HALCON Reference Manual 10.0.2
Name
gen_image_to_world_plane_mapT_gen_image_to_world_plane_mapgen_image_to_world_plane_mapGenImageToWorldPlaneMapGenImageToWorldPlaneMap — Generate a projection map that describes the mapping between the image
plane and a the plane z=0 of a world coordinate system.
Herror gen_image_to_world_plane_map(Hobject* Map, const HTuple& CameraParam, const HTuple& WorldPose, const HTuple& WidthIn, const HTuple& HeightIn, const HTuple& WidthMapped, const HTuple& HeightMapped, const HTuple& Scale, const HTuple& MapType)
HImage HImage::GenImageToWorldPlaneMap(const HTuple& CameraParam, const HTuple& WorldPose, const HTuple& WidthIn, const HTuple& HeightIn, const HTuple& WidthMapped, const HTuple& HeightMapped, const HTuple& Scale, const HTuple& MapType)
void HOperatorSetX.GenImageToWorldPlaneMap(
[out] IHUntypedObjectX** Map, [in] VARIANT CameraParam, [in] VARIANT WorldPose, [in] VARIANT WidthIn, [in] VARIANT HeightIn, [in] VARIANT WidthMapped, [in] VARIANT HeightMapped, [in] VARIANT Scale, [in] VARIANT MapType)
IHImageX* HPoseX.GenImageToWorldPlaneMap(
[in] VARIANT CameraParam, [in] VARIANT WorldPose, [in] Hlong WidthIn, [in] Hlong HeightIn, [in] Hlong WidthMapped, [in] Hlong HeightMapped, [in] VARIANT Scale, [in] BSTR MapType)
void HImageX.GenImageToWorldPlaneMap(
[in] VARIANT CameraParam, [in] VARIANT WorldPose, [in] Hlong WidthIn, [in] Hlong HeightIn, [in] Hlong WidthMapped, [in] Hlong HeightMapped, [in] VARIANT Scale, [in] BSTR MapType)
static void HOperatorSet.GenImageToWorldPlaneMap(out HObject map, HTuple cameraParam, HTuple worldPose, HTuple widthIn, HTuple heightIn, HTuple widthMapped, HTuple heightMapped, HTuple scale, HTuple mapType)
HImage HPose.GenImageToWorldPlaneMap(HTuple cameraParam, int widthIn, int heightIn, int widthMapped, int heightMapped, HTuple scale, string mapType)
HImage HPose.GenImageToWorldPlaneMap(HTuple cameraParam, int widthIn, int heightIn, int widthMapped, int heightMapped, string scale, string mapType)
void HImage.GenImageToWorldPlaneMap(HTuple cameraParam, HPose worldPose, int widthIn, int heightIn, int widthMapped, int heightMapped, HTuple scale, string mapType)
void HImage.GenImageToWorldPlaneMap(HTuple cameraParam, HPose worldPose, int widthIn, int heightIn, int widthMapped, int heightMapped, string scale, string mapType)
gen_image_to_world_plane_mapgen_image_to_world_plane_mapgen_image_to_world_plane_mapGenImageToWorldPlaneMapGenImageToWorldPlaneMap generates a projection map MapMapMapMapmap,
which describes the mapping between the image plane and the plane z=0
(plane of measurements) in a world coordinate system. This map can be used
to rectify an image with the operator map_imagemap_imagemap_imageMapImageMapImage. The rectified
image shows neither radial nor perspective distortions; it corresponds to an
image acquired by a distortion-free camera that looks perpendicularly onto
the plane of measurements. The world coordinate system is chosen by passing
its 3D pose relative to the camera coordinate system in
WorldPoseWorldPoseWorldPoseWorldPoseworldPose. In CameraParamCameraParamCameraParamCameraParamcameraParam you must pass the internal camera
parameters (see write_cam_parwrite_cam_parwrite_cam_parWriteCamParWriteCamPar for the sequence of the parameters and
the underlying camera model).
In many cases CameraParamCameraParamCameraParamCameraParamcameraParam and WorldPoseWorldPoseWorldPoseWorldPoseworldPose are the result of
calibrating the camera with the operator calibrate_camerascalibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCameras. See
below for an example.
The size of the images to be mapped can be specified by the parameters
WidthInWidthInWidthInWidthInwidthIn and HeightInHeightInHeightInHeightInheightIn. The pixel position of the upper left
corner of the output image is determined by the origin of the world
coordinate system. The size of the output image can be choosen by the
parameters WidthMappedWidthMappedWidthMappedWidthMappedwidthMapped, HeightMappedHeightMappedHeightMappedHeightMappedheightMapped, and
ScaleScaleScaleScalescale. WidthMappedWidthMappedWidthMappedWidthMappedwidthMapped and HeightMappedHeightMappedHeightMappedHeightMappedheightMapped must be given
in pixels.
With the parameter ScaleScaleScaleScalescale you can specify the size of a pixel in the
transformed image. There are two typical scenarios: First, you can scale the
image such that pixel coordinates in the transformed image directly
correspond to metric units, e.g., that one pixel corresponds to one
micron. This is useful if you want to perform measurements in the transformed
image which will then directly result in metric results. The second scenario
is to scale the image such that its content appears in a size similar to the
original image. This is useful, e.g., if you want to perform shape-based
matching in the transformed image.
ScaleScaleScaleScalescale must be specified as the ratio desired pixel
size/original unit. A pixel size of 1um means that a pixel in the
transformed image corresponds to the area 1um x 1um in the
plane of measurements. The original unit is determined by the coordinates of
the calibration object. If the original unit is meters (which is the case if
you use the standard calibration plate), you can use the parameter values
'm'"m""m""m""m", 'cm'"cm""cm""cm""cm", 'mm'"mm""mm""mm""mm", 'microns'"microns""microns""microns""microns", or
'um'"um""um""um""um" to directly set the unit of pixel coordinates in the
transformed image.
The mapping function is stored in the output image MapMapMapMapmap.
MapMapMapMapmap has the same size as the resulting images after the mapping.
MapTypeMapTypeMapTypeMapTypemapType is used to specify the type of the output MapMapMapMapmap.
If 'nearest_neighbor'"nearest_neighbor""nearest_neighbor""nearest_neighbor""nearest_neighbor" is chosen, MapMapMapMapmap consists of one image
containing one channel, in which for each pixel of the resulting image the
linearized coordinate of the pixel of the input image is stored that is the
nearest neighbor to the transformed coordinates. If 'bilinear'"bilinear""bilinear""bilinear""bilinear"
interpolation is chosen, MapMapMapMapmap consists of one image containing five
channels. In the first channel for each pixel in the resulting image the
linearized coordinates of the pixel in the input image is stored that is in
the upper left position relative to the transformed coordinates.
The four other channels contain the weights of the four neighboring pixels
of the transformed coordinates which are used for the bilinear interpolation,
in the following order:
+---+---+
| 2 | 3 |
+---+---+
| 4 | 5 |
+---+---+
The second channel, for example, contains the weights of the pixels that
lie to the upper left relative to the transformed coordinates.
If 'coordinate_map_sub_pix'"coordinate_map_sub_pix""coordinate_map_sub_pix""coordinate_map_sub_pix""coordinate_map_sub_pix" is chosen, MapMapMapMapmap consists of
one vector field image, in which for each pixel of the resulting image
the subpixel precise coordinates in the input image are stored.
If several images have to be mapped using the same camera parameters,
gen_image_to_world_plane_mapgen_image_to_world_plane_mapgen_image_to_world_plane_mapGenImageToWorldPlaneMapGenImageToWorldPlaneMap in combination with map_imagemap_imagemap_imageMapImageMapImage is
much more efficient than the operator image_to_world_planeimage_to_world_planeimage_to_world_planeImageToWorldPlaneImageToWorldPlane because
the mapping function needs to be computed only once.
If you want to re-use the created map in another program, you can save it as
a multi-channel image with the operator write_imagewrite_imagewrite_imageWriteImageWriteImage, using the format
'tiff'"tiff""tiff""tiff""tiff".
- Multithreading type: reentrant (runs in parallel with non-exclusive operators).
- Multithreading scope: global (may be called from any thread).
- Processed without parallelization.
Image containing the mapping data.
Internal camera parameters.
Number of elements: ((CameraParam == 8) || (CameraParam == 11)) || (CameraParam == 12)
3D pose of the world coordinate system in camera
coordinates.
Number of elements: 7
Width of the images to be transformed.
Restriction: WidthIn >= 1
Height of the images to be transformed.
Restriction: HeightIn >= 1
Width of the resulting mapped images in pixels.
Restriction: WidthMapped >= 1
Height of the resulting mapped images in pixels.
Restriction: HeightMapped >= 1
ScaleScaleScaleScalescale (input_control) number → HTupleHTupleVARIANTHtuple (string / integer / real) (string / int / long / double) (char* / Hlong / double) (BSTR / Hlong / double) (char* / Hlong / double)
Scale or unit.
Default value:
'm'
"m"
"m"
"m"
"m"
Suggested values: 'm'"m""m""m""m", 'cm'"cm""cm""cm""cm", 'mm'"mm""mm""mm""mm", 'microns'"microns""microns""microns""microns", 'um'"um""um""um""um", 1.0, 0.01, 0.001, 1.0e-6, 0.0254, 0.3048, 0.9144
Type of the mapping.
Default value:
'bilinear'
"bilinear"
"bilinear"
"bilinear"
"bilinear"
List of values: 'nearest_neighbor'"nearest_neighbor""nearest_neighbor""nearest_neighbor""nearest_neighbor", 'bilinear'"bilinear""bilinear""bilinear""bilinear", 'coord_map_sub_pix'"coord_map_sub_pix""coord_map_sub_pix""coord_map_sub_pix""coord_map_sub_pix"
* perform camera calibration (with standard calibration plate)
camera_calibration(NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, \
'all', FinalCamParam, NFinalPose, Errors)
* world coordinate system is defined by calibration plate in first image
FinalPose1 := NFinalPose[0:6]
* compensate thickness of plate
set_origin_pose(FinalPose1, 0, 0, 0.000073, WorldPose)
* goal: rectify images
* first determine parameters such that the entire image content is visible
* -> transform image boundary into world plane, determine smallest
* rectangle around it
get_image_pointer1(Image, Pointer, Type, Width, Height)
gen_rectangle1 (ImageRect, 0, 0, Height-1, Width-1)
gen_contour_region_xld (ImageRect, ImageBorder, 'border')
contour_to_world_plane_xld(ImageBorder, ImageBorderWCS, FinalCamParam, \
WorldPose, 1)
smallest_rectangle1_xld (ImageBorderWCS, MinY, MinX, MaxY, MaxX)
* -> move the pose to the upper left corner of the surrounding rectangle
set_origin_pose(WorldPose, MinX, MinY, 0, PoseForEntireImage)
* -> determine the scaling factor such that the center pixel has the same
* size in the original and in the rectified image
* method: transform corner points of the pixel into the world
* coordinate system, compute their distances, and use their
* mean as the scaling factor
image_points_to_world_plane(FinalCamParam, PoseForEntireImage, \
[Height/2, Height/2, Height/2+1], \
[Width/2, Width/2+1, Width/2], \
1, WorldPixelX, WorldPixelY)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[1], WorldPixelX[1], \
WorldLength1)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[2], WorldPixelX[2], \
WorldLength2)
ScaleForSimilarPixelSize := (WorldLength1+WorldLength2)/2
* -> determine output image size such that entire input image fits into it
ExtentX := MaxX-MinX
ExtentY := MaxY-MinY
WidthRectifiedImage := ExtentX/ScaleForSimilarPixelSize
HeightRectifiedImage := ExtentY/ScaleForSimilarPixelSize
* create mapping with the determined parameters
gen_image_to_world_plane_map(Map, FinalCamParam, PoseForEntireImage, \
Width, Height, \
WidthRectifiedImage, HeightRectifiedImage, \
ScaleForSimilarPixelSize, 'bilinear')
* transform grabbed images with the created map
while(1)
grab_image_async(Image, AcqHandle, -1)
map_image(Image, Map, RectifiedImage)
endwhile
* perform camera calibration (with standard calibration plate)
camera_calibration(NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, \
'all', FinalCamParam, NFinalPose, Errors)
* world coordinate system is defined by calibration plate in first image
FinalPose1 := NFinalPose[0:6]
* compensate thickness of plate
set_origin_pose(FinalPose1, 0, 0, 0.000073, WorldPose)
* goal: rectify images
* first determine parameters such that the entire image content is visible
* -> transform image boundary into world plane, determine smallest
* rectangle around it
get_image_pointer1(Image, Pointer, Type, Width, Height)
gen_rectangle1 (ImageRect, 0, 0, Height-1, Width-1)
gen_contour_region_xld (ImageRect, ImageBorder, 'border')
contour_to_world_plane_xld(ImageBorder, ImageBorderWCS, FinalCamParam, \
WorldPose, 1)
smallest_rectangle1_xld (ImageBorderWCS, MinY, MinX, MaxY, MaxX)
* -> move the pose to the upper left corner of the surrounding rectangle
set_origin_pose(WorldPose, MinX, MinY, 0, PoseForEntireImage)
* -> determine the scaling factor such that the center pixel has the same
* size in the original and in the rectified image
* method: transform corner points of the pixel into the world
* coordinate system, compute their distances, and use their
* mean as the scaling factor
image_points_to_world_plane(FinalCamParam, PoseForEntireImage, \
[Height/2, Height/2, Height/2+1], \
[Width/2, Width/2+1, Width/2], \
1, WorldPixelX, WorldPixelY)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[1], WorldPixelX[1], \
WorldLength1)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[2], WorldPixelX[2], \
WorldLength2)
ScaleForSimilarPixelSize := (WorldLength1+WorldLength2)/2
* -> determine output image size such that entire input image fits into it
ExtentX := MaxX-MinX
ExtentY := MaxY-MinY
WidthRectifiedImage := ExtentX/ScaleForSimilarPixelSize
HeightRectifiedImage := ExtentY/ScaleForSimilarPixelSize
* create mapping with the determined parameters
gen_image_to_world_plane_map(Map, FinalCamParam, PoseForEntireImage, \
Width, Height, \
WidthRectifiedImage, HeightRectifiedImage, \
ScaleForSimilarPixelSize, 'bilinear')
* transform grabbed images with the created map
while(1)
grab_image_async(Image, AcqHandle, -1)
map_image(Image, Map, RectifiedImage)
endwhile
HImage Image, Map, RectifiedImage;
HFramegrabber AcqHandle;
HTuple NX, NY, NZ, NRow, NCol;
HTuple StartCamParam, NStartPose, FinalCamParam, NFinalPose, Errors;
HTuple FinalPose1, WorldPose, PoseForEntireImage;
HTuple Width, Height, Type, MinX, MinY, MaxX, MaxY;
HTuple UpperLeftX, UpperLeftY, UpperRightX, UpperRightY;
HTuple LowerLeftX, LowerLeftY, WorldLength1, WorldLength2;
HTuple ScaleForSimilarPixelSize, ExtentX, ExtentY;
HTuple WidthRectifiedImage, HeightRectifiedImage;
// perform camera calibration (with standard calibration plate)
camera_calibration(NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, 'all',
&FinalCamParam, &NFinalPose, &Errors);
// world coordinate system is defined by calibration plate in first image
FinalPose1 = NFinalPose(0,6);
// compensate thickness of plate
set_origin_pose(FinalPose1, 0, 0, 0.000073, &WorldPose);
// goal: rectify image
// first determine parameters such that the entire image content is visible
// and that objects have a similar size before and after the rectification
// -> transform image boundary into world plane, determine smallest
// rectangle around it
Image.GetImagePointer1(&Type, &Width, &Height);
HRegion ImageRect = HRegion::GenRectangle1(0, 0, Height-1, Width-1);
HXLDCont ImageBorder = ImageRect.GenContourRegionXld("border");
Hobject ImageBorderWCSObj;
contour_to_world_plane_xld(ImageBorder.Id(), &ImageBorderWCSObj,
FinalCamParam, WorldPose, 1);
HXLDArray ImageBorderWCS(ImageBorderWCSObj);
MinY = ImageBorderWCS.SmallestRectangle1Xld(&MinX, &MaxY, &MaxX);
// -> move the pose to the upper left corner of the surrounding rectangle
set_origin_pose(WorldPose, MinX, MinY, 0, &PoseForEntireImage);
// -> determine the scaling factor such that the center pixel has the same
// size in the original and in the rectified image
// method: transform corner points of the pixel into the world
// coordinate system, compute their distances, and use their
// mean as the scaling factor
image_points_to_world_plane(FinalCamParam, PoseForEntireImage,
Height/2, Width/2, 1,
&UpperLeftX, &UpperLeftY);
image_points_to_world_plane(FinalCamParam, PoseForEntireImage,
Height/2, Width/2+1,
1, &UpperRightX, &UpperRightY);
image_points_to_world_plane(FinalCamParam, PoseForEntireImage,
Height/2+1, Width/2,
1, &LowerLeftX, &LowerLeftY);
distance_pp(UpperLeftY, UpperLeftX, UpperRightY, UpperRightX,
&WorldLength1);
distance_pp(UpperLeftY, UpperLeftX, LowerLeftY, LowerLeftX,
&WorldLength2);
ScaleForSimilarPixelSize = (WorldLength1+WorldLength2)/2;
// -> determine output image size such that entire input image fits into it
ExtentX = MaxX-MinX;
ExtentY = MaxY-MinY;
WidthRectifiedImage = ExtentX/ScaleForSimilarPixelSize;
HeightRectifiedImage = ExtentY/ScaleForSimilarPixelSize;
// create mapping with the determined parameters
Map =
HImage::GenImageToWorldPlaneMap(FinalCamParam, PoseForEntireImage,
Width, Height, WidthRectifiedImage,
HeightRectifiedImage,
ScaleForSimilarPixelSize, "bilinear");
// transform grabbed images with the created map
while(1)
{
Image = AcqHandle.GrabImageAsync(-1);
RectifiedImage = Image.MapImage(Map);
}
* perform camera calibration (with standard calibration plate)
camera_calibration(NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, \
'all', FinalCamParam, NFinalPose, Errors)
* world coordinate system is defined by calibration plate in first image
FinalPose1 := NFinalPose[0:6]
* compensate thickness of plate
set_origin_pose(FinalPose1, 0, 0, 0.000073, WorldPose)
* goal: rectify images
* first determine parameters such that the entire image content is visible
* -> transform image boundary into world plane, determine smallest
* rectangle around it
get_image_pointer1(Image, Pointer, Type, Width, Height)
gen_rectangle1 (ImageRect, 0, 0, Height-1, Width-1)
gen_contour_region_xld (ImageRect, ImageBorder, 'border')
contour_to_world_plane_xld(ImageBorder, ImageBorderWCS, FinalCamParam, \
WorldPose, 1)
smallest_rectangle1_xld (ImageBorderWCS, MinY, MinX, MaxY, MaxX)
* -> move the pose to the upper left corner of the surrounding rectangle
set_origin_pose(WorldPose, MinX, MinY, 0, PoseForEntireImage)
* -> determine the scaling factor such that the center pixel has the same
* size in the original and in the rectified image
* method: transform corner points of the pixel into the world
* coordinate system, compute their distances, and use their
* mean as the scaling factor
image_points_to_world_plane(FinalCamParam, PoseForEntireImage, \
[Height/2, Height/2, Height/2+1], \
[Width/2, Width/2+1, Width/2], \
1, WorldPixelX, WorldPixelY)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[1], WorldPixelX[1], \
WorldLength1)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[2], WorldPixelX[2], \
WorldLength2)
ScaleForSimilarPixelSize := (WorldLength1+WorldLength2)/2
* -> determine output image size such that entire input image fits into it
ExtentX := MaxX-MinX
ExtentY := MaxY-MinY
WidthRectifiedImage := ExtentX/ScaleForSimilarPixelSize
HeightRectifiedImage := ExtentY/ScaleForSimilarPixelSize
* create mapping with the determined parameters
gen_image_to_world_plane_map(Map, FinalCamParam, PoseForEntireImage, \
Width, Height, \
WidthRectifiedImage, HeightRectifiedImage, \
ScaleForSimilarPixelSize, 'bilinear')
* transform grabbed images with the created map
while(1)
grab_image_async(Image, AcqHandle, -1)
map_image(Image, Map, RectifiedImage)
endwhile
* perform camera calibration (with standard calibration plate)
camera_calibration(NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, \
'all', FinalCamParam, NFinalPose, Errors)
* world coordinate system is defined by calibration plate in first image
FinalPose1 := NFinalPose[0:6]
* compensate thickness of plate
set_origin_pose(FinalPose1, 0, 0, 0.000073, WorldPose)
* goal: rectify images
* first determine parameters such that the entire image content is visible
* -> transform image boundary into world plane, determine smallest
* rectangle around it
get_image_pointer1(Image, Pointer, Type, Width, Height)
gen_rectangle1 (ImageRect, 0, 0, Height-1, Width-1)
gen_contour_region_xld (ImageRect, ImageBorder, 'border')
contour_to_world_plane_xld(ImageBorder, ImageBorderWCS, FinalCamParam, \
WorldPose, 1)
smallest_rectangle1_xld (ImageBorderWCS, MinY, MinX, MaxY, MaxX)
* -> move the pose to the upper left corner of the surrounding rectangle
set_origin_pose(WorldPose, MinX, MinY, 0, PoseForEntireImage)
* -> determine the scaling factor such that the center pixel has the same
* size in the original and in the rectified image
* method: transform corner points of the pixel into the world
* coordinate system, compute their distances, and use their
* mean as the scaling factor
image_points_to_world_plane(FinalCamParam, PoseForEntireImage, \
[Height/2, Height/2, Height/2+1], \
[Width/2, Width/2+1, Width/2], \
1, WorldPixelX, WorldPixelY)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[1], WorldPixelX[1], \
WorldLength1)
distance_pp(WorldPixelY[0], WorldPixelX[0], WorldPixelY[2], WorldPixelX[2], \
WorldLength2)
ScaleForSimilarPixelSize := (WorldLength1+WorldLength2)/2
* -> determine output image size such that entire input image fits into it
ExtentX := MaxX-MinX
ExtentY := MaxY-MinY
WidthRectifiedImage := ExtentX/ScaleForSimilarPixelSize
HeightRectifiedImage := ExtentY/ScaleForSimilarPixelSize
* create mapping with the determined parameters
gen_image_to_world_plane_map(Map, FinalCamParam, PoseForEntireImage, \
Width, Height, \
WidthRectifiedImage, HeightRectifiedImage, \
ScaleForSimilarPixelSize, 'bilinear')
* transform grabbed images with the created map
while(1)
grab_image_async(Image, AcqHandle, -1)
map_image(Image, Map, RectifiedImage)
endwhile
gen_image_to_world_plane_mapgen_image_to_world_plane_mapgen_image_to_world_plane_mapGenImageToWorldPlaneMapGenImageToWorldPlaneMap returns 2 (H_MSG_TRUE) if all parameter values
are correct. If necessary, an exception is raised.
create_posecreate_posecreate_poseCreatePoseCreatePose,
hom_mat3d_to_posehom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPose,
camera_calibrationcamera_calibrationcamera_calibrationCameraCalibrationCameraCalibration,
hand_eye_calibrationhand_eye_calibrationhand_eye_calibrationHandEyeCalibrationHandEyeCalibration,
set_origin_poseset_origin_poseset_origin_poseSetOriginPoseSetOriginPose
map_imagemap_imagemap_imageMapImageMapImage
image_to_world_planeimage_to_world_planeimage_to_world_planeImageToWorldPlaneImageToWorldPlane
map_imagemap_imagemap_imageMapImageMapImage,
contour_to_world_plane_xldcontour_to_world_plane_xldcontour_to_world_plane_xldContourToWorldPlaneXldContourToWorldPlaneXld,
image_points_to_world_planeimage_points_to_world_planeimage_points_to_world_planeImagePointsToWorldPlaneImagePointsToWorldPlane
Calibration
| HALCON Reference Manual 10.0.2 |
Copyright © 1996-2011 MVTec Software GmbH |