camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibration (Operator)

Name

camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibration — Determine all camera parameters by a simultaneous minimization process.

Signature

camera_calibration( : : NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, EstimateParams : CameraParam, NFinalPose, Errors)

Herror T_camera_calibration(const Htuple NX, const Htuple NY, const Htuple NZ, const Htuple NRow, const Htuple NCol, const Htuple StartCamParam, const Htuple NStartPose, const Htuple EstimateParams, Htuple* CameraParam, Htuple* NFinalPose, Htuple* Errors)

void CameraCalibration(const HTuple& NX, const HTuple& NY, const HTuple& NZ, const HTuple& NRow, const HTuple& NCol, const HTuple& StartCamParam, const HTuple& NStartPose, const HTuple& EstimateParams, HTuple* CameraParam, HTuple* NFinalPose, HTuple* Errors)

HCamPar HCamPar::CameraCalibration(const HTuple& NX, const HTuple& NY, const HTuple& NZ, const HTuple& NRow, const HTuple& NCol, const HPoseArray& NStartPose, const HTuple& EstimateParams, HPoseArray* NFinalPose, HTuple* Errors) const

HCamPar HCamPar::CameraCalibration(const HTuple& NX, const HTuple& NY, const HTuple& NZ, const HTuple& NRow, const HTuple& NCol, const HPose& NStartPose, const HTuple& EstimateParams, HPose* NFinalPose, double* Errors) const

static HCamPar HPose::CameraCalibration(const HTuple& NX, const HTuple& NY, const HTuple& NZ, const HTuple& NRow, const HTuple& NCol, const HCamPar& StartCamParam, const HPoseArray& NStartPose, const HTuple& EstimateParams, HPoseArray* NFinalPose, HTuple* Errors)

HCamPar HPose::CameraCalibration(const HTuple& NX, const HTuple& NY, const HTuple& NZ, const HTuple& NRow, const HTuple& NCol, const HCamPar& StartCamParam, const HTuple& EstimateParams, HPose* NFinalPose, double* Errors) const

static void HOperatorSet.CameraCalibration(HTuple NX, HTuple NY, HTuple NZ, HTuple NRow, HTuple NCol, HTuple startCamParam, HTuple NStartPose, HTuple estimateParams, out HTuple cameraParam, out HTuple NFinalPose, out HTuple errors)

HCamPar HCamPar.CameraCalibration(HTuple NX, HTuple NY, HTuple NZ, HTuple NRow, HTuple NCol, HPose[] NStartPose, HTuple estimateParams, out HPose[] NFinalPose, out HTuple errors)

HCamPar HCamPar.CameraCalibration(HTuple NX, HTuple NY, HTuple NZ, HTuple NRow, HTuple NCol, HPose NStartPose, HTuple estimateParams, out HPose NFinalPose, out double errors)

static HCamPar HPose.CameraCalibration(HTuple NX, HTuple NY, HTuple NZ, HTuple NRow, HTuple NCol, HCamPar startCamParam, HPose[] NStartPose, HTuple estimateParams, out HPose[] NFinalPose, out HTuple errors)

HCamPar HPose.CameraCalibration(HTuple NX, HTuple NY, HTuple NZ, HTuple NRow, HTuple NCol, HCamPar startCamParam, HTuple estimateParams, out HPose NFinalPose, out double errors)

Description

camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration performs the calibration of a single camera. For this, known 3D model points (with coordinates NXNXNXNXNX, NYNYNYNYNY, NZNZNZNZNZ) are projected into the image and the sum of the squared distances between the projected 3D-coordinates and their corresponding image point coordinates (NRowNRowNRowNRowNRow, NColNColNColNColNCol) is minimized.

As initial values for the minimization process the external (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose) and internal (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) camera parameters are used. Thereby NStartPoseNStartPoseNStartPoseNStartPoseNStartPose is an ordered tuple with all initial values for the external camera parameters given in the form , where ccs denotes the camera coordinate system and wcs the world coordinate system (see Transformations / Poses and “Solution Guide III-C - 3D Vision”). Individual camera parameters can be explicitly included or excluded from the minimization with EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams. For a detailed description of the available camera models, the different sets of internal camera parameters, and general requirements for the setup, see Calibration.

For a successful calibration, at least one calibration object with accurately known metric properties is needed, e.g., a HALCON calibration plate. Before calling camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration, take a series of images of the calibration object in different orientations and make sure that the whole field of view or measurement volume is covered. The success of the calibration highly depends on the quality of the calibration object and the images. So you might want to exercise special diligence during the acquisition of the calibration images. See the section “How to take a set of suitable images?” in Calibration for further details.

After a successful calibration, camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration returns the optimized internal (CameraParamCameraParamCameraParamCameraParamcameraParam) and external (NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose ) camera parameters of the camera. Additionally, the root mean square error (RMSE) of the back projection of the optimization is returned in ErrorsErrorsErrorsErrorserrors (in pixels). This error gives a general indication whether the optimization was successful.

Preparation of the calibration process

How to extract the calibration marks in the images?

If a HALCON calibration plate is used, you can use the operator find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject to determine the coordinates of the calibration marks in each image and to compute a rough estimate for the external camera parameters. Using HALCON calibration plates with rectangularly arranged marks (see gen_caltabgen_caltabGenCaltabGenCaltabGenCaltab), a combination of the two operators find_caltabfind_caltabFindCaltabFindCaltabFindCaltab and find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose will have the same effect. In both cases, the hereby obtained values can directly be used as initial values for the external camera parameters (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose).

Obviously, images in which the segmentation of the calibration plate (find_caltabfind_caltabFindCaltabFindCaltabFindCaltab) has failed or the calibration marks have not been determined successfully by find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose or find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject should not be used.

How do you get the required initial values for the calibration?

If you use a HALCON calibration plate, the input parameters NXNXNXNXNX, NYNYNYNYNY, and NZNZNZNZNZ are stored in the description file of the calibration plate. You can easily access them by calling the operator caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints. Initial values for the internal camera parameters (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) can be obtained from the specifications of the used camera. Further information can be found in Calibration. Initial values for the poses of the calibration plate and the coordinates of the calibration marks NRowNRowNRowNRowNRow and NColNColNColNColNCol can be calculated using the operator find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject. The tuple NStartPoseNStartPoseNStartPoseNStartPoseNStartPose is set by the concatenation of all these poses.

Which camera parameters are estimated?

The input parameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams is used to select which camera parameters to estimate. Usually, this parameter is set to 'all'"all""all""all""all", i.e., all 6 external camera parameters (translation and rotation) and all internal camera parameters are determined. If the internal camera parameters already have been determined (e.g., by a previous call to camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration), it is often desired to only determine the pose of the world coordinate system in camera coordinates (i.e., the external camera parameters). In this case, EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams can be set to 'pose'"pose""pose""pose""pose". This has the same effect as EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams = ['alpha','beta','gamma','transx','transy','transz']["alpha","beta","gamma","transx","transy","transz"]["alpha","beta","gamma","transx","transy","transz"]["alpha","beta","gamma","transx","transy","transz"]["alpha","beta","gamma","transx","transy","transz"]. Otherwise, EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams contains a tuple of strings that indicates the combination of parameters to estimate. In addition, parameters can be excluded from estimation by using the prefix ~. For example, the values ['pose','~transx']["pose","~transx"]["pose","~transx"]["pose","~transx"]["pose","~transx"] have the same effect as ['alpha','beta','gamma','transy','transz']["alpha","beta","gamma","transy","transz"]["alpha","beta","gamma","transy","transz"]["alpha","beta","gamma","transy","transz"]["alpha","beta","gamma","transy","transz"]. As a different example, ['all','~focus']["all","~focus"]["all","~focus"]["all","~focus"]["all","~focus"] determines all internal and external parameters except the focus. The prefix ~ can be used with all parameter values except 'all'.

Which limitations exist for the determination of the camera parameters?

For additional information about general limitations when determining camera parameters, please see the section “Further Limitations Related to Specific Camera Types” in the chapter Calibration.

What is the order within the individual parameters?

The length of the tuple NStartPoseNStartPoseNStartPoseNStartPoseNStartPose depends on the number of calibration images, e.g., using 15 images leads to a length of the tuple NStartPoseNStartPoseNStartPoseNStartPoseNStartPose equal to (15 times the 7 external camera parameters). The first 7 values correspond to the pose of the calibration plate in the first image, the next 7 values to the pose in the second image, etc.

This fixed number of calibration images must be considered within the tuples with the coordinates of the 3D model marks and the extracted 2D marks. If 15 images are used, the length of the tuples NRowNRowNRowNRowNRow and NColNColNColNColNCol is 15 times the length of the tuples with the coordinates of the 3D model marks (NXNXNXNXNX, NYNYNYNYNY, and NZNZNZNZNZ). If every image consists 49 marks, the length of the tuples NRowNRowNRowNRowNRow and NColNColNColNColNCol is , while the length of the tuples NXNXNXNXNX, NYNYNYNYNY, and NZNZNZNZNZ is 49. The order of the values in NRowNRowNRowNRowNRow and NColNColNColNColNCol is “image after image”, i.e., using 49 marks the first 3D model point corresponds to the 1st, 50th, 99th, 148th, 197th, 246th, etc. extracted 2D mark.

What is the meaning of the output parameters?

If the camera calibration process has finished successfully, the output parameters CameraParamCameraParamCameraParamCameraParamcameraParam and NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose contain the adjusted values for the internal and external camera parameters. The length of the tuple NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose corresponds to the length of the tuple NStartPoseNStartPoseNStartPoseNStartPoseNStartPose.

The representation types of NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose correspond to the representation type of the first tuple of NStartPoseNStartPoseNStartPoseNStartPoseNStartPose (see create_posecreate_poseCreatePoseCreatePoseCreatePose). You can convert the representation type by convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseType.

As an additional parameter, the root mean square error (RMSE) (ErrorsErrorsErrorsErrorserrors) of the back projection of the optimization is returned. This parameter reflects the accuracy of the calibration. The error value (root mean square error of the position) is measured in pixels. If only a single camera is calibrated, an Error in the order of 0.1 pixel (the typical detection error by extraction of the coordinates of the projected calibration markers) is an indication that the optimization fits the observation data well. If ErrorsErrorsErrorsErrorserrors strongly differs from 0.1 pixels, the calibration did not perform well. Reasons for this might be, e.g., a poor image quality, an insufficient number of calibration images, or an inaccurate calibration plate.

Do I have to use a planar calibration object?

No. The operator camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration is designed in a way that the input tuples NXNXNXNXNX, NYNYNYNYNY, NZNZNZNZNZ, NRowNRowNRowNRowNRow, and NColNColNColNColNCol can contain any 3D/2D correspondences. The order of the single parameters is explained in the paragraph “What is the order within the individual parameters?”.

Thus, it makes no difference how the required 3D model marks and the corresponding 2D marks are determined. On the one hand, it is possible to use a 3D calibration object, on the other hand, you also can use any characteristic points (e.g. natural landmarks) with known position in the world. By setting EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams to 'pose'"pose""pose""pose""pose", it is thus possible to compute the pose of an object in camera coordinates! For this, at least three 3D/2D-correspondences are necessary as input. NStartPoseNStartPoseNStartPoseNStartPoseNStartPose can, e.g., be generated directly as shown in the program example for create_posecreate_poseCreatePoseCreatePoseCreatePose.

Attention

The minimization process of the calibration depends on the initial values of the internal (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) and external (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose) camera parameters. The computed average errors ErrorsErrorsErrorsErrorserrors give an impression of the accuracy of the calibration. The errors (deviations in x- and y-coordinates) are measured in pixels.

For line scan cameras, it is possible to set the start value for the internal camera parameter Sy to the value 0.0. In this case, it is not possible to determine the position of the principal point in y-direction. Therefore, EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams must contain the term '~cy'"~cy""~cy""~cy""~cy". The effective distance of the principle point from the sensor line is then always . Further information can be found in the section “Further Limitations Related to Specific Camera Types” of Calibration.

Execution Information

Parameters

NXNXNXNXNX (input_control)  number-array HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all x coordinates of the calibration marks (in meters).

NYNYNYNYNY (input_control)  number-array HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all y coordinates of the calibration marks (in meters).

Number of elements: NY == NX

NZNZNZNZNZ (input_control)  number-array HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all z coordinates of the calibration marks (in meters).

Number of elements: NZ == NX

NRowNRowNRowNRowNRow (input_control)  number-array HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all row coordinates of the extracted calibration marks (in pixels).

NColNColNColNColNCol (input_control)  number-array HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all column coordinates of the extracted calibration marks (in pixels).

Number of elements: NCol == NRow

StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam (input_control)  campar HCamPar, HTupleHTupleHtuple (real / integer / string) (double / int / long / string) (double / Hlong / HString) (double / Hlong / char*)

Initial values for the internal camera parameters.

NStartPoseNStartPoseNStartPoseNStartPoseNStartPose (input_control)  pose(-array) HPose, HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all initial values for the external camera parameters.

Number of elements: NStartPose == 7 * NRow / NX

EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams (input_control)  string-array HTupleHTupleHtuple (string) (string) (HString) (char*)

Camera parameters to be estimated.

Default value: 'all' "all" "all" "all" "all"

List of values: 'all'"all""all""all""all", 'alpha'"alpha""alpha""alpha""alpha", 'beta'"beta""beta""beta""beta", 'camera'"camera""camera""camera""camera", 'cx'"cx""cx""cx""cx", 'cy'"cy""cy""cy""cy", 'focus'"focus""focus""focus""focus", 'gamma'"gamma""gamma""gamma""gamma", 'image_plane_dist'"image_plane_dist""image_plane_dist""image_plane_dist""image_plane_dist", 'k1'"k1""k1""k1""k1", 'k2'"k2""k2""k2""k2", 'k3'"k3""k3""k3""k3", 'kappa'"kappa""kappa""kappa""kappa", 'magnification'"magnification""magnification""magnification""magnification", 'poly'"poly""poly""poly""poly", 'poly_tan_2'"poly_tan_2""poly_tan_2""poly_tan_2""poly_tan_2", 'pose'"pose""pose""pose""pose", 'sx'"sx""sx""sx""sx", 'sy'"sy""sy""sy""sy", 'tilt'"tilt""tilt""tilt""tilt", 'transx'"transx""transx""transx""transx", 'transy'"transy""transy""transy""transy", 'transz'"transz""transz""transz""transz", 'vx'"vx""vx""vx""vx", 'vy'"vy""vy""vy""vy", 'vz'"vz""vz""vz""vz"

CameraParamCameraParamCameraParamCameraParamcameraParam (output_control)  campar HCamPar, HTupleHTupleHtuple (real / integer / string) (double / int / long / string) (double / Hlong / HString) (double / Hlong / char*)

Internal camera parameters.

NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose (output_control)  pose(-array) HPose, HTupleHTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Ordered tuple with all external camera parameters.

Number of elements: NFinalPose == 7 * NRow / NX

ErrorsErrorsErrorsErrorserrors (output_control)  real(-array) HTupleHTupleHtuple (real) (double) (double) (double)

Average error distance in pixels.

Example (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Example (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Example (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Example (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Example (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Result

camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration returns 2 (H_MSG_TRUE) if all parameter values are correct and the desired camera parameters have been determined by the minimization algorithm. If necessary, an exception is raised.

Possible Predecessors

find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints, read_cam_parread_cam_parReadCamParReadCamParReadCamPar

Possible Successors

write_posewrite_poseWritePoseWritePoseWritePose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3d, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltab

Alternatives

calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCameras

See also

find_caltabfind_caltabFindCaltabFindCaltabFindCaltab, find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltab, write_cam_parwrite_cam_parWriteCamParWriteCamParWriteCamPar, read_cam_parread_cam_parReadCamParReadCamParReadCamPar, create_posecreate_poseCreatePoseCreatePoseCreatePose, convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseType, write_posewrite_poseWritePoseWritePoseWritePose, read_poseread_poseReadPoseReadPoseReadPose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3d, hom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPoseHomMat3dToPose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints, gen_caltabgen_caltabGenCaltabGenCaltabGenCaltab, calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCameras

Module

Calibration