HALCON到OpenCV失真系数的转换

Question

我有一个校准的多摄像头系统。内部(焦距、畸变等)和外部(姿态)的相机参数都是用基于HALCON的程序估计的。现在，我们的目标是编写一个C++程序，读取摄像机参数，特别是由HALCON估计的失真系数(k1、k2、k3、p1、p2)，并使用它们来使用OpenCV对图像进行非失真处理。不幸的是，到目前为止，我无法成功:在HALCON和OpenCV中使用的相同的失真系数产生了非常不同的未失真图像！我猜问题是HALCON和OpenCV解释失真系数的方式，甚至是它们表现出非失真的方式。

下面是我的HALCON代码，用于读取失真系数，并使用它们来消除测试图像的失真：

* Read the internal camera calibratino parameters ('area_scan_polynomial' model)
read_cam_par('Calibration.dat', CamParam)

* Estimate camera parameters without distortion: set all distortion coefficients to [k1, k2, k3, p1, p2] = [0, 0, 0, 0, 0] 
change_radial_distortion_cam_par ('fixed', CamParam, [0, 0, 0, 0, 0], CamParamOut)

* Estimate camera matrix of distortion-free parameters (used for OpenCV)
cam_par_to_cam_mat(CamParamOut, CamMatrix, ImageWidth, ImageHeight)

* Generate map to use for undistortion. 
* Note the use of type 'coord_map_sub_pix' which is of type 'vector_field_absolute', 
* i.e. the values are 2D absolute coordinates of the corresponding undistorted pixel location
gen_radial_distortion_map(Map, CamParam, CamParamOut, 'coord_map_sub_pix')

* Read a test image and undistort it using the estimate map
read_image (Image, 'test.jpg')
map_image(Image, Map, ImageRectified)

在OpenCV中，我试图使用以下代码进行完全相同的操作：

Mat view , rview, mapx, mapy;

// Read the same test image as in HALCON
view = imread("test.jpg");

// Get the image size
const Size viewSize = view.size();

// Generate map to use for undistortion
initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
    cameraMatrix, viewSize, CV_16SC2, mapx, mapy);

// Undistort the image using the estimated map
remap(view, rview, mapx, mapy, INTER_LINEAR);

OpenCV中的变量"CamMatrix“等于HALCON中的变量”CamMatrix“。distCoeffs中的失真系数“OpenCV”取自HALCON (k1、k2、k3、p1、p2)，然后按照这种方式重新排列文档：

distCoeffs = (Mat_<double>(5, 1) << k1, k2, p2, p1, k3)

请注意，提供了k3作为第五个参数，并交换了p2和p1。根据HALCON文档(cameras.html，参见函数calibrate_cameras)，图像平面(u，v)中的非畸变坐标是从畸变的(u'，v')中计算出来的：

U= u‘+ u’(k1 r^2 + k2 r^4 + k3 r^6) + p1 (r^2 +2u‘^2)+2 p2 u’v‘ V= v‘+ v’(k1 r^2 + k2 r^4 + k3 r^6) + p2 (r^2 +2v‘^2)+2 p1 u’v‘ 有r= sqrt(u'^2 + v'^2)

在OpenCV (transformations.html，请参阅函数initUndistortRectifyMap)中，相同的未失真坐标的估计是相似的，只有p1和p2被交换。

显然，OpenCV和HALCON都以类似的方式将像素投影到图像平面。也就是说，具有像素(x，y)的相应图像平面坐标被计算为：

u‘=x- cx / fx v‘=y- cy / fy

当然，这些可以反投影以重新获得相应的像素坐标：

X= u‘* fx + cx Y= v‘* fy + cy

根据文件，一切似乎都应如预期的那样运作。然而，我不明白为什么基于HALCON和OpenCV的代码仍然输出非常不同的结果。我注意到，为了产生类似于HALCON那样的不失真结果(但不完全相同)，我不得不缩小(因子为100 !)OpenCV中的畸变系数。事实上，我注意到HALCON估计了巨大的失真系数。例如，为了在不失真的图像中产生可见的变化，我必须在HALCON k1=1000中设置，而在OpenCV k1=1中，已经明显地改变了图像。对于一些失真系数，我甚至不得不反演(用负值)来获得类似方向的不失真结果.

我挖掘了更多的HALCON非失真代码，并试图手动估计文档后面的不失真坐标(u，v)，这应该对应于"Map“中的坐标。我这样做是为了确保"Map“确实被估计为文档中指定的方式/我理解它的方式。然而，即使在这里，我也得到了与“地图”中估计的结果非常不同的结果.为了进行测试，我使用了以下代码：

* Get the camera parameters from the calibration
get_cam_par_data (CamParam, 'k1', k1)
get_cam_par_data (CamParam, 'k2', k2)
get_cam_par_data (CamParam, 'k3', k3)
get_cam_par_data (CamParam, 'p1', p1)
get_cam_par_data (CamParam, 'p2', p2)
get_cam_par_data (CamParam, 'cx', cx)
get_cam_par_data (CamParam, 'cy', cy)
get_cam_par_data (CamParam, 'image_width', width)
get_cam_par_data (CamParam, 'image_height', height)

* Estimate the camera matrix, to read the focal length in pixel
cam_par_to_cam_mat(CamParamOut, CamMatrix, width, height)

* Extract the focal lenths in pixel from the estimated camera matrix (see above)
fx_px := CamMatrix[0]
fy_px := CamMatrix[4]

* Pick a pixel coordinate (I tried different values) in the image domain
x := 350
y := 450

* Convert into image plane coordinates
u_1 := (x - cx) / fx_px
v_1 := (y - cy) / fy_px

* Estimate the undistorted location u_2 and v_2
r2 := u_1 * u_1 + v_1 * v_1
u_2 := u_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + 2 * p1 * u_1 * v_1 + p2 * (r2 + 2 * u_1 * u_1)
v_2 := v_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + 2 * p2 * u_1 * v_1 + p1 * (r2 + 2 * v_1 * v_1)
    
* Back to pixel coordinate
x_1 := u_2 * fx_px + cx
y_1 := v_2 * fy_px + cy

* Compare the values with the value in Map (estimated as before). G_found and G_est should match!
G_found := [y_1, x_1]
get_grayval(Map, y, x, G_est)

我试着一次只关注几个失真系数，即只有k1 > 0，其他的则设置为0。然而，在大多数情况下(当x= cx，y=cy时几乎没有例外)，不失真的坐标超过了图像大小，甚至变成了负值。

这不是HALCON估计不失真地图坐标的方式吗？我是不是遗漏了什么？如何将这些失真系数转换为让OpenCV生成完全相同的未失真图像？任何帮助都将不胜感激！

由于一些软件的限制，使用专用的OpenCV进行校准和不失真是有争议的，但不幸的是，对我来说不是一个可接受的解决方案。

Answer 1

我找到了我自己问题的答案。简而言之，答案是肯定的。是的，可以从HALCON转换为OpenCV失真参数，反之亦然。原因是，HALCON和OpenCV 显然估计了相同的底层模型。我做了几次成功的测试来证实这一点，我想分享我的见解。下面，我计算的公式将每个失真参数从HALCON转换为OpenCV：

k1_opencv = k1_halcon * fmm * fmm;
k2_opencv = k2_halcon * fmm * fmm * fmm * fmm;
k3_opencv = k3_halcon * fmm * fmm * fmm * fmm * fmm * fmm;
p1_opencv = p2_halcon * fmm;    // Notice: swap
p2_opencv = p1_halcon * fmm;

注意，fmm是以毫米为单位的焦距，如HALCON中估计的那样。用于估计地图中估计的相同值的正确HALCON代码是：

get_cam_par_data (CamParam, 'sx', Sx) 
get_cam_par_data (CamParam, 'sy', Sy)

* Convert into image plane coordinates
u_1 := (x - cx) * sx
v_1 := (y - cy) * sy

* Estimate the undistorted location u_2 and v_2
r2 := u_1 * u_1 + v_1 * v_1
u_2 := u_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + 2 * p2 * u_1 * v_1 + p1 * (r2 + 2 * u_1 * u_1)
v_2 := v_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + 2 * p1 * u_1 * v_1 + p2 * (r2 + 2 * v_1 * v_1)

* Back to pixel coordinate
x_1 := u_2 / sx + cx
y_1 := v_2 / sy + cy

* Compare coordinates. NOTICE: we get the values from the distortion map
* going from UNdistorted to DIstorted coordinates!!!
G_found := [y_1, x_1]
gen_radial_distortion_map(MapUD, CamParamOut, CamParam, 'coord_map_sub_pix') 
get_grayval(MapUD, y, x, G_est)

关于我在问题中发布的初始代码，坐标是用像素大小(以毫米sx和sy为单位)来转换的，而不是焦距。另一个不同之处是，我们将估计的坐标与MapUD的值进行比较，其中MapUD(UNdistorted坐标) := DIstorted坐标。地图中估计的坐标和坐标对应于图像边界上的舍入误差和条件。

相反，OpenCV执行以下操作(完全符合文档！)：

float u = (x - cx) / fpx;
float v = (y - cy) / fpx;
float x_1 = u;
float y_1 = v;
float r2 = x_1 * x_1 + y_1 * y_1;
float x_2 = x_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + 2 * p1 * x_1 * y_1 + p2 * (r2 + 2 * x_1 * x_1);
float y_2 = y_1 * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2) + p1 * (r2 + 2 * y_1 * y_1) + 2 * p2 * x_1 * y_1;
float map_x_est = x_2 * fpx + cx;
float map_y_est = y_2 * fpx + cy;

// Compare coordinates
initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
        cameraMatrix, viewSize, CV_32FC1, mapx, mapy);
float map_x = mapx.at<float>(y, x);
float map_y = mapy.at<float>(y, x);

在上面的代码中，值map_x对应于map_x_est，map_y对应于map_y_est，直到舍入错误。如果我们使用与HALCON相同的cameraMatrix，并使用上述公式转换失真系数distCoeffs，我们可以清楚地看到，OpenCV变量map_x和map_y中的映射值对应于来自HALCON的MapUD中的值。我对此进行了测试，将映射值逐个输出(在整个域中)，以确定HALCON和OpenCV中不同的失真参数，得到相同的结果，但误差小于0.01像素。

附加信息：MVTec给我发送了一些HALCON代码，将手动估计的坐标与地图中的坐标进行比较。注意，对于我的解决方案，它们是相反的，即从DIstorted到UNdistorted。在很多情况下，代码对我不起作用。你可以试试，让我知道：

dev_close_window ()
dev_update_off ()

Width:=1600
Height:=1200
dev_open_window_fit_size(0, 0, Width, Height, -1, -1, WindowHandle)

gen_cam_par_area_scan_polynomial (0.008, 0, 0, 0, 0, 10, 5.2e-006, 5.2e-006, Width/2, Height/2, Width, Height, CamParam) 
change_radial_distortion_cam_par ('fixed', CamParam, [0, 0, 0, 0, 0], CamParamOut) 
gen_radial_distortion_map(Map, CamParam, CamParamOut, 'coord_map_sub_pix') 

get_cam_par_data (CamParam, 'k1', k1) 
get_cam_par_data (CamParam, 'k2', k2) 
get_cam_par_data (CamParam, 'k3', k3) 
get_cam_par_data (CamParam, 'p1', p1) 
get_cam_par_data (CamParam, 'p2', p2) 
get_cam_par_data (CamParam, 'cx', cx) 
get_cam_par_data (CamParam, 'cy', cy) 
get_cam_par_data (CamParam, 'sx', Sx) 
get_cam_par_data (CamParam, 'sy', Sy) 

* Select a valid point
Row := 86
Col := 89

get_grayval(Map, Row, Col, G_map)

get_domain (Map, Domain)
test_region_point (Domain, Row, Col, IsInside)
if (IsInside)
    * Check calculation
    GRow:=G_map[0]
    GCol:=G_map[1]

    U_1 := (GCol - cx) * Sx
    V_1 := (GRow - cy) * Sy 

    R_2 := U_1 * U_1 + V_1 * V_1 
    U_2 := U_1 * (1 + k1 * R_2 + k2 * R_2 * R_2 + k3 * R_2 * R_2 * R_2) + p1 * (R_2 + 2 * U_1 * U_1) + 2 * p2 * U_1 * V_1
    V_2 := V_1 * (1 + k1 * R_2 + k2 * R_2 * R_2 + k3 * R_2 * R_2 * R_2) + p2 * (R_2 + 2 * V_1 * V_1) + 2 * p1 * U_1 * V_1

    Col_calc := U_2 / Sx + cx
    Row_calc := V_2 / Sy + cy 

    G_input:=[Row, Col]
    G_calc:=[Row_calc, Col_calc]
    G_diff:=G_calc-G_input
    dev_inspect_ctrl ([G_input, G_calc, G_diff])
    stop()
else
    * Point is outside domain of distortion map
    stop()
endif

dev_close_inspect_ctrl ([G_input, G_calc, G_diff])
dev_clear_window ()
dev_update_on ()
disp_message (WindowHandle, 'No more lines to execute...', 'window', 12, 12, 'black', 'true')

Answer 2

我们向MVTec发出了支持请求，并收到了以下答复(在2019年11月21日收到；09:27)：

OpenCV和HALCON校准参数之间的转换是不可能的。 这是因为HALCON多项式模型使用的是一个方程系统，在该方程组中给出了图像的畸变坐标。因此，失真系数描述了这个计算方向。相反，OpenCV实现使用了一个方程系统，其中_un_distorted图像坐标在右边。因此，失真系数描述了倒置方向。由于多项式等级较高，不可能进行转换。 若要比较方程，请参考calibrate_cameras和OpenCV相机校准教程的操作符引用。 OpenCV中不存在可解析反求的划分模型。

我们还得到了一个hdev脚本，用于从HALCON到OpenCV参数的近似映射(清华，2019年11月21日；16:27)：

​

<?xml version="1.0" encoding="UTF-8"?>
<hdevelop file_version="1.2" halcon_version="19.05.0.0">
<procedure name="main">
<interface/>
<body>
<c>************************************************************************************************</c>
<c>* Parameter</c>
<c>************************************************************************************************</c>
<c></c>
<l>PathImg := './'</l>
<l>PathIdRect := '.rect.'</l>
<l>ZoomDisplay := 0.3</l>
<c></c>
<c>* Distortions from OpenCV</c>
<l>Distortions := [-0.161881, 0.092025, 0.000072, -0.000105, 0.000000]</l>
<c>*</c>
<c>* Camera matrices from OpenCV</c>
<l>* CamMatrixOpenCV := [1402.101918, 0.000000,    967.367190,\
                   0.000000,    1399.751916, 580.546496,\
                   0.000000,    0.000000,    1.000000]</l>
<c></c>
<c>* CamMatrixOpenCV</c>
<l>Cx := 967.3672</l>
<l>Cy := 580.546496</l>
<l>fxPix := 1402.101918</l>
<l>fyPix := 1399.751916</l>
<l>f := 0.00824144</l>
<c>*</c>
<l>* ProjectionOpenCV := [  fxPix,    0.000000,    Cx,       0.000000,\
                    0.000000,    fyPix,       Cy,       0.000000,\
                    0.000000,    0.000000,    1.000000, 0.000000,\
                    0,           0,           0,        1        ]</l>
<c></c>
<c>************************************************************************************************</c>
<c>* Initialization</c>
<c>************************************************************************************************</c>
<c></c>
<l>dev_update_off ()</l>
<c></c>
<c>* Prepare the image data.</c>
<l>list_image_files (PathImg, 'png', [], ImageFilesAll)</l>
<l>ImageFilesRectified := regexp_select(ImageFilesAll, PathIdRect)</l>
<l>ImageFilesNonRectified := difference(ImageFilesAll, ImageFilesRectified)</l>
<l>if (|ImageFilesNonRectified| != |ImageFilesRectified|)</l>
<l>    throw (['Uneven amounts of images found, please check the image pairs'])</l>
<l>endif</l>
<c></c>
<c>* Prepare the display</c>
<l>read_image (Image, ImageFilesNonRectified[0])</l>
<l>get_image_size (Image, Width, Height)</l>
<l>for I := 0 to 2 by 1</l>
<l>    dev_open_window (0, I*(Width*ZoomDisplay+12), Width*ZoomDisplay, Height*ZoomDisplay, 'black', WindowHandles.at(I))</l>
<l>    set_display_font (WindowHandles.at(I), 16, 'mono', 'true', 'false')</l>
<l>endfor</l>
<c></c>
<c>* Perform the calibration using an arbitrary grid (full image also possible but slow)</c>
<l>gen_grid_region (RegionGrid, 5, 5, 'points', Width, Height)</l>
<l>get_region_points (RegionGrid, Row, Col)</l>
<l>campar_opencv2halcon (Distortions, f, Cx, Cy, fxPix, fyPix, Row, Col, Width, Height, Error, CamParamsOpt)</l>
<l>change_radial_distortion_cam_par ('adaptive', CamParamsOpt, [0,0,0,0,0], CamParamOptRect) </l>
<l>dev_set_window (WindowHandles.at(0))</l>
<l>dev_disp_text ('Error (pxl): ' + Error, 'window', 'top', 'left', 'black', [], [])</l>
<l>dev_disp_text (['HALCON camera params:', CamParamsOpt], 'window', 'bottom', 'left', 'black', [], [])</l>
<l>disp_continue_message (WindowHandles.at(0), 'black', 'true')</l>
<l>stop ()</l>
<c></c>
<c>* Ignore errors at the close image border</c>
<l>Padding := min([Width, Height])/100</l>
<l>gen_rectangle1 (RoiDiff, Padding, Padding, Height-Padding, Width-Padding)</l>
<c></c>
<c></c>
<c>************************************************************************************************</c>
<c>* Initialization</c>
<c>************************************************************************************************</c>
<c></c>
<c>* Apply the calibration</c>
<l>for I := 0 to |ImageFilesNonRectified|-1 by 1</l>
<c>    * Select the image pair</c>
<l>    FileNameNonRectCurrent := ImageFilesNonRectified[I]</l>
<l>    FileNameRectCurrent := regexp_select(ImageFilesRectified, split(FileNameNonRectCurrent, PathImg)[0])</l>
<c>    </c>
<l>    read_image (ImageNonRect, FileNameNonRectCurrent)</l>
<l>    read_image (ImageRectOpenCV, FileNameRectCurrent)</l>
<c>    </c>
<c>    * Rectify the image using the HALCON calibration and compare it to the </c>
<c>    * OpenCV ground truth</c>
<l>    change_radial_distortion_image (ImageNonRect, ImageNonRect, ImageRectHALCON, CamParamsOpt, CamParamOptRect)</l>
<c></c>
<l>    reduce_domain (ImageRectOpenCV, RoiDiff, ImageRectOpenCVReduced)</l>
<l>    abs_diff_image (ImageRectOpenCVReduced, ImageRectHALCON, ImageAbsDiff, 1)</l>
<l>    threshold (ImageAbsDiff, RegionDiff, 50, 255)</l>
<l>    region_features (RegionDiff, 'area', AreaDiff)</l>
<c>    </c>
<l>    ImagesDisp := {ImageNonRect, ImageRectOpenCV, ImageRectHALCON}</l>
<l>    DispText := ['Original image', 'Rect image (OpenCV)', 'Rect image (HALCON)']</l>
<l>    for J := 0 to ImagesDisp.length()-1 by 1</l>
<l>        dev_set_window (WindowHandles.at(J))</l>
<l>        dev_display (ImagesDisp.at(J))</l>
<l>        dev_disp_text (DispText[J], 'window', 'top', 'left', 'black', [], [])</l>
<l>    endfor</l>
<l>    if (AreaDiff&gt;100)</l>
<l>        dev_set_color ('#ff0000c0')</l>
<l>        dev_display (RegionDiff)</l>
<l>        smallest_rectangle1 (RegionDiff, Row1, Column1, Row2, Column2)</l>
<l>        dev_set_color ('#ff000040')</l>
<l>        gen_rectangle1 (Rectangle, Row1, Column1, Row2, Column2)</l>
<l>        dev_disp_text ('Deviation detected', 'window', 'top', 'right', 'red', 'box', 'false')</l>
<l>        stop ()</l>
<l>    else</l>
<l>        dev_disp_text ('No deviation', 'window', 'top', 'right', 'green', 'box', 'false')</l>
<l>    endif</l>
<l>endfor</l>
<l>disp_end_of_program_message (WindowHandles.at(WindowHandles.length()-1), 'black', 'true')</l>
<l>stop ()</l>
<c></c>
<c>************************************************************************************************</c>
<c>* Clean up</c>
<c>************************************************************************************************</c>
<c></c>
<l>for I := 0 to WindowHandles.length()-1 by 1</l>
<l>    dev_set_window (WindowHandles.at(I))</l>
<l>    dev_close_window ()</l>
<l>endfor</l>
<l>dev_update_on ()</l>
</body>
<docu id="main">
<parameters/>
</docu>
</procedure>
<procedure name="campar_opencv2halcon">
<interface>
<ic>
<par name="OpenCv_Distortions" base_type="ctrl" dimension="0"/>
<par name="OpenCvF" base_type="ctrl" dimension="0"/>
<par name="OpenCv_Cx" base_type="ctrl" dimension="0"/>
<par name="OpenCv_Cy" base_type="ctrl" dimension="0"/>
<par name="OpenCv_fxPix" base_type="ctrl" dimension="0"/>
<par name="OpenCv_fyPix" base_type="ctrl" dimension="0"/>
<par name="RowObservations" base_type="ctrl" dimension="0"/>
<par name="ColObservations" base_type="ctrl" dimension="0"/>
<par name="WidthImage" base_type="ctrl" dimension="0"/>
<par name="HeightImage" base_type="ctrl" dimension="0"/>
</ic>
<oc>
<par name="Error" base_type="ctrl" dimension="0"/>
<par name="CamParamsOpt" base_type="ctrl" dimension="0"/>
</oc>
</interface>
<body>
<c>************************************************************************************************</c>
<c>* Prepare the OpenCV values as input for HALCON calibration</c>
<c>************************************************************************************************</c>
<c></c>
<c>* Extract the distortions</c>
<l>k_1 := OpenCv_Distortions[0]</l>
<l>k_2 := OpenCv_Distortions[1]</l>
<l>p_1 := OpenCv_Distortions[2]</l>
<l>p_2 := OpenCv_Distortions[3]</l>
<l>k_3 := OpenCv_Distortions[4]</l>
<c></c>
<c>* Image plane coord. system -&gt; HALCONs "description plate"</c>
<l>x_ := (ColObservations - OpenCv_Cx)/OpenCv_fxPix</l>
<l>y_ := (RowObservations - OpenCv_Cy)/OpenCv_fyPix</l>
<c></c>
<c>* Calculate the distorted points using the OpenCV Model</c>
<l>r2 := x_*x_+y_*y_</l>
<c></c>
<l>x2_tmp := x_ * (1 + k_1 * r2 + k_2 * r2 * r2 + k_3 * r2 * r2 * r2)</l>
<l>x2_ := x2_tmp + (2.0 * p_1 *x_ * y_ + p_2*(r2+2.0*x_*x_))</l>
<c></c>
<l>y2_tmp := y_ * (1 + k_1*r2+k_2*r2*r2+k_3*r2*r2*r2)</l>
<l>y2_ := y2_tmp +  (p_1 * (r2 + 2 * y_ * y_) + 2 * p_2 * x_ * y_)</l>
<c></c>
<c>* Image plane coord. system -&gt; Image coord. system (= Pixel coord)</c>
<l>u := OpenCv_fxPix * x2_ + OpenCv_Cx</l>
<l>v := OpenCv_fyPix * y2_ + OpenCv_Cy</l>
<c></c>
<c>* Compute the sensor size</c>
<l>sx := OpenCvF/OpenCv_fxPix</l>
<l>sy := OpenCvF/OpenCv_fyPix</l>
<c></c>
<c></c>
<c>************************************************************************************************</c>
<c>* Perform a HALCON calibration</c>
<c>************************************************************************************************</c>
<c></c>
<l>create_calib_data ('calibration_object', 1, 1, CalibDataID)</l>
<c>* Define a calibration plate</c>
<l>tuple_gen_const (|x_|, OpenCvF, Zeroes)</l>
<l>set_calib_data_calib_object (CalibDataID, 0, [x_, y_, Zeroes])</l>
<c>* Define the start params</c>
<l>gen_cam_par_area_scan_polynomial (OpenCvF, 0, 0, 0, 0, 0, sx, sy, OpenCv_Cx, OpenCv_Cy, WidthImage, HeightImage, CameraParamStart)</l>
<l>set_calib_data_cam_param (CalibDataID, 0, [], CameraParamStart)</l>
<c>* Exclude all params we can set directly from OpenCV</c>
<l>set_calib_data (CalibDataID, 'camera', 0, 'excluded_settings', ['pose'])</l>
<l>set_calib_data (CalibDataID, 'camera', 0, 'excluded_settings', ['focus','cx','cy'])</l>
<c></c>
<c>* Set the observation points</c>
<l>hom_mat3d_identity (HomMat3DIdentity)</l>
<l>hom_mat3d_to_pose (HomMat3DIdentity, Pose)</l>
<l>set_calib_data_observ_points (CalibDataID, 0, 0, 0, v, u, 'all', Pose)</l>
<c>* Calibrate the camera and deliver the results</c>
<l>calibrate_cameras (CalibDataID, Error)</l>
<l>get_calib_data (CalibDataID, 'camera', 0, 'params', CamParamsOpt)</l>
<l>clear_calib_data (CalibDataID)</l>
<l>return ()</l>
</body>
<docu id="campar_opencv2halcon">
<parameters>
<parameter id="CamParamsOpt">
<sem_type>campar</sem_type>
</parameter>
<parameter id="ColObservations">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="Error">
<default_type>real</default_type>
<multivalue>false</multivalue>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="HeightImage">
<default_type>integer</default_type>
<sem_type>number</sem_type>
<type_list>
<item>integer</item>
</type_list>
<value_max>1</value_max>
<value_min>1</value_min>
</parameter>
<parameter id="OpenCvF">
<default_type>real</default_type>
<multivalue>false</multivalue>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="OpenCv_Cx">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="OpenCv_Cy">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="OpenCv_Distortions">
<default_type>real</default_type>
<mixed_type>optional</mixed_type>
<multivalue>true</multivalue>
<sem_type>number</sem_type>
<type_list>
<item>integer</item>
<item>real</item>
</type_list>
</parameter>
<parameter id="OpenCv_fxPix">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="OpenCv_fyPix">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="RowObservations">
<default_type>real</default_type>
<sem_type>number</sem_type>
<type_list>
<item>real</item>
</type_list>
</parameter>
<parameter id="WidthImage">
<default_type>integer</default_type>
<sem_type>number</sem_type>
<type_list>
<item>integer</item>
</type_list>
<value_max>1</value_max>
<value_min>1</value_min>
</parameter>
</parameters>
</docu>
</procedure>
</hdevelop>

​

MVTec对脚本进行了如下注释：

基本上，这个想法是执行一个经典的HALCON校准。为此，我们使用OpenCV文档的公式(即“校准板”的定义，使用OpenCV失真的扭曲点)为其准备输入值。然后，使用HALCON校准来确定HALCON特有的失真值--其余的可以从OpenCV参数集中直接导出/获取。 为了进行验证，可以使用具有无失真和OpenCV校正图像的图像集：

1. 获取原始(失真)图像并使用HALCON校准校正它。
2. 并将其与OpenCV的abs_diff_image校正图像进行比较。

请注意，这只在单个数据集/校准上进行了测试。在不同的校准/摄像机上测试这种方法是有意义的。

Answer 3

不幸的是，HALCON和OpenCV校准参数之间没有直接的转换，因为底层模型和参数估计的方式是不同的。HALCON参数描述了从畸变坐标到非畸变坐标的转换，而OpenCV参数描述的是相反的变换。由于多项式等级较高，不可能进行转换。在OpenCV中不存在可解析反求的划分模型。