| Table of Contents / Calibration / Hand-Eye | Operators |
hand_eye_calibration — Perform a hand-eye calibration.
hand_eye_calibration( : : X, Y, Z, Row, Col, NumPoints, RobotPoses, CameraParam, Method, QualityType : CameraPose, CalibrationPose, Quality)
The operator hand_eye_calibration determines the 3D pose of a robot (“hand”) relative to a camera (“eye”). With this information, the results of image processing can be transformed into the coordinate system of the robot which can then, e.g., grasp an inspected part. There are two possible configurations of robot-camera (hand-eye) systems: The camera can be mounted on the robot or be stationary and observe the robot. Note that the term robot is used in place for a mechanism that moves objects. Thus, you can use hand_eye_calibration to calibrate many different systems, from pan-tilt heads to multi-axis manipulators.
In essence, systems suitable for hand-eye calibration are described by a closed chain of four Euclidian transformations. In this chain two non-consecutive transformations are either known from the robot controller or computed from calibration points seen by a camera system. The two other constant transformations are computed by the hand-eye calibration procedure.
A hand-eye calibration is performed similarly to the calibration of the external camera parameters (see camera_calibration): You acquire a set of images of a calibration object, determine correspondences between known calibration points and their projection in the images and pass them to hand_eye_calibration via the parameters X, Y, Z, Row, Col, and NumPoints. If you use the standard calibration plate, the correspondences can be determined very easily with the operators find_caltab and find_marks_and_pose. Furthermore, the camera is identical for the complete calibration sequence and is specified by the internal camera parameters in CameraParam. The internal camera parameters are calibrated beforehand deploying the operator calibrate_cameras or camera_calibration.
In contrast to the camera calibration, the calibration object is not moved manually. This task is delegated to the robot, which either moves the camera (mounted camera) or the calibration object (stationary camera). The robot's movements are assumed to be known and therefore are also used as an input for the calibration (parameter RobotPoses).
The output of hand_eye_calibration are the two poses CameraPose and CalibrationPose. Their pose type is identical to the pose type of the first input robot pose.
Basically, two hand-eye configurations can be distinguished and are discussed in more detail below, followed by general information about the process of hand-eye calibration.
In this configuration, the calibration object remains stationary and the camera is moved to different positions by the robot. The main idea behind the hand-eye calibration is that the information extracted from a calibration image, i.e., the pose of the calibration object relative to the camera (i.e., the external camera parameters), can be seen as a chain of poses or homogeneous transformation matrices, from the calibration object via the base of the robot to its tool (end-effector) and finally to the camera:
Moving camera: H(cam<-cal) = H(cam<-tool) * H(tool<-base) * H(base<-cal)
| | |
CameraPose RobotPoses CalibrationPose
From the set of calibration images, the operator hand_eye_calibration determines the two transformations at the ends of the chain, i.e., the pose of the robot tool in camera coordinates (H(cam<-tool),CameraPose) and the pose of the calibration object in the robot base coordinate system (H(base<-cal),CalibrationPose).
In contrast, the transformation in the middle of the chain, H(tool<-base), is known but changes for each calibration image, because it describes the pose of the robot moving the camera, or to be more exact its inverse pose (pose of the base coordinate system in robot tool coordinates). You must specify the inverse robot poses in the calibration images in the parameter RobotPoses.
In this configuration, the robot grasps the calibration object and moves it in front of the camera. Again, the information extracted from a calibration image, i.e., the pose of the calibration object in camera coordinates (the external camera parameters), are equal to a chain of poses or homogeneous transformation matrices, this time from the calibration object via the robot's tool to its base and finally to the camera:
Stationary camera: H(cam<-cal) = H(cam<-base) * H(base<-tool) * H(tool<-cal)
| | |
CameraPose RobotPoses CalibrationPose
Analogously to the configuration with a moving camera, the operator hand_eye_calibration determines the two transformations at the ends of the chain, here the pose of the robot base coordinate system in camera coordinates (H(cam<-base),CameraPose) and the pose of the calibration object relative to the robot tool (H(tool<-cal),CalibrationPose).
The transformation in the middle of the chain, H(base<-tool), describes the pose of the robot moving the calibration object, i.e., the pose of the tool relative to the base coordinate system. You must specify the robot poses in the calibration images in the parameter RobotPoses.
The following sections discuss individual questions arising from the use of hand_eye_calibration. They are intended to be a guideline for using the operator in an application, as well as to help understanding the operator.
How do I get 3D calibration points and their projections?
3D calibration points given in the world coordinate system (X, Y, Z) and their associated projections in the image (Row, Col) form the basis of the hand-eye calibration. In order to be able to perform a successful hand-eye calibration, you need at least three images of the 3D calibration points that were obtained under different poses of the manipulator. In each image at least four points must be available, in order to compute internally the pose transferring the calibration points from their world coordinate system into the camera coordinate system.
In principle, you can use arbitrary known points for the calibration. However, it is usually most convenient to use the standard calibration plate, e.g., the one that can be generated with gen_caltab. In this case, you can use the operators find_caltab and find_marks_and_pose to extract the position of the calibration plate and of the calibration marks and the operator caltab_points to read the 3D coordinates of the calibration marks (see also the description of camera_calibration).
The parameter NumPoints specifies the number of 3D calibration points used for each pose of the manipulator, i.e., for each image. With this, the 3D calibration points which are stored in a linearized fashion in X, Y, Z, and their corresponding projections (Row, Col) can be associated with the corresponding pose of the manipulator (RobotPoses). Note that in contrast to the operator camera_calibration the 3D coordinates of the calibration points must be specified for each calibration image, not only once, and thus can vary for each image of the sequence.
How do I acquire a suitable set of images?
The following conditions, especially if using a standard calibration plate, should be considered:
The position of the calibration markers (moving camera: relative to the robot's base; stationary camera: relative to the robot's tool) and the position of the camera (moving camera: relative to the robot's tool; stationary camera: relative to the robot's base) must not be changed between the images.
The internal camera parameters (CameraParam) must be constant and must be determined in a previous camera calibration step (see camera_calibration). Note that changes of the image size, the focal length, the aperture, or the focus cause a change of the internal camera parameters.
The theoretical lower limit of the number of image to acquire is three. Nevertheless, it is recommended to have 10 or more images at hand, in which the position of the camera or the robot hand are sufficiently different. The amount of rotation between the images is essential and should be at least 30 degrees or better 60 degrees. The rotations between the images must exhibit at least two different axes of rotation. Very different orientations lead to precise calibration results.
In each image, the calibration plate must be completely visible (including its border).
Reflections or other disturbances should not impair the detection of the calibration plate and its markers.
If individual markers instead of the standard calibration plate are used at least four markers must be present in each image.
In each image, the calibration plate should at least fill one quarter of the entire image for a precise computation of the calibration to camera transformation, which is performed internally during hand-eye calibration.
As mentioned, the camera must not be modified between the acquisition of the individual images. Please make sure that the focus is sufficient for the expected changes of the camera to calibration plate distance. Therefore, bright lighting conditions for the calibration plate are important, because then you can use smaller apertures, which result in a larger depth of focus.
How do I obtain the poses of the robot?
In the parameter RobotPoses you must pass the poses of the robot in the calibration images (moving camera: pose of the robot base in robot tool coordinates; stationary camera: pose of the robot tool in robot base coordinates) in a linearized fashion. We recommend to create the robot poses in a separate program and save in files using write_pose. In the calibration program you can then read and accumulate them in a tuple as shown in the example program below. In addition, we recommend to save the pose of the robot tool in robot base coordinates independent of the hand-eye configuration. When using a moving camera, you then invert the read poses before accumulating them. This is also shown in the example program.
Via the cartesian interface of the robot, you can typically obtain the pose of the tool in base coordinates in a notation that corresponds to the pose representations with the codes 0 or 2 (OrderOfRotation = 'gba' or 'abg', see create_pose). In this case, you can directly use the pose values obtained from the robot as input for create_pose.
If the cartesian interface of your robot describes the orientation in a different way, e.g., with the representation ZYZ (Rz(phi1) * Ry(phi2) * Rz(phi3)), you can create the corresponding homogeneous transformation matrix step by step using the operators hom_mat3d_rotate and hom_mat3d_translate and then convert the matrix into a pose using hom_mat3d_to_pose. The following example code creates a pose from the ZYZ representation described above:
hom_mat3d_identity (HomMat3DIdent) hom_mat3d_rotate (HomMat3DIdent, phi3, 'z', 0, 0, 0, HomMat3DRotZ) hom_mat3d_rotate (HomMat3DRotZ, phi2, 'y', 0, 0, 0, HomMat3DRotZY) hom_mat3d_rotate (HomMat3DRotZY, phi1, 'z', 0, 0, 0, HomMat3DRotZYZ) hom_mat3d_translate (HomMat3DRotZYZ, Tx, Ty, Tz, base_H_tool) hom_mat3d_to_pose (base_H_tool, RobPose)
Please note that the hand-eye calibration only works if the robot poses RobotPoses are specified with high accuracy!
What is the order of the individual parameters?
The length of the tuple NumPoints corresponds to the number of different positions of the manipulator and thus to the number of calibration images. The parameter NumPoints determines the number of calibration points used in the individual positions. If the standard calibration plate is used, this means 49 points per position (image). If, for example, 15 images were acquired, NumPoints is a tuple of length 15, where all elements of the tuple have the value 49.
The number of images in the sequence, which is determined by the length of NumPoints, must also be taken into account for the tuples of the 3D calibration points and the extracted 2D markers, respectively. Hence, for 15 calibration images with 49 calibration points each, the tuples X, Y, Z, Row, and Col must contain 15*49=735 values each. These tuples are ordered according to the image the respective points lie in, i.e., the first 49 values correspond to the 49 calibration points in the first image. The order of the 3D calibration points and the extracted 2D calibration points must be the same in each image.
The length of the tuple RobotPoses also depends on the number of calibration images. If, for example, 15 images and therefore 15 poses are used, the length of the tuple RobotPoses is 15*7=105 (15 times 7 pose parameters). The first seven parameters thus determine the pose of the manipulator in the first image, and so on.
Algorithm and output parameter
The parameter Method determines the type of algorithm used for the hand-eye calibration: With 'linear' a linear algorithm is chosen, which is fast but in many practical situations not accurate enough. 'nonlinear' selects a non-linear algorithm, which results in the most accurately calibrated poses and which is the method of choice.
The parameter QualityType switches between different possibilities for assessing the quality of the calibration result returned in Quality. 'error_pose' stands for the pose error of the complete chain of transformations. To be more precise, a tuple with four elements is returned, where the first element is the root-mean-square error of the translational part, the second element is the root-mean-square error of the rotational part, the third element is the maximum translational error and the fourth element is the maximum rotational error. With 'standard_deviation', a tuple with 12 elements containing the standard deviations of the two poses is returned: The first six elements refer to the camera pose and the others to the pose of the calibration points. With 'covariance', the full 12x12 covariance matrix of both poses is returned. Note that selecting 'linear' for the parameter Method enables only the output of the pose error ('error_pose').
Linear list containing all the x coordinates of the calibration points (in the order of the images).
Linear list containing all the y coordinates of the calibration points (in the order of the images).
Linear list containing all the z coordinates of the calibration points (in the order of the images).
Linear list containing all row coordinates of the calibration points (in the order of the images).
Linear list containing all the column coordinates of the calibration points (in the order of the images).
Number of the calibration points for each image.
Known 3D pose of the robot for each image (moving camera: robot base in robot tool coordinates; stationary camera: robot tool in robot base coordinates).
Internal camera parameters.
Method of hand-eye calibration.
Default value: 'nonlinear'
List of values: 'linear', 'nonlinear'
Type of quality assessment.
Default value: 'error_pose'
List of values: 'error_pose', 'standard_deviation', 'covariance'
Computed relative camera pose: 3D pose of the robot tool (moving camera) or robot base (stationary camera), respectively, in camera coordinates.
Computed 3D pose of the calibration points in robot base coordinates (moving camera) or in robot tool coordinates (stationary camera), respectively.
Quality assessment of the result.
read_cam_par('campar.dat', CameraParam)
CalDescr := 'caltab.descr'
caltab_points(CalDescr, X, Y, Z)
* process all calibration images
for i := 0 to NumImages-1 by 1
read_image(Image, 'calib_'+i$'02d')
* find marks on the calibration plate in every image
find_caltab(Image, CalPlate, CalDescr, 3, 150, 5)
find_marks_and_pose(Image, CalPlate, CalDescr, CameraParam, 128, 10, 18, \
0.9, 15, 100, RCoordTmp, CCoordTmp, StartPose)
* accumulate 2D and 3D coordinates of the marks
RCoord := [RCoord, RCoordTmp]
CCoord := [CCoord, CCoordTmp]
XCoord := [XCoord, X]
YCoord := [YCoord, Y]
ZCoord := [ZCoord, Z]
NumMarker := [NumMarker, |RCoordTmp|]
* read pose of the robot tool in robot base coordinates
read_pose('robpose_'+i$'02d'+'.dat', RobPose)
* moving camera? invert pose
if (IsMovingCameraConfig='true')
pose_to_hom_mat3d(RobPose, base_H_tool)
hom_mat3d_invert(base_H_tool, tool_H_base)
hom_mat3d_to_pose(tool_H_base, RobPose)
endif
* accumulate robot poses
RobotPoses := [RobotPoses, RobPose]
endfor
*
* perform hand-eye calibration
*
hand_eye_calibration(XCoord, YCoord, ZCoord, RCoord, CCoord, NumMarker, \
RobotPoses, CameraParam, 'nonlinear', 'error_pose', \
CameraPose, CalibrationPose, Error)
The operator hand_eye_calibration returns the value H_MSG_2 (H_MSG_TRUE) if the given parameters are correct. Otherwise, an exception will be raised.
write_pose, convert_pose_type, pose_to_hom_mat3d, disp_caltab, sim_caltab
find_caltab, find_marks_and_pose, disp_caltab, sim_caltab, write_cam_par, read_cam_par, create_pose, convert_pose_type, write_pose, read_pose, pose_to_hom_mat3d, hom_mat3d_to_pose, caltab_points, gen_caltab
Calibration
| Table of Contents / Calibration / Hand-Eye | Operators |
| HALCON Reference Manual 10.0.2 | Copyright © 1996-2011 MVTec Software GmbH |