HALCON到OpenCV失真系数的转换

我有一个校准的多摄像头系统。使用基于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);

变量"；cameraMatrix"；在OpenCV中等于变量"；CamMatrix"；在HALCON。失真系数"；distCoeffs"；在OpenCV中，它们取自HALCON(k1，k2，k3，p1，p2)，并按照以下文档进行重新排列：

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

请注意，提供了k3作为第五个参数，并且交换了p2和p1。根据HALCON文件(https://www.mvtec.com/doc/halcon/12/en/calibrate_cameras.html，参见函数calibrate_cameras)图像平面(u，v)中的未失真坐标根据失真(u'，v')计算为：

u=u'+u'(k1 r^2+k2 r^4+k3 r^6)+p1(r^2+2 u'^2)+2 p2 u'v'
v=v'+v'(k1 r^2+k2 r^4+k3 r^6)+p2(r^2+2 v'^2)+2 p1 u'v'
具有r=sqrt(u'^2+v'^2)

在OpenCV中时(https://docs.opencv.org/2.4/modules/imgproc/doc/geometric_transformations.html，请参见函数initUnstortRectifyMap)相同的未失真坐标被类似地估计，只有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中类似的无失真结果(但并不完全相同)，我必须缩小OpenCV中的失真系数(约为100！)。事实上，我注意到HALCON估计了巨大的失真系数。例如，为了在未失真的图像中产生可见的变化，我必须在HALCON中设置k1=1000，而在OpenCV中设置k1=1已经明显地改变了图像。对于一些失真系数，我甚至不得不反转(带负号)这些值，以获得方向相似的未失真结果。。。

我进一步挖掘了HALCON无失真代码，并试图手动估计文档后面的无失真坐标(u，v)，它应该对应于"；地图"；。我这样做是为了确保"；映射"；实际上是按照文件中规定的方式/我理解的方式来估计的。然而，即使在这里，与"；映射"。。。为了进行测试，我使用了以下代码：

* 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进行校准和不失真是有争议的，但不幸的是，对我来说，这不是一个可接受的解决方案。

我找到了自己问题的答案。简而言之，答案是肯定的。是的，可以将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(未失真坐标)：=D失真坐标。估计的坐标和地图中的坐标对应于图像边界处的舍入误差和条件。

相反，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代码，以便将手动估计的坐标与地图中的坐标进行比较。请注意，对于我的解决方案，它们是相反的，即从DIstored到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')

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

OpenCV和HALCON校准参数之间的转换不是可能的

原因是HALCON多项式模型使用了一个方程系统其中失真的图像坐标在右边给出。因此失真系数描述了这个计算方向。关于相反，OpenCV实现使用了一个方程系统，其中un失真的图像坐标在右侧给出。因此，失真系数描述了反向方向。因为多项式等级高，转换是不可能的。

要比较方程式，请参阅的运算符参考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校正的图像集可以使用图像：

获取原始(失真)图像，并使用HALCON校准进行校正

通过abs_diff_image将其与OpenCV的校正图像进行比较

请注意，这仅在单个数据集/校准上进行了测试。对不同的校准/摄像机。

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

相关内容

最新更新

热门标签：