java.lang.Object
- org.opencv.calib3d.Calib3d

public class Calib3d
extends java.lang.Object

字段摘要

字段
修饰符和类型	字段	描述
`static int`	`CALIB_CB_ACCURACY`
`static int`	`CALIB_CB_ADAPTIVE_THRESH`
`static int`	`CALIB_CB_ASYMMETRIC_GRID`
`static int`	`CALIB_CB_CLUSTERING`
`static int`	`CALIB_CB_EXHAUSTIVE`
`static int`	`CALIB_CB_FAST_CHECK`
`static int`	`CALIB_CB_FILTER_QUADS`
`static int`	`CALIB_CB_LARGER`
`static int`	`CALIB_CB_MARKER`
`static int`	`CALIB_CB_NORMALIZE_IMAGE`
`static int`	`CALIB_CB_PLAIN`
`static int`	`CALIB_CB_SYMMETRIC_GRID`
`static int`	`CALIB_FIX_ASPECT_RATIO`
`static int`	`CALIB_FIX_FOCAL_LENGTH`
`static int`	`CALIB_FIX_INTRINSIC`
`static int`	`CALIB_FIX_K1`
`static int`	`CALIB_FIX_K2`
`static int`	`CALIB_FIX_K3`
`static int`	`CALIB_FIX_K4`
`static int`	`CALIB_FIX_K5`
`static int`	`CALIB_FIX_K6`
`static int`	`CALIB_FIX_PRINCIPAL_POINT`
`static int`	`CALIB_FIX_S1_S2_S3_S4`
`static int`	`CALIB_FIX_TANGENT_DIST`
`static int`	`CALIB_FIX_TAUX_TAUY`
`static int`	`CALIB_HAND_EYE_ANDREFF`
`static int`	`CALIB_HAND_EYE_DANIILIDIS`
`static int`	`CALIB_HAND_EYE_HORAUD`
`static int`	`CALIB_HAND_EYE_PARK`
`static int`	`CALIB_HAND_EYE_TSAI`
`static int`	`CALIB_NINTRINSIC`
`static int`	`CALIB_RATIONAL_MODEL`
`static int`	`CALIB_ROBOT_WORLD_HAND_EYE_LI`
`static int`	`CALIB_ROBOT_WORLD_HAND_EYE_SHAH`
`static int`	`CALIB_SAME_FOCAL_LENGTH`
`static int`	`CALIB_THIN_PRISM_MODEL`
`static int`	`CALIB_TILTED_MODEL`
`static int`	`CALIB_USE_EXTRINSIC_GUESS`
`static int`	`CALIB_USE_INTRINSIC_GUESS`
`static int`	`CALIB_USE_LU`
`static int`	`CALIB_USE_QR`
`static int`	`CALIB_ZERO_DISPARITY`
`static int`	`CALIB_ZERO_TANGENT_DIST`
`static int`	`CirclesGridFinderParameters_ASYMMETRIC_GRID`
`static int`	`CirclesGridFinderParameters_SYMMETRIC_GRID`
`static int`	`COV_POLISHER`
`static int`	`CV_DLS`
`static int`	`CV_EPNP`
`static int`	`CV_ITERATIVE`
`static int`	`CV_P3P`
`static int`	`CvLevMarq_CALC_J`
`static int`	`CvLevMarq_CHECK_ERR`
`static int`	`CvLevMarq_DONE`
`static int`	`CvLevMarq_STARTED`
`static int`	`fisheye_CALIB_CHECK_COND`
`static int`	`fisheye_CALIB_FIX_FOCAL_LENGTH`
`static int`	`fisheye_CALIB_FIX_INTRINSIC`
`static int`	`fisheye_CALIB_FIX_K1`
`static int`	`fisheye_CALIB_FIX_K2`
`static int`	`fisheye_CALIB_FIX_K3`
`static int`	`fisheye_CALIB_FIX_K4`
`static int`	`fisheye_CALIB_FIX_PRINCIPAL_POINT`
`static int`	`fisheye_CALIB_FIX_SKEW`
`static int`	`fisheye_CALIB_RECOMPUTE_EXTRINSIC`
`static int`	`fisheye_CALIB_USE_INTRINSIC_GUESS`
`static int`	`fisheye_CALIB_ZERO_DISPARITY`
`static int`	`FM_7POINT`
`static int`	`FM_8POINT`
`static int`	`FM_LMEDS`
`static int`	`FM_RANSAC`
`static int`	`LMEDS`
`static int`	`LOCAL_OPTIM_GC`
`static int`	`LOCAL_OPTIM_INNER_AND_ITER_LO`
`static int`	`LOCAL_OPTIM_INNER_LO`
`static int`	`LOCAL_OPTIM_NULL`
`static int`	`LOCAL_OPTIM_SIGMA`
`static int`	`LSQ_POLISHER`
`static int`	`MAGSAC`
`static int`	`NEIGH_FLANN_KNN`
`static int`	`NEIGH_FLANN_RADIUS`
`static int`	`NEIGH_GRID`
`static int`	`NONE_POLISHER`
`static int`	`PROJ_SPHERICAL_EQRECT`
`static int`	`PROJ_SPHERICAL_ORTHO`
`static int`	`RANSAC`
`static int`	`RHO`
`static int`	`SAMPLING_NAPSAC`
`static int`	`SAMPLING_PROGRESSIVE_NAPSAC`
`static int`	`SAMPLING_PROSAC`
`static int`	`SAMPLING_UNIFORM`
`static int`	`SCORE_METHOD_LMEDS`
`static int`	`SCORE_METHOD_MAGSAC`
`static int`	`SCORE_METHOD_MSAC`
`static int`	`SCORE_METHOD_RANSAC`
`static int`	`SOLVEPNP_AP3P`
`static int`	`SOLVEPNP_DLS`
`static int`	`SOLVEPNP_EPNP`
`static int`	`SOLVEPNP_IPPE`
`static int`	`SOLVEPNP_IPPE_SQUARE`
`static int`	`SOLVEPNP_ITERATIVE`
`static int`	`SOLVEPNP_MAX_COUNT`
`static int`	`SOLVEPNP_P3P`
`static int`	`SOLVEPNP_SQPNP`
`static int`	`SOLVEPNP_UPNP`
`static int`	`USAC_ACCURATE`
`static int`	`USAC_DEFAULT`
`static int`	`USAC_FAST`
`static int`	`USAC_FM_8PTS`
`static int`	`USAC_MAGSAC`
`static int`	`USAC_PARALLEL`
`static int`	`USAC_PROSAC`

构造器摘要

构造器
构造器描述

Calib3d()

方法摘要

所有方法静态方法具体方法
修饰符和类型	方法	描述
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`	根据校准图案的多个视图查找相机内参和外参。
`static double`	`calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags)`	根据校准图案的多个视图查找相机内参和外参。
`static double`	`calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`	根据校准图案的多个视图查找相机内参和外参。
`static double`	`calibrateCameraRO(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints)`
`static double`	`calibrateCameraRO(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints, int flags)`
`static double`	`calibrateCameraRO(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraROExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat stdDeviationsObjPoints, Mat perViewErrors)`	根据校准图案的多个视图查找相机内参和外参。
`static double`	`calibrateCameraROExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat stdDeviationsObjPoints, Mat perViewErrors, int flags)`	根据校准图案的多个视图查找相机内参和外参。
`static double`	`calibrateCameraROExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat newObjPoints, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat stdDeviationsObjPoints, Mat perViewErrors, int flags, TermCriteria criteria)`	根据校准图案的多个视图查找相机内参和外参。
`静态 void`	`calibrateHandEye(java.util.List<Mat> R_gripper2base, java.util.List<Mat> t_gripper2base, java.util.List<Mat> R_target2cam, java.util.List<Mat> t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper)`	计算手眼标定：\(_{}^{g}\textrm{T}_c\)
`静态 void`	`calibrateHandEye(java.util.List<Mat> R_gripper2base, java.util.List<Mat> t_gripper2base, java.util.List<Mat> R_target2cam, java.util.List<Mat> t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper, int method)`	计算手眼标定：\(_{}^{g}\textrm{T}_c\)
`静态 void`	`calibrateRobotWorldHandEye(java.util.List<Mat> R_world2cam, java.util.List<Mat> t_world2cam, java.util.List<Mat> R_base2gripper, java.util.List<Mat> t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam)`	计算机器人-世界/手眼标定：\(_{}^{w}\textrm{T}_b\) 和 \(_{}^{c}\textrm{T}_g\)
`静态 void`	`calibrateRobotWorldHandEye(java.util.List<Mat> R_world2cam, java.util.List<Mat> t_world2cam, java.util.List<Mat> R_base2gripper, java.util.List<Mat> t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam, int method)`	计算机器人-世界/手眼标定：\(_{}^{w}\textrm{T}_b\) 和 \(_{}^{c}\textrm{T}_g\)
`静态 void`	`calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio)`	根据相机内参矩阵计算有用的相机特性。
`静态布尔值`	`checkChessboard(Mat img, Size size)`
`静态 void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(…)`	组合两个旋转和平移变换。
`静态 void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2)`	组合两个旋转和平移变换。
`静态 void`	`computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines)`	对于立体图像对中的一幅图像中的点，计算另一幅图像中对应的极线。
`静态 void`	`convertPointsFromHomogeneous(Mat src, Mat dst)`	将点从齐次空间转换为欧几里德空间。
`静态 void`	`convertPointsToHomogeneous(Mat src, Mat dst)`	将点从欧几里德空间转换为齐次空间。
`静态 void`	`correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2)`	细化对应点的坐标。
`静态 void`	`decomposeEssentialMat(Mat E, Mat R1, Mat R2, Mat t)`	将本质矩阵分解为可能的旋转和平移。
`static int`	`decomposeHomographyMat(Mat H, Mat K, java.util.List<Mat> rotations, java.util.List<Mat> translations, java.util.List<Mat> normals)`	将单应性矩阵分解为旋转、平移和平面法向量。
`静态 void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`静态 void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`静态 void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`静态 void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`静态 void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`静态 void`	`drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound)`	绘制检测到的棋盘格角点。
`静态 void`	`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)`	根据位姿估计绘制世界/物体坐标系的坐标轴。
`静态 void`	`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness)`	根据位姿估计绘制世界/物体坐标系的坐标轴。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`	计算两个二维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine2D(Mat pts1, Mat pts2, Mat inliers, UsacParams params)`
`静态 Mat`	`estimateAffine3D(Mat src, Mat dst)`	计算两个三维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine3D(Mat src, Mat dst, double[] scale)`	计算两个三维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffine3D(Mat src, Mat dst, double[] scale, boolean force_rotation)`	计算两个三维点集之间的最优仿射变换。
`static int`	`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers)`	计算两个三维点集之间的最优仿射变换。
`static int`	`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold)`	计算两个三维点集之间的最优仿射变换。
`static int`	`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)`	计算两个三维点集之间的最优仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`静态 Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`	计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
`static Scalar`	`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners)`	估计检测到的棋盘格的清晰度。
`static Scalar`	`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners, float rise_distance)`	估计检测到的棋盘格的清晰度。
`static Scalar`	`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners, float rise_distance, boolean vertical)`	估计检测到的棋盘格的清晰度。
`static Scalar`	`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners, float rise_distance, boolean vertical, Mat sharpness)`	估计检测到的棋盘格的清晰度。
`static int`	`estimateTranslation3D(Mat src, Mat dst, Mat out, Mat inliers)`	计算两个三维点集之间的最优平移。
`static int`	`estimateTranslation3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold)`	计算两个三维点集之间的最优平移。
`static int`	`estimateTranslation3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)`	计算两个三维点集之间的最优平移。
`静态 void`	`filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations, java.util.List<Mat> normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`	基于额外信息过滤单应性分解。
`静态 void`	`filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations, java.util.List<Mat> normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)`	基于额外信息过滤单应性分解。
`静态 void`	`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff)`	过滤视差图中小的噪点斑块（斑点）。
`静态 void`	`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf)`	过滤视差图中小的噪点斑块（斑点）。
`静态布尔值`	`find4QuadCornerSubpix(Mat img, Mat corners, Size region_size)`
`静态布尔值`	`findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners)`	查找棋盘格内角点的位置。
`静态布尔值`	`findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags)`	查找棋盘格内角点的位置。
`静态布尔值`	`findChessboardCornersSB(Mat image, Size patternSize, Mat corners)`
`静态布尔值`	`findChessboardCornersSB(Mat image, Size patternSize, Mat corners, int flags)`
`静态布尔值`	`findChessboardCornersSBWithMeta(Mat image, Size patternSize, Mat corners, int flags, Mat meta)`	使用基于扇区的方案查找棋盘格内角点的位置。
`静态布尔值`	`findCirclesGrid(Mat image, Size patternSize, Mat centers)`
`静态布尔值`	`findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, int maxIters)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, int maxIters, Mat mask)`
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters, Mat mask)`	根据两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2)`	根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method)`	根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob)`	根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold)`	根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold, Mat mask)`	根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
`静态 Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat cameraMatrix2, Mat dist_coeff1, Mat dist_coeff2, Mat mask, UsacParams params)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, int maxIters)`	根据两幅图像中对应的点计算基本矩阵。
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, int maxIters, Mat mask)`	根据两幅图像中对应的点计算基本矩阵。
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, Mat mask)`
`静态 Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, Mat mask, UsacParams params)`
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)`	查找两个平面之间的透视变换。
`静态 Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, Mat mask, UsacParams params)`
`static double`	`fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`	执行相机标定
`static double`	`fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`	执行相机标定
`static double`	`fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`	执行相机标定
`静态 void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)`	使用鱼眼模型扭曲二维点。
`静态 void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)`	使用鱼眼模型扭曲二维点。
`静态 void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat Kundistorted, Mat K, Mat D)`	distortPoints 函数的重载，用于处理当未失真点是用非单位矩阵获得的情况，例如：
`静态 void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat Kundistorted, Mat K, Mat D, double alpha)`	distortPoints 函数的重载，用于处理当未失真点是用非单位矩阵获得的情况，例如：
`静态 void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P)`	估计用于去畸变或校正的新相机内参矩阵。
`静态 void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance)`	估计用于去畸变或校正的新相机内参矩阵。
`静态 void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size)`	估计用于去畸变或校正的新相机内参矩阵。
`静态 void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale)`	估计用于去畸变或校正的新相机内参矩阵。
`静态 void`	`fisheye_initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat map1, Mat map2)`	计算用于通过 #remap 进行图像变换的畸变校正和校正映射。
`静态 void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D)`
`静态 void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha)`
`静态 void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian)`
`静态布尔值`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)`	针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags, TermCriteria criteria)`	针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T)`
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags)`
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags, TermCriteria criteria)`
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`	执行立体标定
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`	执行立体标定
`static double`	`fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`	执行立体标定
`静态 void`	`fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags)`	鱼眼相机模型的立体校正
`静态 void`	`fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize)`	鱼眼相机模型的立体校正
`静态 void`	`fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance)`	鱼眼相机模型的立体校正
`静态 void`	`fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance, double fov_scale)`	鱼眼相机模型的立体校正
`静态 void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D)`	变换图像以补偿鱼眼镜头畸变。
`静态 void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew)`	变换图像以补偿鱼眼镜头畸变。
`静态 void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size)`	变换图像以补偿鱼眼镜头畸变。
`静态 void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D)`	使用鱼眼模型对二维点进行去畸变
`静态 void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R)`	使用鱼眼模型对二维点进行去畸变
`静态 void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P)`	使用鱼眼模型对二维点进行去畸变
`静态 void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P, TermCriteria criteria)`	使用鱼眼模型对二维点进行去畸变
`静态 Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix)`	返回默认的新相机内参矩阵。
`静态 Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize)`	返回默认的新相机内参矩阵。
`静态 Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)`	返回默认的新相机内参矩阵。
`静态 Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)`	基于自由缩放参数返回新的相机内参矩阵。
`静态 Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize)`	基于自由缩放参数返回新的相机内参矩阵。
`静态 Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI)`	基于自由缩放参数返回新的相机内参矩阵。
`静态 Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)`	基于自由缩放参数返回新的相机内参矩阵。
`静态 Rect`	`getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)`
`静态 Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize)`	根据3D-2D点对应关系查找初始相机内参矩阵。
`静态 Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize, double aspectRatio)`	根据3D-2D点对应关系查找初始相机内参矩阵。
`静态 void`	`initInverseRectificationMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)`	计算投影和反校正变换映射。
`静态 void`	`initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)`	计算去畸变和校正变换映射。
`静态 void`	`matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB)`	计算每个相乘矩阵的矩阵乘积的偏导数。
`静态 void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints)`	将3D点投影到图像平面。
`静态 void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian)`	将3D点投影到图像平面。
`静态 void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio)`	将3D点投影到图像平面。
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp, Mat mask)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t)`	使用手性检查从估计的基本矩阵和两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask, Mat triangulatedPoints)`
`static int`	`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, Mat mask)`	使用手性检查从估计的基本矩阵和两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat E, Mat R, Mat t)`	使用手性检查从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat E, Mat R, Mat t, int method)`	使用手性检查从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat E, Mat R, Mat t, int method, double prob)`	使用手性检查从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat E, Mat R, Mat t, int method, double prob, double threshold)`	使用手性检查从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`static int`	`recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat E, Mat R, Mat t, int method, double prob, double threshold, Mat mask)`	使用手性检查从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`static float`	`rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, java.util.List<Mat> imgpt1, java.util.List<Mat> imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)`
`静态 void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)`	将视差图像重新投影到3D空间。
`静态 void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues)`	将视差图像重新投影到3D空间。
`静态 void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)`	将视差图像重新投影到3D空间。
`静态 void`	`Rodrigues(Mat src, Mat dst)`	将旋转矩阵转换为旋转向量，反之亦然。
`静态 void`	`Rodrigues(Mat src, Mat dst, Mat jacobian)`	将旋转矩阵转换为旋转向量，反之亦然。
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)`	计算3x3矩阵的RQ分解。
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx)`	计算3x3矩阵的RQ分解。
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy)`	计算3x3矩阵的RQ分解。
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)`	计算3x3矩阵的RQ分解。
`static double`	`sampsonDistance(Mat pt1, Mat pt2, Mat F)`	计算两点之间的 Sampson 距离。
`static int`	`solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`	根据3个3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`	根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, boolean useExtrinsicGuess)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, boolean useExtrinsicGuess, int flags)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, boolean useExtrinsicGuess, int flags, Mat rvec)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, boolean useExtrinsicGuess, int flags, Mat rvec, Mat tvec)`	根据3D-2D点对应关系查找物体姿态。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, boolean useExtrinsicGuess, int flags, Mat rvec, Mat tvec, Mat reprojectionError)`	根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)`	使用RANSAC方案根据3D-2D点对应关系查找物体姿态。
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, Mat inliers)`
`静态布尔值`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, Mat inliers, UsacParams params)`
`静态 void`	`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	基于3D-2D点对应关系和初始解，优化姿态（将物体坐标系中表达的3D点转换为相机坐标系的平移和旋转）。
`静态 void`	`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria)`	基于3D-2D点对应关系和初始解，优化姿态（将物体坐标系中表达的3D点转换为相机坐标系的平移和旋转）。
`静态 void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	基于3D-2D点对应关系和初始解，优化姿态（将物体坐标系中表达的3D点转换为相机坐标系的平移和旋转）。
`静态 void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria)`	基于3D-2D点对应关系和初始解，优化姿态（将物体坐标系中表达的3D点转换为相机坐标系的平移和旋转）。
`静态 void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria, double VVSlambda)`	基于3D-2D点对应关系和初始解，优化姿态（将物体坐标系中表达的3D点转换为相机坐标系的平移和旋转）。
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`stereoCalibrateExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat perViewErrors)`	标定立体相机设置。
`static double`	`stereoCalibrateExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat perViewErrors, int flags)`	标定立体相机设置。
`static double`	`stereoCalibrateExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat perViewErrors, int flags, TermCriteria criteria)`	标定立体相机设置。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q)`	计算已标定立体相机的每个头的校正变换。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags)`	计算已标定立体相机的每个头的校正变换。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha)`	计算已标定立体相机的每个头的校正变换。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize)`	计算已标定立体相机的每个头的校正变换。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1)`	计算已标定立体相机的每个头的校正变换。
`静态 void`	`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1, Rect validPixROI2)`	计算已标定立体相机的每个头的校正变换。
`静态布尔值`	`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2)`	计算未标定的立体摄像机的校正变换。
`静态布尔值`	`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold)`	计算未标定的立体摄像机的校正变换。
`静态 void`	`triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D)`	此函数使用立体摄像机观察到的点来重建三维点（齐次坐标）。
`静态 void`	`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`	变换图像以补偿镜头畸变。
`静态 void`	`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix)`	变换图像以补偿镜头畸变。
`静态 void`	`undistortImagePoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`	计算未失真的图像点位置
`静态 void`	`undistortImagePoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, TermCriteria arg1)`	计算未失真的图像点位置
`静态 void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs)`	根据观察到的点坐标计算理想的点坐标。
`静态 void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs, Mat R)`	根据观察到的点坐标计算理想的点坐标。
`静态 void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P)`	根据观察到的点坐标计算理想的点坐标。
`静态 void`	`undistortPointsIter(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P, TermCriteria criteria)`	注意： #undistortPoints 的默认版本进行 5 次迭代来计算未失真点。
`静态 void`	`validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities)`
`静态 void`	`validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)`

继承自类 java.lang.Object 的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详情
  - CV_ITERATIVE
```
public static final int CV_ITERATIVE
```
    另请参阅
    
    常量字段值
  - CV_EPNP
```
public static final int CV_EPNP
```
    另请参阅
    
    常量字段值
  - CV_P3P
```
public static final int CV_P3P
```
    另请参阅
    
    常量字段值
  - CV_DLS
```
public static final int CV_DLS
```
    另请参阅
    
    常量字段值
  - CvLevMarq_DONE
```
public static final int CvLevMarq_DONE
```
    另请参阅
    
    常量字段值
  - CvLevMarq_STARTED
```
public static final int CvLevMarq_STARTED
```
    另请参阅
    
    常量字段值
  - CvLevMarq_CALC_J
```
public static final int CvLevMarq_CALC_J
```
    另请参阅
    
    常量字段值
  - CvLevMarq_CHECK_ERR
```
public static final int CvLevMarq_CHECK_ERR
```
    另请参阅
    
    常量字段值
  - LMEDS
```
public static final int LMEDS
```
    另请参阅
    
    常量字段值
  - RANSAC
```
public static final int RANSAC
```
    另请参阅
    
    常量字段值
  - RHO
```
public static final int RHO
```
    另请参阅
    
    常量字段值
  - USAC_DEFAULT
```
public static final int USAC_DEFAULT
```
    另请参阅
    
    常量字段值
  - USAC_PARALLEL
```
public static final int USAC_PARALLEL
```
    另请参阅
    
    常量字段值
  - USAC_FM_8PTS
```
public static final int USAC_FM_8PTS
```
    另请参阅
    
    常量字段值
  - USAC_FAST
```
public static final int USAC_FAST
```
    另请参阅
    
    常量字段值
  - USAC_ACCURATE
```
public static final int USAC_ACCURATE
```
    另请参阅
    
    常量字段值
  - USAC_PROSAC
```
public static final int USAC_PROSAC
```
    另请参阅
    
    常量字段值
  - USAC_MAGSAC
```
public static final int USAC_MAGSAC
```
    另请参阅
    
    常量字段值
  - CALIB_CB_ADAPTIVE_THRESH
```
public static final int CALIB_CB_ADAPTIVE_THRESH
```
    另请参阅
    
    常量字段值
  - CALIB_CB_NORMALIZE_IMAGE
```
public static final int CALIB_CB_NORMALIZE_IMAGE
```
    另请参阅
    
    常量字段值
  - CALIB_CB_FILTER_QUADS
```
public static final int CALIB_CB_FILTER_QUADS
```
    另请参阅
    
    常量字段值
  - CALIB_CB_FAST_CHECK
```
public static final int CALIB_CB_FAST_CHECK
```
    另请参阅
    
    常量字段值
  - CALIB_CB_EXHAUSTIVE
```
public static final int CALIB_CB_EXHAUSTIVE
```
    另请参阅
    
    常量字段值
  - CALIB_CB_ACCURACY
```
public static final int CALIB_CB_ACCURACY
```
    另请参阅
    
    常量字段值
  - CALIB_CB_LARGER
```
public static final int CALIB_CB_LARGER
```
    另请参阅
    
    常量字段值
  - CALIB_CB_MARKER
```
public static final int CALIB_CB_MARKER
```
    另请参阅
    
    常量字段值
  - CALIB_CB_PLAIN
```
public static final int CALIB_CB_PLAIN
```
    另请参阅
    
    常量字段值
  - CALIB_CB_SYMMETRIC_GRID
```
public static final int CALIB_CB_SYMMETRIC_GRID
```
    另请参阅
    
    常量字段值
  - CALIB_CB_ASYMMETRIC_GRID
```
public static final int CALIB_CB_ASYMMETRIC_GRID
```
    另请参阅
    
    常量字段值
  - CALIB_CB_CLUSTERING
```
public static final int CALIB_CB_CLUSTERING
```
    另请参阅
    
    常量字段值
  - CALIB_NINTRINSIC
```
public static final int CALIB_NINTRINSIC
```
    另请参阅
    
    常量字段值
  - CALIB_USE_INTRINSIC_GUESS
```
public static final int CALIB_USE_INTRINSIC_GUESS
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_ASPECT_RATIO
```
public static final int CALIB_FIX_ASPECT_RATIO
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_PRINCIPAL_POINT
```
public static final int CALIB_FIX_PRINCIPAL_POINT
```
    另请参阅
    
    常量字段值
  - CALIB_ZERO_TANGENT_DIST
```
public static final int CALIB_ZERO_TANGENT_DIST
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_FOCAL_LENGTH
```
public static final int CALIB_FIX_FOCAL_LENGTH
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K1
```
public static final int CALIB_FIX_K1
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K2
```
public static final int CALIB_FIX_K2
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K3
```
public static final int CALIB_FIX_K3
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K4
```
public static final int CALIB_FIX_K4
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K5
```
public static final int CALIB_FIX_K5
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_K6
```
public static final int CALIB_FIX_K6
```
    另请参阅
    
    常量字段值
  - CALIB_RATIONAL_MODEL
```
public static final int CALIB_RATIONAL_MODEL
```
    另请参阅
    
    常量字段值
  - CALIB_THIN_PRISM_MODEL
```
public static final int CALIB_THIN_PRISM_MODEL
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_S1_S2_S3_S4
```
public static final int CALIB_FIX_S1_S2_S3_S4
```
    另请参阅
    
    常量字段值
  - CALIB_TILTED_MODEL
```
public static final int CALIB_TILTED_MODEL
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_TAUX_TAUY
```
public static final int CALIB_FIX_TAUX_TAUY
```
    另请参阅
    
    常量字段值
  - CALIB_USE_QR
```
public static final int CALIB_USE_QR
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_TANGENT_DIST
```
public static final int CALIB_FIX_TANGENT_DIST
```
    另请参阅
    
    常量字段值
  - CALIB_FIX_INTRINSIC
```
public static final int CALIB_FIX_INTRINSIC
```
    另请参阅
    
    常量字段值
  - CALIB_SAME_FOCAL_LENGTH
```
public static final int CALIB_SAME_FOCAL_LENGTH
```
    另请参阅
    
    常量字段值
  - CALIB_ZERO_DISPARITY
```
public static final int CALIB_ZERO_DISPARITY
```
    另请参阅
    
    常量字段值
  - CALIB_USE_LU
```
public static final int CALIB_USE_LU
```
    另请参阅
    
    常量字段值
  - CALIB_USE_EXTRINSIC_GUESS
```
public static final int CALIB_USE_EXTRINSIC_GUESS
```
    另请参阅
    
    常量字段值
  - FM_7POINT
```
public static final int FM_7POINT
```
    另请参阅
    
    常量字段值
  - FM_8POINT
```
public static final int FM_8POINT
```
    另请参阅
    
    常量字段值
  - FM_LMEDS
```
public static final int FM_LMEDS
```
    另请参阅
    
    常量字段值
  - FM_RANSAC
```
public static final int FM_RANSAC
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_USE_INTRINSIC_GUESS
```
public static final int fisheye_CALIB_USE_INTRINSIC_GUESS
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_RECOMPUTE_EXTRINSIC
```
public static final int fisheye_CALIB_RECOMPUTE_EXTRINSIC
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_CHECK_COND
```
public static final int fisheye_CALIB_CHECK_COND
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_SKEW
```
public static final int fisheye_CALIB_FIX_SKEW
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_K1
```
public static final int fisheye_CALIB_FIX_K1
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_K2
```
public static final int fisheye_CALIB_FIX_K2
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_K3
```
public static final int fisheye_CALIB_FIX_K3
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_K4
```
public static final int fisheye_CALIB_FIX_K4
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_INTRINSIC
```
public static final int fisheye_CALIB_FIX_INTRINSIC
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_PRINCIPAL_POINT
```
public static final int fisheye_CALIB_FIX_PRINCIPAL_POINT
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_ZERO_DISPARITY
```
public static final int fisheye_CALIB_ZERO_DISPARITY
```
    另请参阅
    
    常量字段值
  - fisheye_CALIB_FIX_FOCAL_LENGTH
```
public static final int fisheye_CALIB_FIX_FOCAL_LENGTH
```
    另请参阅
    
    常量字段值
  - CirclesGridFinderParameters_SYMMETRIC_GRID
```
public static final int CirclesGridFinderParameters_SYMMETRIC_GRID
```
    另请参阅
    
    常量字段值
  - CirclesGridFinderParameters_ASYMMETRIC_GRID
```
public static final int CirclesGridFinderParameters_ASYMMETRIC_GRID
```
    另请参阅
    
    常量字段值
  - CALIB_HAND_EYE_TSAI
```
public static final int CALIB_HAND_EYE_TSAI
```
    另请参阅
    
    常量字段值
  - CALIB_HAND_EYE_PARK
```
public static final int CALIB_HAND_EYE_PARK
```
    另请参阅
    
    常量字段值
  - CALIB_HAND_EYE_HORAUD
```
public static final int CALIB_HAND_EYE_HORAUD
```
    另请参阅
    
    常量字段值
  - CALIB_HAND_EYE_ANDREFF
```
public static final int CALIB_HAND_EYE_ANDREFF
```
    另请参阅
    
    常量字段值
  - CALIB_HAND_EYE_DANIILIDIS
```
public static final int CALIB_HAND_EYE_DANIILIDIS
```
    另请参阅
    
    常量字段值
  - LOCAL_OPTIM_NULL
```
public static final int LOCAL_OPTIM_NULL
```
    另请参阅
    
    常量字段值
  - LOCAL_OPTIM_INNER_LO
```
public static final int LOCAL_OPTIM_INNER_LO
```
    另请参阅
    
    常量字段值
  - LOCAL_OPTIM_INNER_AND_ITER_LO
```
public static final int LOCAL_OPTIM_INNER_AND_ITER_LO
```
    另请参阅
    
    常量字段值
  - LOCAL_OPTIM_GC
```
public static final int LOCAL_OPTIM_GC
```
    另请参阅
    
    常量字段值
  - LOCAL_OPTIM_SIGMA
```
public static final int LOCAL_OPTIM_SIGMA
```
    另请参阅
    
    常量字段值
  - NEIGH_FLANN_KNN
```
public static final int NEIGH_FLANN_KNN
```
    另请参阅
    
    常量字段值
  - NEIGH_GRID
```
public static final int NEIGH_GRID
```
    另请参阅
    
    常量字段值
  - NEIGH_FLANN_RADIUS
```
public static final int NEIGH_FLANN_RADIUS
```
    另请参阅
    
    常量字段值
  - NONE_POLISHER
```
public static final int NONE_POLISHER
```
    另请参阅
    
    常量字段值
  - LSQ_POLISHER
```
public static final int LSQ_POLISHER
```
    另请参阅
    
    常量字段值
  - MAGSAC
```
public static final int MAGSAC
```
    另请参阅
    
    常量字段值
  - COV_POLISHER
```
public static final int COV_POLISHER
```
    另请参阅
    
    常量字段值
  - CALIB_ROBOT_WORLD_HAND_EYE_SHAH
```
public static final int CALIB_ROBOT_WORLD_HAND_EYE_SHAH
```
    另请参阅
    
    常量字段值
  - CALIB_ROBOT_WORLD_HAND_EYE_LI
```
public static final int CALIB_ROBOT_WORLD_HAND_EYE_LI
```
    另请参阅
    
    常量字段值
  - SAMPLING_UNIFORM
```
public static final int SAMPLING_UNIFORM
```
    另请参阅
    
    常量字段值
  - SAMPLING_PROGRESSIVE_NAPSAC
```
public static final int SAMPLING_PROGRESSIVE_NAPSAC
```
    另请参阅
    
    常量字段值
  - SAMPLING_NAPSAC
```
public static final int SAMPLING_NAPSAC
```
    另请参阅
    
    常量字段值
  - SAMPLING_PROSAC
```
public static final int SAMPLING_PROSAC
```
    另请参阅
    
    常量字段值
  - SCORE_METHOD_RANSAC
```
public static final int SCORE_METHOD_RANSAC
```
    另请参阅
    
    常量字段值
  - SCORE_METHOD_MSAC
```
public static final int SCORE_METHOD_MSAC
```
    另请参阅
    
    常量字段值
  - SCORE_METHOD_MAGSAC
```
public static final int SCORE_METHOD_MAGSAC
```
    另请参阅
    
    常量字段值
  - SCORE_METHOD_LMEDS
```
public static final int SCORE_METHOD_LMEDS
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_ITERATIVE
```
public static final int SOLVEPNP_ITERATIVE
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_EPNP
```
public static final int SOLVEPNP_EPNP
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_P3P
```
public static final int SOLVEPNP_P3P
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_DLS
```
public static final int SOLVEPNP_DLS
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_UPNP
```
public static final int SOLVEPNP_UPNP
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_AP3P
```
public static final int SOLVEPNP_AP3P
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_IPPE
```
public static final int SOLVEPNP_IPPE
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_IPPE_SQUARE
```
public static final int SOLVEPNP_IPPE_SQUARE
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_SQPNP
```
public static final int SOLVEPNP_SQPNP
```
    另请参阅
    
    常量字段值
  - SOLVEPNP_MAX_COUNT
```
public static final int SOLVEPNP_MAX_COUNT
```
    另请参阅
    
    常量字段值
  - PROJ_SPHERICAL_ORTHO
```
public static final int PROJ_SPHERICAL_ORTHO
```
    另请参阅
    
    常量字段值
  - PROJ_SPHERICAL_EQRECT
```
public static final int PROJ_SPHERICAL_EQRECT
```
    另请参阅
    
    常量字段值
- 构造函数详情
  - Calib3d
```
public Calib3d()
```
- 方法详情
  - Rodrigues
```
public static void Rodrigues(Mat src,
                             Mat dst,
                             Mat jacobian)
```
    将旋转矩阵转换为旋转向量，反之亦然。
    参数
    
    src - 输入旋转向量 (3x1 或 1x3) 或旋转矩阵 (3x3)。
    
    dst - 输出旋转矩阵 (3x3) 或旋转向量 (3x1 或 1x3)，分别对应。
    
    jacobian - 可选的输出雅可比矩阵，3x9 或 9x3，它是输出数组分量关于输入数组分量的偏导数矩阵。 \(\begin{array}{l} \theta \leftarrow norm(r) \\ r \leftarrow r/ \theta \\ R = \cos(\theta) I + (1- \cos{\theta} ) r r^T + \sin(\theta) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}\) 反向变换也很容易实现，因为 \(\sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}\) 旋转向量是旋转矩阵的一种方便且最紧凑的表示方式（因为任何旋转矩阵只有 3 个自由度）。这种表示方式用于全局 3D 几何优化程序，例如 REF: calibrateCamera、REF: stereoCalibrate 或 REF: solvePnP。注意： 有关计算 3D 旋转矩阵关于其指数坐标的导数的更多信息，请参见
    
    指数坐标系下三维旋转导数的紧凑公式，Guillermo Gallego，Anthony J. Yezzi CITE: Gallego2014ACF
    
    注意： 有关 SE(3) 和李群的有用信息，请参见
    
    关于 SE(3) 变换参数化和流形优化教程，Jose-Luis Blanco CITE: blanco2010tutorial
    
    二维和三维变换的李群，Ethan Eade CITE: Eade17
    
    机器人状态估计的微型李群理论，Joan Solà、Jérémie Deray、Dinesh Atchuthan CITE: Sol2018AML
  - Rodrigues
```
public static void Rodrigues(Mat src,
                             Mat dst)
```
    将旋转矩阵转换为旋转向量，反之亦然。
    参数
    
    src - 输入旋转向量 (3x1 或 1x3) 或旋转矩阵 (3x3)。
    
    dst - 输出旋转矩阵 (3x3) 或旋转向量 (3x1 或 1x3)，分别对应。输出数组分量关于输入数组分量的偏导数矩阵。 \(\begin{array}{l} \theta \leftarrow norm(r) \\ r \leftarrow r/ \theta \\ R = \cos(\theta) I + (1- \cos{\theta} ) r r^T + \sin(\theta) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}\) 反向变换也很容易实现，因为 \(\sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}\) 旋转向量是旋转矩阵的一种方便且最紧凑的表示方式（因为任何旋转矩阵只有 3 个自由度）。这种表示方式用于全局 3D 几何优化程序，例如 REF: calibrateCamera、REF: stereoCalibrate 或 REF: solvePnP。注意： 有关计算 3D 旋转矩阵关于其指数坐标的导数的更多信息，请参见
    
    指数坐标系下三维旋转导数的紧凑公式，Guillermo Gallego，Anthony J. Yezzi CITE: Gallego2014ACF
    
    注意： 有关 SE(3) 和李群的有用信息，请参见
    
    关于 SE(3) 变换参数化和流形优化教程，Jose-Luis Blanco CITE: blanco2010tutorial
    
    二维和三维变换的李群，Ethan Eade CITE: Eade17
    
    机器人状态估计的微型李群理论，Joan Solà、Jérémie Deray、Dinesh Atchuthan CITE: Sol2018AML
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 int method,
                                 double ransacReprojThreshold,
                                 Mat mask,
                                 int maxIters,
                                 double confidence)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    method - 用于计算单应性矩阵的方法。可以使用以下方法
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    ransacReprojThreshold - 将点对视为内点的最大允许重投影误差（仅在 RANSAC 和 RHO 方法中使用）。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点 \(i\) 被视为异常值。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个范围是有意义的。
    
    mask - 鲁棒方法 (RANSAC 或 LMeDS) 设置的可选输出掩码。请注意，输入掩码值将被忽略。
    
    maxIters - RANSAC 迭代的最大次数。
    
    confidence - 置信度水平，介于 0 和 1 之间。该函数查找并返回源平面和目标平面之间的透视变换 \(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，使得反投影误差 \(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\) 最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对通过简单的最小二乘法计算初始单应性估计。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（即存在一些离群值），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试对应点对的许多不同的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 而言是内点的数量，对于 LMeDS 而言是最小中值重投影误差）。然后使用最佳子集生成单应性矩阵的初始估计和内点/离群值的掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（对于鲁棒方法，仅使用内点），以进一步减小重投影误差。RANSAC 和 RHO 方法可以处理实际上任何比例的离群值，但需要一个阈值来区分内点和离群值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有离群值并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内在矩阵和外在矩阵。单应性矩阵最多确定一个比例。如果 \(h_{33}\) 不为零，则矩阵将被归一化为 \(h_{33}=1\)。注意：每当无法估计 \(H\) 矩阵时，都会返回一个空的矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 int method,
                                 double ransacReprojThreshold,
                                 Mat mask,
                                 int maxIters)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    method - 用于计算单应性矩阵的方法。可以使用以下方法
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    ransacReprojThreshold - 将点对视为内点的最大允许重投影误差（仅在 RANSAC 和 RHO 方法中使用）。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点 \(i\) 被视为异常值。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个范围是有意义的。
    
    mask - 鲁棒方法 (RANSAC 或 LMeDS) 设置的可选输出掩码。请注意，输入掩码值将被忽略。
    
    maxIters - RANSAC 迭代的最大次数。该函数查找并返回源平面和目标平面之间的透视变换 \(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，使得反投影误差 \(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\) 最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对通过简单的最小二乘法计算初始单应性估计。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（即存在一些离群值），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试对应点对的许多不同的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 而言是内点的数量，对于 LMeDS 而言是最小中值重投影误差）。然后使用最佳子集生成单应性矩阵的初始估计和内点/离群值的掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（对于鲁棒方法，仅使用内点），以进一步减小重投影误差。RANSAC 和 RHO 方法可以处理实际上任何比例的离群值，但需要一个阈值来区分内点和离群值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有离群值并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内在矩阵和外在矩阵。单应性矩阵最多确定一个比例。如果 \(h_{33}\) 不为零，则矩阵将被归一化为 \(h_{33}=1\)。注意：每当无法估计 \(H\) 矩阵时，都会返回一个空的矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 int method,
                                 double ransacReprojThreshold,
                                 Mat mask)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    method - 用于计算单应性矩阵的方法。可以使用以下方法
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    ransacReprojThreshold - 将点对视为内点的最大允许重投影误差（仅在 RANSAC 和 RHO 方法中使用）。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点 \(i\) 被视为异常值。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个范围是有意义的。
    
    mask - 由鲁棒方法（RANSAC 或 LMeDS）设置的可选输出掩码。请注意，输入掩码值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换 \(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，使得反投影误差 \(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\) 最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对通过简单的最小二乘法计算初始单应性估计。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（即存在一些离群值），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试对应点对的许多不同的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 而言是内点的数量，对于 LMeDS 而言是最小中值重投影误差）。然后使用最佳子集生成单应性矩阵的初始估计和内点/离群值的掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（对于鲁棒方法，仅使用内点），以进一步减小重投影误差。RANSAC 和 RHO 方法可以处理实际上任何比例的离群值，但需要一个阈值来区分内点和离群值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有离群值并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内在矩阵和外在矩阵。单应性矩阵最多确定一个比例。如果 \(h_{33}\) 不为零，则矩阵将被归一化为 \(h_{33}=1\)。注意：每当无法估计 \(H\) 矩阵时，都会返回一个空的矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 int method,
                                 double ransacReprojThreshold)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    method - 用于计算单应性矩阵的方法。可以使用以下方法
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    ransacReprojThreshold - 最大允许重投影误差，用于将点对视为内点（仅在 RANSAC 和 RHO 方法中使用）。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点\(i\)被视为外点。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个值是合理的。mask 值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换\(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，以便反投影误差\(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\)最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对来计算初始单应性估计，采用简单的最小二乘方案。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（也就是说，存在一些外点），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试许多不同的对应点对的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 来说是内点数，对于 LMeDS 来说是最小中位数重投影误差）。然后，使用最佳子集来生成单应性矩阵的初始估计和内点/外点掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（在鲁棒方法的情况下，仅使用内点），以进一步减少重投影误差。RANSAC 和 RHO 方法可以处理几乎任何比例的外点，但需要一个阈值来区分内点和外点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有外点并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内参矩阵和外参矩阵。单应性矩阵取决于比例因子。如果\(h_{33}\)非零，则矩阵将被归一化，使得\(h_{33}=1\)。注意：每当无法估计\(H\)矩阵时，都将返回一个空矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 int method)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    method - 用于计算单应性矩阵的方法。可以使用以下方法
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    (仅在 RANSAC 和 RHO 方法中使用)。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点\(i\)被视为外点。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个值是合理的。mask 值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换\(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，以便反投影误差\(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\)最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对来计算初始单应性估计，采用简单的最小二乘方案。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（也就是说，存在一些外点），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试许多不同的对应点对的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 来说是内点数，对于 LMeDS 来说是最小中位数重投影误差）。然后，使用最佳子集来生成单应性矩阵的初始估计和内点/外点掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（在鲁棒方法的情况下，仅使用内点），以进一步减少重投影误差。RANSAC 和 RHO 方法可以处理几乎任何比例的外点，但需要一个阈值来区分内点和外点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有外点并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内参矩阵和外参矩阵。单应性矩阵取决于比例因子。如果\(h_{33}\)非零，则矩阵将被归一化，使得\(h_{33}=1\)。注意：每当无法估计\(H\)矩阵时，都将返回一个空矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints)
```
    查找两个平面之间的透视变换。
    参数
    
    srcPoints - 原平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    dstPoints - 目标平面中点的坐标，类型为 CV_32FC2 的矩阵或 vector<Point2f>。
    
    0 - 使用所有点的常规方法，即最小二乘法
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法
    
    REF: RHO - 基于 PROSAC 的鲁棒方法
    
    (仅在 RANSAC 和 RHO 方法中使用)。也就是说，如果 \(\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \cdot \texttt{srcPoints} _i) \|_2 > \texttt{ransacReprojThreshold}\)，则点\(i\)被视为外点。如果 srcPoints 和 dstPoints 以像素为单位测量，则通常将此参数设置为 1 到 10 之间的某个值是合理的。mask 值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换\(H\)：\(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，以便反投影误差\(\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\)最小化。如果参数 method 设置为默认值 0，则该函数使用所有点对来计算初始单应性估计，采用简单的最小二乘方案。但是，如果并非所有点对（\(srcPoints_i\)，\(dstPoints_i\)）都符合刚性透视变换（也就是说，存在一些外点），则此初始估计将很差。在这种情况下，您可以使用三种鲁棒方法之一。RANSAC、LMeDS 和 RHO 方法尝试许多不同的对应点对的随机子集（每个子集包含四对点，共线点对将被丢弃），使用此子集和简单的最小二乘算法估计单应性矩阵，然后计算所计算单应性的质量/优度（对于 RANSAC 来说是内点数，对于 LMeDS 来说是最小中位数重投影误差）。然后，使用最佳子集来生成单应性矩阵的初始估计和内点/外点掩码。无论方法是鲁棒的还是非鲁棒的，计算出的单应性矩阵都将使用 Levenberg-Marquardt 方法进一步细化（在鲁棒方法的情况下，仅使用内点），以进一步减少重投影误差。RANSAC 和 RHO 方法可以处理几乎任何比例的外点，但需要一个阈值来区分内点和外点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。最后，如果没有外点并且噪声相当小，请使用默认方法 (method=0)。该函数用于查找初始内参矩阵和外参矩阵。单应性矩阵取决于比例因子。如果\(h_{33}\)非零，则矩阵将被归一化，使得\(h_{33}=1\)。注意：每当无法估计\(H\)矩阵时，都将返回一个空矩阵。参见：getAffineTransform、estimateAffine2D、estimateAffinePartial2D、getPerspectiveTransform、warpPerspective、perspectiveTransform
    
    返回值
    
    自动生成
  - findHomography
```
public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints,
                                 Mat mask,
                                 UsacParams params)
```
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ,
                                   Mat Qx,
                                   Mat Qy,
                                   Mat Qz)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。
    
    Qx - 可选输出 3x3 绕 x 轴旋转矩阵。
    
    Qy - 可选输出 3x3 绕 y 轴旋转矩阵。
    
    Qz - 可选输出 3x3 绕 z 轴旋转矩阵。该函数使用给定的旋转计算 RQ 分解。此函数用于 #decomposeProjectionMatrix 将投影矩阵的左上角 3x3 子矩阵分解为相机矩阵和旋转矩阵。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角（以度为单位，作为返回值），这些可以用于 OpenGL。注意，总存在多个绕三个主轴旋转的序列会导致对象的相同方向，例如参见 CITE: Slabaugh。返回的三个旋转矩阵和相应的三个欧拉角只是可能的解之一。
    
    返回值
    
    自动生成
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ,
                                   Mat Qx,
                                   Mat Qy)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。
    
    Qx - 可选输出 3x3 绕 x 轴旋转矩阵。
    
    Qy - 可选输出 3x3 绕 y 轴旋转矩阵。该函数使用给定的旋转计算 RQ 分解。此函数用于 #decomposeProjectionMatrix 将投影矩阵的左上角 3x3 子矩阵分解为相机矩阵和旋转矩阵。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角（以度为单位，作为返回值），这些可以用于 OpenGL。注意，总存在多个绕三个主轴旋转的序列会导致对象的相同方向，例如参见 CITE: Slabaugh。返回的三个旋转矩阵和相应的三个欧拉角只是可能的解之一。
    
    返回值
    
    自动生成
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ,
                                   Mat Qx)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。
    
    Qx - 可选输出 3x3 绕 x 轴旋转矩阵。该函数使用给定的旋转计算 RQ 分解。此函数用于 #decomposeProjectionMatrix 将投影矩阵的左 3x3 子矩阵分解为相机和旋转矩阵。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角（以度为单位，作为返回值），这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。
    
    返回值
    
    自动生成
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。该函数使用给定的旋转计算 RQ 分解。此函数用于 #decomposeProjectionMatrix 将投影矩阵的左 3x3 子矩阵分解为相机和旋转矩阵。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角（以度为单位，作为返回值），这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。
    
    返回值
    
    自动生成
  - decomposeProjectionMatrix
```
public static void decomposeProjectionMatrix(Mat projMatrix,
                                             Mat cameraMatrix,
                                             Mat rotMatrix,
                                             Mat transVect,
                                             Mat rotMatrixX,
                                             Mat rotMatrixY,
                                             Mat rotMatrixZ,
                                             Mat eulerAngles)
```
    将投影矩阵分解为旋转矩阵和相机内参矩阵。
    
    参数
    
    projMatrix - 3x4 输入投影矩阵 P。
    
    cameraMatrix - 输出 3x3 相机内参矩阵 \(\cameramatrix{A}\)。
    
    rotMatrix - 输出 3x3 外部旋转矩阵 R。
    
    transVect - 输出 4x1 平移向量 T。
    
    rotMatrixX - 可选 3x3 绕 x 轴旋转矩阵。
    
    rotMatrixY - 可选 3x3 绕 y 轴旋转矩阵。
    
    rotMatrixZ - 可选 3x3 绕 z 轴旋转矩阵。
    
    eulerAngles - 可选的三元素向量，包含以度为单位的三个欧拉旋转角。该函数计算投影矩阵分解为校准和旋转矩阵以及相机位置。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角，这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。该函数基于 #RQDecomp3x3。
  - decomposeProjectionMatrix
```
public static void decomposeProjectionMatrix(Mat projMatrix,
                                             Mat cameraMatrix,
                                             Mat rotMatrix,
                                             Mat transVect,
                                             Mat rotMatrixX,
                                             Mat rotMatrixY,
                                             Mat rotMatrixZ)
```
    将投影矩阵分解为旋转矩阵和相机内参矩阵。
    
    参数
    
    projMatrix - 3x4 输入投影矩阵 P。
    
    cameraMatrix - 输出 3x3 相机内参矩阵 \(\cameramatrix{A}\)。
    
    rotMatrix - 输出 3x3 外部旋转矩阵 R。
    
    transVect - 输出 4x1 平移向量 T。
    
    rotMatrixX - 可选 3x3 绕 x 轴旋转矩阵。
    
    rotMatrixY - 可选 3x3 绕 y 轴旋转矩阵。
    
    rotMatrixZ - 可选 3x3 绕 z 轴旋转矩阵。以度为单位。该函数计算投影矩阵分解为校准和旋转矩阵以及相机位置。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角，这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。该函数基于 #RQDecomp3x3。
  - decomposeProjectionMatrix
```
public static void decomposeProjectionMatrix(Mat projMatrix,
                                             Mat cameraMatrix,
                                             Mat rotMatrix,
                                             Mat transVect,
                                             Mat rotMatrixX,
                                             Mat rotMatrixY)
```
    将投影矩阵分解为旋转矩阵和相机内参矩阵。
    
    参数
    
    projMatrix - 3x4 输入投影矩阵 P。
    
    cameraMatrix - 输出 3x3 相机内参矩阵 \(\cameramatrix{A}\)。
    
    rotMatrix - 输出 3x3 外部旋转矩阵 R。
    
    transVect - 输出 4x1 平移向量 T。
    
    rotMatrixX - 可选 3x3 绕 x 轴旋转矩阵。
    
    rotMatrixY - 可选 3x3 绕 y 轴旋转矩阵。以度为单位。该函数计算投影矩阵分解为校准和旋转矩阵以及相机位置。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角，这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。该函数基于 #RQDecomp3x3。
  - decomposeProjectionMatrix
```
public static void decomposeProjectionMatrix(Mat projMatrix,
                                             Mat cameraMatrix,
                                             Mat rotMatrix,
                                             Mat transVect,
                                             Mat rotMatrixX)
```
    将投影矩阵分解为旋转矩阵和相机内参矩阵。
    
    参数
    
    projMatrix - 3x4 输入投影矩阵 P。
    
    cameraMatrix - 输出 3x3 相机内参矩阵 \(\cameramatrix{A}\)。
    
    rotMatrix - 输出 3x3 外部旋转矩阵 R。
    
    transVect - 输出 4x1 平移向量 T。
    
    rotMatrixX - 可选 3x3 绕 x 轴旋转矩阵。以度为单位。该函数计算投影矩阵分解为校准和旋转矩阵以及相机位置。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角，这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。该函数基于 #RQDecomp3x3。
  - decomposeProjectionMatrix
```
public static void decomposeProjectionMatrix(Mat projMatrix,
                                             Mat cameraMatrix,
                                             Mat rotMatrix,
                                             Mat transVect)
```
    将投影矩阵分解为旋转矩阵和相机内参矩阵。
    
    参数
    
    projMatrix - 3x4 输入投影矩阵 P。
    
    cameraMatrix - 输出 3x3 相机内参矩阵 \(\cameramatrix{A}\)。
    
    rotMatrix - 输出 3x3 外部旋转矩阵 R。
    
    transVect - 输出 4x1 平移向量 T。以度为单位。该函数计算投影矩阵分解为校准和旋转矩阵以及相机位置。它可以选择返回三个旋转矩阵（每个轴一个）和三个欧拉角，这些可以用于 OpenGL。请注意，总有多个绕三个主轴旋转的序列会导致物体的方向相同，例如参见文献：Slabaugh。返回的三个旋转矩阵和对应的三个欧拉角只是可能的解之一。该函数基于 #RQDecomp3x3。
  - matMulDeriv
```
public static void matMulDeriv(Mat A,
                               Mat B,
                               Mat dABdA,
                               Mat dABdB)
```
    计算每个相乘矩阵的矩阵乘积的偏导数。
    
    参数
    
    A - 第一个相乘矩阵。
    
    B - 第二个相乘矩阵。
    
    dABdA - 第一个输出导数矩阵 d(A\*B)/dA，大小为 \(\texttt{A.rows*B.cols} \times {A.rows*A.cols}\) 。
    
    dABdB - 第二个输出导数矩阵 d(A\*B)/dB，大小为 \(\texttt{A.rows*B.cols} \times {B.rows*B.cols}\) 。该函数计算矩阵乘积 \(A*B\) 的元素相对于两个输入矩阵中每个矩阵的元素的偏导数。该函数用于计算 #stereoCalibrate 中的雅可比矩阵，但也可以用于任何其他类似的优化函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2,
                             Mat dr3dt2,
                             Mat dt3dr1,
                             Mat dt3dt1,
                             Mat dt3dr2,
                             Mat dt3dt2)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出 rvec3 相对于 rvec2 的导数
    
    dr3dt2 - 可选输出 rvec3 相对于 tvec2 的导数
    
    dt3dr1 - 可选输出 tvec3 相对于 rvec1 的导数
    
    dt3dt1 - 可选输出 tvec3 相对于 tvec1 的导数
    
    dt3dr2 - 可选输出 tvec3 相对于 rvec2 的导数
    
    dt3dt2 - 可选输出 tvec3 相对于 tvec2 的导数。这些函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的变换，而 \(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情请参见 #Rodrigues。此外，这些函数还可以计算输出向量相对于输入向量的导数（参见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2,
                             Mat dr3dt2,
                             Mat dt3dr1,
                             Mat dt3dt1,
                             Mat dt3dr2)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出 rvec3 相对于 rvec2 的导数
    
    dr3dt2 - 可选输出 rvec3 相对于 tvec2 的导数
    
    dt3dr1 - 可选输出 tvec3 相对于 rvec1 的导数
    
    dt3dt1 - 可选输出 tvec3 相对于 tvec1 的导数
    
    dt3dr2 - 可选输出，tvec3 关于 rvec2 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2,
                             Mat dr3dt2,
                             Mat dt3dr1,
                             Mat dt3dt1)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出 rvec3 相对于 rvec2 的导数
    
    dr3dt2 - 可选输出 rvec3 相对于 tvec2 的导数
    
    dt3dr1 - 可选输出 tvec3 相对于 rvec1 的导数
    
    dt3dt1 - 可选输出，tvec3 关于 tvec1 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2,
                             Mat dr3dt2,
                             Mat dt3dr1)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出 rvec3 相对于 rvec2 的导数
    
    dr3dt2 - 可选输出 rvec3 相对于 tvec2 的导数
    
    dt3dr1 - 可选输出，tvec3 关于 rvec1 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2,
                             Mat dr3dt2)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出 rvec3 相对于 rvec2 的导数
    
    dr3dt2 - 可选输出，rvec3 关于 tvec2 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1,
                             Mat dr3dr2)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出 rvec3 相对于 tvec1 的导数
    
    dr3dr2 - 可选输出，rvec3 关于 rvec2 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1,
                             Mat dr3dt1)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出 rvec3 相对于 rvec1 的导数
    
    dr3dt1 - 可选输出，rvec3 关于 tvec1 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3,
                             Mat dr3dr1)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 输出叠加的平移向量。
    
    dr3dr1 - 可选输出，rvec3 关于 rvec1 的导数。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3)
```
    组合两个旋转和平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 输出叠加的旋转向量。
    
    tvec3 - 叠加的输出平移向量。函数计算：\(\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\) 其中 \(\mathrm{rodrigues}\) 表示旋转向量到旋转矩阵的转换，\(\mathrm{rodrigues}^{-1}\) 表示逆变换。详情见 #Rodrigues。此外，这些函数可以计算输出向量关于输入向量的导数（见 #matMulDeriv）。这些函数在 #stereoCalibrate 内部使用，但也可以在您自己的代码中使用，其中 Levenberg-Marquardt 或其他基于梯度的求解器用于优化包含矩阵乘法的函数。
  - projectPoints
```
public static void projectPoints(MatOfPoint3f objectPoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat cameraMatrix,
                                 MatOfDouble distCoeffs,
                                 MatOfPoint2f imagePoints,
                                 Mat jacobian,
                                 double aspectRatio)
```
    将3D点投影到图像平面。
    
    参数
    
    objectPoints - 表示为世界坐标系的对象点数组。一个 3xN/Nx3 单通道或 1xN/Nx1 三通道（或 vector<Point3f>）数组，其中 N 是视角中的点数。
    
    rvec - 旋转向量 (REF: Rodrigues)，它与 tvec 一起执行从世界坐标系到相机坐标系的基变换，详情见 REF: calibrateCamera。
    
    tvec - 平移向量，见上文参数描述。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数输入向量 \(\distcoeffs\) 。如果向量为空，则假设畸变系数为零。
    
    imagePoints - 图像点输出数组，1xN/Nx1 双通道，或 vector<Point2f> 。
    
    jacobian - 可选输出，图像点关于旋转向量、平移向量、焦距、主点坐标和畸变系数分量的导数的 2Nx(10+<numDistCoeffs>) 雅可比矩阵。在旧接口中，雅可比矩阵的不同分量通过不同的输出参数返回。
    
    aspectRatio - 可选的“固定纵横比”参数。如果参数不为 0，则函数假设纵横比（\(f_x / f_y\)）是固定的，并相应地调整雅可比矩阵。该函数根据内参和外参计算 3D 点在图像平面上的 2D 投影。可选地，该函数计算雅可比矩阵——图像点坐标（作为所有输入参数的函数）关于特定参数（内参和/或外参）的偏导数矩阵。雅可比矩阵在 REF: calibrateCamera、REF: solvePnP 和 REF: stereoCalibrate 中的全局优化过程中使用。该函数本身也可以用来计算重投影误差，给定当前的内参和外参。注意：通过设置 rvec = tvec = \([0, 0, 0]\) 或将 cameraMatrix 设置为 3x3 单位矩阵，或传递零畸变系数，可以得到函数的各种有用的特例。这意味着，可以在理想的零畸变设置中计算稀疏点集的畸变坐标或应用透视变换（以及计算导数）。
  - projectPoints
```
public static void projectPoints(MatOfPoint3f objectPoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat cameraMatrix,
                                 MatOfDouble distCoeffs,
                                 MatOfPoint2f imagePoints,
                                 Mat jacobian)
```
    将3D点投影到图像平面。
    
    参数
    
    objectPoints - 表示为世界坐标系的对象点数组。一个 3xN/Nx3 单通道或 1xN/Nx1 三通道（或 vector<Point3f>）数组，其中 N 是视角中的点数。
    
    rvec - 旋转向量 (REF: Rodrigues)，它与 tvec 一起执行从世界坐标系到相机坐标系的基变换，详情见 REF: calibrateCamera。
    
    tvec - 平移向量，见上文参数描述。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数输入向量 \(\distcoeffs\) 。如果向量为空，则假设畸变系数为零。
    
    imagePoints - 图像点输出数组，1xN/Nx1 双通道，或 vector<Point2f> 。
    
    jacobian - 可选的输出 2Nx(10+) 雅可比矩阵，表示图像点关于旋转向量、平移向量、焦距、主点坐标和畸变系数分量的导数。在旧接口中，雅可比矩阵的不同分量通过不同的输出参数返回。函数假设纵横比（\(f_x / f_y\)）是固定的，并相应地调整雅可比矩阵。该函数根据内参和外参计算 3D 点在图像平面上的 2D 投影。可选地，该函数计算雅可比矩阵——图像点坐标（作为所有输入参数的函数）关于特定参数（内参和/或外参）的偏导数矩阵。雅可比矩阵在 REF: calibrateCamera、REF: solvePnP 和 REF: stereoCalibrate 中的全局优化过程中使用。该函数本身也可以用来计算重投影误差，给定当前的内参和外参。注意：通过设置 rvec = tvec = \([0, 0, 0]\) 或将 cameraMatrix 设置为 3x3 单位矩阵，或传递零畸变系数，可以得到函数的各种有用的特例。这意味着，可以在理想的零畸变设置中计算稀疏点集的畸变坐标或应用透视变换（以及计算导数）。
  - projectPoints
```
public static void projectPoints(MatOfPoint3f objectPoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat cameraMatrix,
                                 MatOfDouble distCoeffs,
                                 MatOfPoint2f imagePoints)
```
    将3D点投影到图像平面。
    
    参数
    
    objectPoints - 表示为世界坐标系的对象点数组。一个 3xN/Nx3 单通道或 1xN/Nx1 三通道（或 vector<Point3f>）数组，其中 N 是视角中的点数。
    
    rvec - 旋转向量 (REF: Rodrigues)，它与 tvec 一起执行从世界坐标系到相机坐标系的基变换，详情见 REF: calibrateCamera。
    
    tvec - 平移向量，见上文参数描述。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数输入向量 \(\distcoeffs\) 。如果向量为空，则假设畸变系数为零。
    
    imagePoints - 输出图像点数组，1xN/Nx1 2 通道，或 vector<Point2f>。点关于旋转向量、平移向量、焦距、主点坐标和畸变系数分量的导数。在旧接口中，雅可比矩阵的不同分量通过不同的输出参数返回。函数假设纵横比（\(f_x / f_y\)）是固定的，并相应地调整雅可比矩阵。该函数根据内参和外参计算 3D 点在图像平面上的 2D 投影。可选地，该函数计算雅可比矩阵——图像点坐标（作为所有输入参数的函数）关于特定参数（内参和/或外参）的偏导数矩阵。雅可比矩阵在 REF: calibrateCamera、REF: solvePnP 和 REF: stereoCalibrate 中的全局优化过程中使用。该函数本身也可以用来计算重投影误差，给定当前的内参和外参。注意：通过设置 rvec = tvec = \([0, 0, 0]\) 或将 cameraMatrix 设置为 3x3 单位矩阵，或传递零畸变系数，可以得到函数的各种有用的特例。这意味着，可以在理想的零畸变设置中计算稀疏点集的畸变坐标或应用透视变换（以及计算导数）。
  - solvePnP
```
public static boolean solvePnP(MatOfPoint3f objectPoints,
                               MatOfPoint2f imagePoints,
                               Mat cameraMatrix,
                               MatOfDouble distCoeffs,
                               Mat rvec,
                               Mat tvec,
                               boolean useExtrinsicGuess,
                               int flags)
```
    根据 3D-2D 点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数使用不同的方法返回旋转和平移向量，这些向量将以物体坐标系表示的 3D 点转换到相机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 求解 PnP 问题的算法：参见 REF: calib3d_solvePnP_flags 有关透视 n 点法的更多信息，请参见 REF: calib3d_solvePnP 注意：
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于 REF: SOLVEPNP_SQPNP，输入点数必须 >= 3
    
    返回值
    
    自动生成
  - solvePnP
```
public static boolean solvePnP(MatOfPoint3f objectPoints,
                               MatOfPoint2f imagePoints,
                               Mat cameraMatrix,
                               MatOfDouble distCoeffs,
                               Mat rvec,
                               Mat tvec,
                               boolean useExtrinsicGuess)
```
    根据 3D-2D 点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数使用不同的方法返回旋转和平移向量，这些向量将以物体坐标系表示的 3D 点转换到相机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。有关透视 n 点法的更多信息，请参见 REF: calib3d_solvePnP 注意：
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于 REF: SOLVEPNP_SQPNP，输入点数必须 >= 3
    
    返回值
    
    自动生成
  - solvePnP
```
public static boolean solvePnP(MatOfPoint3f objectPoints,
                               MatOfPoint2f imagePoints,
                               Mat cameraMatrix,
                               MatOfDouble distCoeffs,
                               Mat rvec,
                               Mat tvec)
```
    根据 3D-2D 点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数使用不同的方法返回旋转和平移向量，这些向量将以物体坐标系表示的 3D 点转换到相机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。有关透视 n 点法的更多信息，请参见 REF: calib3d_solvePnP 注意：
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于 REF: SOLVEPNP_SQPNP，输入点数必须 >= 3
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess,
                                     int iterationsCount,
                                     float reprojectionError,
                                     double confidence,
                                     Mat inliers,
                                     int flags)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 程序使用的内点阈值。参数值是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 包含 objectPoints 和 imagePoints 中内点索引的输出向量。
    
    flags - 用于解决 PnP 问题的方法（参见 REF: solvePnP）。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess,
                                     int iterationsCount,
                                     float reprojectionError,
                                     double confidence,
                                     Mat inliers)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 程序使用的内点阈值。参数值是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 包含 objectPoints 和 imagePoints 中内点索引的输出向量。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess,
                                     int iterationsCount,
                                     float reprojectionError,
                                     double confidence)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 程序使用的内点阈值。参数值是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。
    
    confidence - 算法产生有用结果的概率。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess,
                                     int iterationsCount,
                                     float reprojectionError)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 程序使用的内点阈值。参数值是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess,
                                     int iterationsCount)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec)
```
    使用 RANSAC 方案根据 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。使用提供的 rvec 和 tvec 值分别作为旋转向量和平移向量的初始近似值，并进一步优化它们。是观察到的点投影和计算出的点投影之间允许的最大距离，超过此距离则认为其为离群点。该函数根据一组目标点、其对应的图像投影以及相机内参矩阵和畸变系数来估计物体位姿。此函数找到最小化重投影误差的位姿，即观察到的投影 imagePoints 与投影 (使用 REF: projectPoints) 的 objectPoints 之间的平方距离之和。使用 RANSAC 使函数能够抵抗离群点。注意：
    
    如何在物体检测中使用 solvePNPRansac 的示例，请参见 opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
    
    用于估计最小样本集步骤中相机位姿的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，则将使用这些方法。
    
    如果输入点数等于 4，则使用 #SOLVEPNP_P3P。
    
    除非 flags 参数等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，否则用于使用所有内点估计相机位姿的方法由 flags 参数定义。在这种情况下，将改为使用 #SOLVEPNP_EPNP 方法。
    
    返回值
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     Mat inliers,
                                     UsacParams params)
```
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     Mat inliers)
```
  - solveP3P
```
public static int solveP3P(Mat objectPoints,
                           Mat imagePoints,
                           Mat cameraMatrix,
                           Mat distCoeffs,
                           java.util.List<Mat> rvecs,
                           java.util.List<Mat> tvecs,
                           int flags)
```
    根据 3 个 3D-2D 点对应关系查找物体位姿。参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 物体坐标系中物体点的数组，3x3 单通道或 1x3/3x1 三通道。也可以在此处传递 vector<Point3f>。
    
    imagePoints - 对应的图像点的数组，3x2 单通道或 1x3/3x1 双通道。也可以在此处传递 vector<Point2f>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。P3P问题最多有4个解。
    
    tvecs - 输出平移向量。
    
    flags - 求解P3P问题的方法
    
    REF: SOLVEPNP_P3P 方法基于X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang 的论文 "Complete Solution Classification for the Perspective-Three-Point Problem" (CITE: gao2003complete)。
    
    REF: SOLVEPNP_AP3P 方法基于T. Ke 和 S. Roumeliotis 的论文 "An Efficient Algebraic Solution to the Perspective-Three-Point Problem" (CITE: Ke17)。
    
    该函数根据3个目标点、它们对应的图像投影、相机内参矩阵和畸变系数来估计目标姿态。**注意：**解按重投影误差排序（从小到大）。
    
    返回值
    
    自动生成
  - solvePnPRefineLM
```
public static void solvePnPRefineLM(Mat objectPoints,
                                    Mat imagePoints,
                                    Mat cameraMatrix,
                                    Mat distCoeffs,
                                    Mat rvec,
                                    Mat tvec,
                                    TermCriteria criteria)
```
    根据3D-2D点对应关系，并从初始解出发，优化姿态（将以物体坐标系表示的3D点转换到相机坐标系的平移和旋转）。参见：REF: calib3d_solvePnP
    
    参数
    
    objectPoints - 物体坐标系中物体点的数组，Nx3单通道或1xN/Nx1三通道，其中N是点数。也可以传入vector<Point3d>。
    
    imagePoints - 对应的图像点的数组，Nx2单通道或1xN/Nx1双通道，其中N是点数。也可以传入vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输入/输出旋转向量（参见 REF: Rodrigues），与tvec一起，将模型坐标系中的点转换到相机坐标系。输入值用作初始解。
    
    tvec - 输入/输出平移向量。输入值用作初始解。
    
    criteria - 停止Levenberg-Marquardt迭代算法的条件。该函数根据至少3个目标点、它们对应的图像投影、旋转和平移向量的初始解、相机内参矩阵和畸变系数来优化目标姿态。根据Levenberg-Marquardt迭代最小化过程 CITE: Madsen04 CITE: Eade13，该函数最小化关于旋转和平移向量的投影误差。
  - solvePnPRefineLM
```
public static void solvePnPRefineLM(Mat objectPoints,
                                    Mat imagePoints,
                                    Mat cameraMatrix,
                                    Mat distCoeffs,
                                    Mat rvec,
                                    Mat tvec)
```
    根据3D-2D点对应关系，并从初始解出发，优化姿态（将以物体坐标系表示的3D点转换到相机坐标系的平移和旋转）。参见：REF: calib3d_solvePnP
    
    参数
    
    objectPoints - 物体坐标系中物体点的数组，Nx3单通道或1xN/Nx1三通道，其中N是点数。也可以传入vector<Point3d>。
    
    imagePoints - 对应的图像点的数组，Nx2单通道或1xN/Nx1双通道，其中N是点数。也可以传入vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输入/输出旋转向量（参见 REF: Rodrigues），与tvec一起，将模型坐标系中的点转换到相机坐标系。输入值用作初始解。
    
    tvec - 输入/输出平移向量。输入值用作初始解。该函数根据至少3个目标点、它们对应的图像投影、旋转和平移向量的初始解、相机内参矩阵和畸变系数来优化目标姿态。根据Levenberg-Marquardt迭代最小化过程 CITE: Madsen04 CITE: Eade13，该函数最小化关于旋转和平移向量的投影误差。
  - solvePnPRefineVVS
```
public static void solvePnPRefineVVS(Mat objectPoints,
                                     Mat imagePoints,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     TermCriteria criteria,
                                     double VVSlambda)
```
    根据3D-2D点对应关系，并从初始解出发，优化姿态（将以物体坐标系表示的3D点转换到相机坐标系的平移和旋转）。参见：REF: calib3d_solvePnP
    
    参数
    
    objectPoints - 物体坐标系中物体点的数组，Nx3单通道或1xN/Nx1三通道，其中N是点数。也可以传入vector<Point3d>。
    
    imagePoints - 对应的图像点的数组，Nx2单通道或1xN/Nx1双通道，其中N是点数。也可以传入vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输入/输出旋转向量（参见 REF: Rodrigues），与tvec一起，将模型坐标系中的点转换到相机坐标系。输入值用作初始解。
    
    tvec - 输入/输出平移向量。输入值用作初始解。
    
    criteria - 停止Levenberg-Marquardt迭代算法的条件。
    
    VVSlambda - 虚拟视觉伺服控制律的增益，相当于阻尼高斯-牛顿公式中的α增益。该函数根据至少3个目标点、它们对应的图像投影、旋转和平移向量的初始解、相机内参矩阵和畸变系数来优化目标姿态。使用虚拟视觉伺服(VVS) CITE: Chaumette06 CITE: Marchand16 方案，该函数最小化关于旋转和平移向量的投影误差。
  - solvePnPRefineVVS
```
public static void solvePnPRefineVVS(Mat objectPoints,
                                     Mat imagePoints,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     TermCriteria criteria)
```
    根据3D-2D点对应关系，并从初始解出发，优化姿态（将以物体坐标系表示的3D点转换到相机坐标系的平移和旋转）。参见：REF: calib3d_solvePnP
    
    参数
    
    objectPoints - 物体坐标系中物体点的数组，Nx3单通道或1xN/Nx1三通道，其中N是点数。也可以传入vector<Point3d>。
    
    imagePoints - 对应的图像点的数组，Nx2单通道或1xN/Nx1双通道，其中N是点数。也可以传入vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输入/输出旋转向量（参见 REF: Rodrigues），与tvec一起，将模型坐标系中的点转换到相机坐标系。输入值用作初始解。
    
    tvec - 输入/输出平移向量。输入值用作初始解。
    
    criteria - 停止Levenberg-Marquardt迭代算法的条件。阻尼高斯-牛顿公式中的增益。该函数根据至少3个目标点、它们对应的图像投影、旋转和平移向量的初始解、相机内参矩阵和畸变系数来优化目标姿态。使用虚拟视觉伺服(VVS) CITE: Chaumette06 CITE: Marchand16 方案，该函数最小化关于旋转和平移向量的投影误差。
  - solvePnPRefineVVS
```
public static void solvePnPRefineVVS(Mat objectPoints,
                                     Mat imagePoints,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     Mat rvec,
                                     Mat tvec)
```
    根据3D-2D点对应关系，并从初始解出发，优化姿态（将以物体坐标系表示的3D点转换到相机坐标系的平移和旋转）。参见：REF: calib3d_solvePnP
    
    参数
    
    objectPoints - 物体坐标系中物体点的数组，Nx3单通道或1xN/Nx1三通道，其中N是点数。也可以传入vector<Point3d>。
    
    imagePoints - 对应的图像点的数组，Nx2单通道或1xN/Nx1双通道，其中N是点数。也可以传入vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输入/输出旋转向量（参见 REF: Rodrigues），与tvec一起，将模型坐标系中的点转换到相机坐标系。输入值用作初始解。
    
    tvec - 输入/输出平移向量。输入值用作初始解。阻尼高斯-牛顿公式中的增益。该函数根据至少3个目标点、它们对应的图像投影、旋转和平移向量的初始解、相机内参矩阵和畸变系数来优化目标姿态。使用虚拟视觉伺服(VVS) CITE: Chaumette06 CITE: Marchand16 方案，该函数最小化关于旋转和平移向量的投影误差。
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs,
                                  boolean useExtrinsicGuess,
                                  int flags,
                                  Mat rvec,
                                  Mat tvec,
                                  Mat reprojectionError)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 求解PnP问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 当标志为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时，用于初始化迭代 PnP 细化算法的旋转向量。
    
    tvec - 当标志为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时，用于初始化迭代 PnP 细化算法的平移向量。
    
    reprojectionError - 可选的重投影误差向量，即输入图像点与使用估计姿态投影的3D物体点之间的均方根误差 ( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \) )。更多信息在 REF: calib3d_solvePnP 中描述 **注意：**
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs,
                                  boolean useExtrinsicGuess,
                                  int flags,
                                  Mat rvec,
                                  Mat tvec)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 求解PnP问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 当标志为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时，用于初始化迭代 PnP 细化算法的旋转向量。
    
    tvec - 当标志为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时，用于初始化迭代 PnP 细化算法的平移向量。 ( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \) ) 输入图像点与使用估计姿态投影的3D物体点之间的均方根误差。更多信息在 REF: calib3d_solvePnP 中描述 **注意：**
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs,
                                  boolean useExtrinsicGuess,
                                  int flags,
                                  Mat rvec)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 求解PnP问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 当标志为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时，用于初始化迭代 PnP 细化算法的旋转向量。且 useExtrinsicGuess 设置为 true。( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \) ) 输入图像点与使用估计姿态投影的3D物体点之间的均方根误差。更多信息在 REF: calib3d_solvePnP 中描述 **注意：**
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs,
                                  boolean useExtrinsicGuess,
                                  int flags)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 求解PnP问题的方法：参见 REF: calib3d_solvePnP_flags 且 useExtrinsicGuess 设置为 true。且 useExtrinsicGuess 设置为 true。( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \) ) 输入图像点与使用估计姿态投影的3D物体点之间的均方根误差。更多信息在 REF: calib3d_solvePnP 中描述 **注意：**
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs,
                                  boolean useExtrinsicGuess)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值分别作为旋转和平移向量的初始近似值，并进一步优化它们。且 useExtrinsicGuess 设置为 true。且 useExtrinsicGuess 设置为 true。( \( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \) ) 输入图像点与使用估计姿态投影的3D物体点之间的均方根误差。更多信息在 REF: calib3d_solvePnP 中描述 **注意：**
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - solvePnPGeneric
```
public static int solvePnPGeneric(Mat objectPoints,
                                  Mat imagePoints,
                                  Mat cameraMatrix,
                                  Mat distCoeffs,
                                  java.util.List<Mat> rvecs,
                                  java.util.List<Mat> tvecs)
```
    根据3D-2D点对应关系查找物体姿态。参见：REF: calib3d_solvePnP 此函数返回所有可能的解的列表（解是一个<旋转向量，平移向量>对），取决于输入点的数量和选择的方法。
    
    P3P方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3或4个输入点。对于3个输入点，返回的解的数量可以在0到4之间。
    
    REF: SOLVEPNP_IPPE 输入点必须>=4，并且物体点必须共面。返回2个解。
    
    REF: SOLVEPNP_IPPE_SQUARE 适用于标记姿态估计的特殊情况。输入点数必须为4，返回2个解。物体点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须>=4，物体点可以处于任何配置。只返回1个解。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量的向量（参见 REF: Rodrigues），与tvecs一起，将模型坐标系中的点转换到相机坐标系。
    
    tvecs - 输出平移向量向量。该函数使用提供的rvec和tvec值作为旋转和平移向量的初始近似值，并进一步优化它们。并且useExtrinsicGuess设置为true。并且useExtrinsicGuess设置为true。（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）表示输入图像点和使用估计姿态投影的3D物体点之间的均方根误差。更多信息请参见REF: calib3d_solvePnP 注意：
    
    如何在平面增强现实中使用 solvePnP 的示例，请参见 opencv_source_code/samples/python/plane_ar.py
    
    如果您使用的是 Python
    
    NumPy 数组切片不能用作输入，因为 solvePnP 需要连续数组（由使用 cv::Mat::checkVector() 的断言强制执行，位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 55 行）。
    
    由于其调用了 #undistortPoints（位于 modules/calib3d/src/solvepnp.cpp 版本 2.4.9 的大约第 75 行），需要 2 通道信息，因此 P3P 算法要求图像点位于形状为 (N,1,2) 的数组中。
    
    因此，给定一些数据 D = np.array(...)，其中 D.shape = (N,M)，为了使用它的子集作为例如 imagePoints，必须将其有效地复制到新数组中：imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
    
    由于当前实现不稳定，有时会给出完全错误的结果，因此无法使用 REF: SOLVEPNP_DLS 和 REF: SOLVEPNP_UPNP 方法。如果传递这两个标志之一，则将改为使用 REF: SOLVEPNP_EPNP 方法。
    
    一般情况下，最小点数为 4。对于 REF: SOLVEPNP_P3P 和 REF: SOLVEPNP_AP3P 方法，需要精确使用 4 个点（前 3 个点用于估计 P3P 问题的全部解，最后一个点用于保留最小化重投影误差的最佳解）。
    
    对于 REF: SOLVEPNP_ITERATIVE 方法以及 useExtrinsicGuess=true，最小点数为 3（3 个点足以计算位姿，但最多可能有 4 个解）。初始解应接近全局解才能收敛。
    
    对于 REF: SOLVEPNP_IPPE，输入点数必须 >= 4，并且目标点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 是一个适用于标记位姿估计的特殊情况。输入点数必须为 4。目标点必须按以下顺序定义
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    返回值
    
    自动生成
  - initCameraMatrix2D
```
public static Mat initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints,
                                     java.util.List<MatOfPoint2f> imagePoints,
                                     Size imageSize,
                                     double aspectRatio)
```
    根据3D-2D点对应关系查找初始相机内参矩阵。
    
    参数
    
    objectPoints - 校准图案坐标空间中校准图案点的向量向量。在旧接口中，所有每视图向量都连接在一起。详情见 #calibrateCamera。
    
    imagePoints - 校准图案点投影的向量向量。在旧接口中，所有每视图向量都连接在一起。
    
    imageSize - 用于初始化主点的像素图像大小。
    
    aspectRatio - 如果为零或负数，则\(f_x\)和\(f_y\)将独立估计。否则，\(f_x = f_y \cdot \texttt{aspectRatio}\) 。该函数估计并返回相机校准过程的初始相机内参矩阵。目前，该函数仅支持平面校准图案，即每个物体点的z坐标为0的图案。
    
    返回值
    
    自动生成
  - initCameraMatrix2D
```
public static Mat initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints,
                                     java.util.List<MatOfPoint2f> imagePoints,
                                     Size imageSize)
```
    根据3D-2D点对应关系查找初始相机内参矩阵。
    
    参数
    
    objectPoints - 校准图案坐标空间中校准图案点的向量向量。在旧接口中，所有每视图向量都连接在一起。详情见 #calibrateCamera。
    
    imagePoints - 校准图案点投影的向量向量。在旧接口中，所有每视图向量都连接在一起。
    
    imageSize - 用于初始化主点的像素图像大小。否则，\(f_x = f_y \cdot \texttt{aspectRatio}\) 。该函数估计并返回相机校准过程的初始相机内参矩阵。目前，该函数仅支持平面校准图案，即每个物体点的z坐标为0的图案。
    
    返回值
    
    自动生成
  - findChessboardCorners
```
public static boolean findChessboardCorners(Mat image,
                                            Size patternSize,
                                            MatOfPoint2f corners,
                                            int flags)
```
    查找棋盘格内角点的位置。
    参数
    
    image - 源棋盘视图。它必须是8位灰度或彩色图像。
    
    patternSize - 棋盘每行和每列的内角点数 (patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows))。
    
    corners - 检测到的角点的输出数组。
    
    flags - 可以为零或以下值的组合的各种操作标志
    
    REF: CALIB_CB_ADAPTIVE_THRESH 使用自适应阈值将图像转换为黑白图像，而不是使用固定的阈值级别（根据平均图像亮度计算）。
    
    REF: CALIB_CB_NORMALIZE_IMAGE 使用 #equalizeHist 归一化图像伽马值，然后再应用固定或自适应阈值。
    
    REF: CALIB_CB_FILTER_QUADS 使用其他标准（如轮廓面积、周长、类似正方形的形状）来过滤掉在轮廓检索阶段提取的错误四边形。
    
    REF: CALIB_CB_FAST_CHECK 对图像运行快速检查以查找棋盘角点，如果未找到任何角点则缩短调用。如果未观察到棋盘，这可以大大加快在退化条件下的调用速度。
    
    REF: CALIB_CB_PLAIN 所有其他标志都被忽略。输入图像按原样使用。不会进行任何图像处理以改进棋盘查找。这会加快函数的执行速度，但如果图像未以适当的方式预先二值化，则可能导致无法识别棋盘。
    
    该函数尝试确定输入图像是否是棋盘图案的视图，并定位内部棋盘角点。如果找到所有角点并且它们按特定顺序排列（每行一行，每行从左到右），则该函数返回非零值。否则，如果函数未能找到所有角点或重新排序它们，则返回 0。例如，常规棋盘有 8 x 8 个方格和 7 x 7 个内角，即黑色方格相互接触的点。检测到的坐标是近似的，为了更准确地确定它们的位置，该函数调用 #cornerSubPix。如果返回的坐标不够准确，您也可以使用具有不同参数的函数 #cornerSubPix。检测和绘制棋盘角点的示例用法： : Size patternsize(8,6); //内部角点数 Mat gray = ....; //源图像 vector<Point2f> corners; //这将由检测到的角点填充 //CALIB_CB_FAST_CHECK 在不包含任何棋盘角点的图像上节省大量时间 //bool patternfound = findChessboardCorners(gray, patternsize, corners, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK); if(patternfound) cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1)); drawChessboardCorners(img, patternsize, Mat(corners), patternfound); 注意：该函数需要棋盘周围的白色空间（例如方块粗边框，越宽越好），以使检测在各种环境中更可靠。否则，如果没有边框并且背景较暗，则无法正确分割外部黑色方格，因此方格分组和排序算法失败。使用 gen_pattern.py (REF: tutorial_camera_calibration_pattern) 创建棋盘。
    
    返回值
    
    自动生成
  - findChessboardCorners
```
public static boolean findChessboardCorners(Mat image,
                                            Size patternSize,
                                            MatOfPoint2f corners)
```
    查找棋盘格内角点的位置。
    参数
    
    image - 源棋盘视图。它必须是8位灰度或彩色图像。
    
    patternSize - 棋盘每行和每列的内角点数 (patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows))。
    
    corners - 检测到的角点的输出数组。
    
    REF: CALIB_CB_ADAPTIVE_THRESH 使用自适应阈值将图像转换为黑白图像，而不是使用固定的阈值级别（根据平均图像亮度计算）。
    
    REF: CALIB_CB_NORMALIZE_IMAGE 使用 #equalizeHist 归一化图像伽马值，然后再应用固定或自适应阈值。
    
    REF: CALIB_CB_FILTER_QUADS 使用其他标准（如轮廓面积、周长、类似正方形的形状）来过滤掉在轮廓检索阶段提取的错误四边形。
    
    REF: CALIB_CB_FAST_CHECK 对图像运行快速检查以查找棋盘角点，如果未找到任何角点则缩短调用。如果未观察到棋盘，这可以大大加快在退化条件下的调用速度。
    
    REF: CALIB_CB_PLAIN 所有其他标志都被忽略。输入图像按原样使用。不会进行任何图像处理以改进棋盘查找。这会加快函数的执行速度，但如果图像未以适当的方式预先二值化，则可能导致无法识别棋盘。
    
    该函数尝试确定输入图像是否是棋盘图案的视图，并定位内部棋盘角点。如果找到所有角点并且它们按特定顺序排列（每行一行，每行从左到右），则该函数返回非零值。否则，如果函数未能找到所有角点或重新排序它们，则返回 0。例如，常规棋盘有 8 x 8 个方格和 7 x 7 个内角，即黑色方格相互接触的点。检测到的坐标是近似的，为了更准确地确定它们的位置，该函数调用 #cornerSubPix。如果返回的坐标不够准确，您也可以使用具有不同参数的函数 #cornerSubPix。检测和绘制棋盘角点的示例用法： : Size patternsize(8,6); //内部角点数 Mat gray = ....; //源图像 vector<Point2f> corners; //这将由检测到的角点填充 //CALIB_CB_FAST_CHECK 在不包含任何棋盘角点的图像上节省大量时间 //bool patternfound = findChessboardCorners(gray, patternsize, corners, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK); if(patternfound) cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1)); drawChessboardCorners(img, patternsize, Mat(corners), patternfound); 注意：该函数需要棋盘周围的白色空间（例如方块粗边框，越宽越好），以使检测在各种环境中更可靠。否则，如果没有边框并且背景较暗，则无法正确分割外部黑色方格，因此方格分组和排序算法失败。使用 gen_pattern.py (REF: tutorial_camera_calibration_pattern) 创建棋盘。
    
    返回值
    
    自动生成
  - checkChessboard
```
public static boolean checkChessboard(Mat img,
                                      Size size)
```
  - findChessboardCornersSBWithMeta
```
public static boolean findChessboardCornersSBWithMeta(Mat image,
                                                      Size patternSize,
                                                      Mat corners,
                                                      int flags,
                                                      Mat meta)
```
    使用基于扇区的方案查找棋盘格内角点的位置。
    参数
    
    image - 源棋盘视图。它必须是8位灰度或彩色图像。
    
    patternSize - 棋盘每行和每列的内角点数 (patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows))。
    
    corners - 检测到的角点的输出数组。
    
    flags - 可以为零或以下值的组合的各种操作标志
    
    REF: CALIB_CB_NORMALIZE_IMAGE 使用 equalizeHist 归一化图像伽马值，然后再进行检测。
    
    REF: CALIB_CB_EXHAUSTIVE 运行穷举搜索以提高检测率。
    
    REF: CALIB_CB_ACCURACY 上采样输入图像以提高由于混叠效应导致的亚像素精度。
    
    REF: CALIB_CB_LARGER 检测到的图案允许大于 patternSize（参见说明）。
    
    REF: CALIB_CB_MARKER 检测到的图案必须具有标记（参见说明）。如果需要准确的相机校准，则应使用此选项。
    
    meta - 检测到的角点的可选输出数组 (CV_8UC1 和大小 = cv::Size(columns,rows))。每个条目代表图案的一个角点，并且可以具有以下值之一
    
    0 = 未附加元数据
    
    1 = 黑色单元格的左上角
    
    2 = 白色单元格的左上角
    
    3 = 带有白色标记点的黑色单元格的左上角
    
    4 = 带有黑色标记点的白色单元格的左上角（如果有标记，则为图案原点，否则为第一个角点）
    
    该函数类似于 #findChessboardCorners，但使用局部Radon变换（通过盒式滤波器近似），对各种噪声更鲁棒，在大图像上速度更快，并且能够直接返回棋盘内角点的亚像素位置。该方法基于论文 CITE: duda2018 "Accurate Detection and Localization of Checkerboard Corners for Calibration"，该论文证明返回的亚像素位置比 cornerSubPix 返回的更准确，允许对要求苛刻的应用进行精确的相机标定。在这种情况下，如果给出标志 REF: CALIB_CB_LARGER 或 REF: CALIB_CB_MARKER，则结果可以从可选的元数组中恢复。这两个标志有助于使用超出相机视野的标定图案。这些超尺寸图案允许更精确的标定，因为可以使用尽可能靠近图像边界的角点。为了在所有图像中保持一致的坐标系，可以使用可选的标记（见下图）将棋盘的原点移动到黑圈所在的位置。注意：该函数需要一个宽度大致与整个棋盘周围棋盘格字段宽度相同的白色边框，以提高在各种环境下的检测效果。此外，由于使用了局部Radon变换，因此最好使用圆角作为位于棋盘外部的角点。下图显示了一个针对检测优化的棋盘示例。但是，也可以使用任何其他棋盘。使用 gen_pattern.py (REF: tutorial_camera_calibration_pattern) 创建棋盘。![Checkerboard](pics/checkerboard_radon.png)
    
    返回值
    
    自动生成
  - findChessboardCornersSB
```
public static boolean findChessboardCornersSB(Mat image,
                                              Size patternSize,
                                              Mat corners,
                                              int flags)
```
  - findChessboardCornersSB
```
public static boolean findChessboardCornersSB(Mat image,
                                              Size patternSize,
                                              Mat corners)
```
  - estimateChessboardSharpness
```
public static Scalar estimateChessboardSharpness(Mat image,
                                                 Size patternSize,
                                                 Mat corners,
                                                 float rise_distance,
                                                 boolean vertical,
                                                 Mat sharpness)
```
    估计检测到的棋盘的锐度。图像锐度和亮度都是精确相机标定的关键参数。为了访问这些参数以过滤掉有问题的标定图像，此方法通过从黑色到白色棋盘单元中心移动来计算边缘轮廓。基于此，计算从黑色过渡到白色的像素数。过渡区域的宽度很好地指示了棋盘成像的锐度，应低于 ~3.0 像素。
    
    参数
    
    image - 用于查找棋盘角点的灰度图像
    
    patternSize - 找到的棋盘图案的大小
    
    corners - 由 #findChessboardCornersSB 找到的角点
    
    rise_distance - 上升距离 0.8 表示最终信号强度的 10% ... 90%
    
    vertical - 默认情况下，计算水平线的边缘响应
    
    sharpness - 可选输出数组，包含计算出的边缘响应的锐度值（参见描述）。可选的锐度数组的类型为 CV_32FC1，每个计算出的轮廓有一行，包含以下五个条目：0 = 图像中底层边缘的 x 坐标 1 = 图像中底层边缘的 y 坐标 2 = 过渡区域的宽度（锐度） 3 = 黑色单元格中的信号强度（最小亮度） 4 = 白色单元格中的信号强度（最大亮度）
    
    返回值
    
    Scalar(平均锐度，平均最小亮度，平均最大亮度，0)
  - estimateChessboardSharpness
```
public static Scalar estimateChessboardSharpness(Mat image,
                                                 Size patternSize,
                                                 Mat corners,
                                                 float rise_distance,
                                                 boolean vertical)
```
    估计检测到的棋盘的锐度。图像锐度和亮度都是精确相机标定的关键参数。为了访问这些参数以过滤掉有问题的标定图像，此方法通过从黑色到白色棋盘单元中心移动来计算边缘轮廓。基于此，计算从黑色过渡到白色的像素数。过渡区域的宽度很好地指示了棋盘成像的锐度，应低于 ~3.0 像素。
    
    参数
    
    image - 用于查找棋盘角点的灰度图像
    
    patternSize - 找到的棋盘图案的大小
    
    corners - 由 #findChessboardCornersSB 找到的角点
    
    rise_distance - 上升距离 0.8 表示最终信号强度的 10% ... 90%
    
    vertical - 默认情况下，计算水平线的边缘响应。可选的锐度数组的类型为 CV_32FC1，每个计算出的轮廓有一行，包含以下五个条目：0 = 图像中底层边缘的 x 坐标 1 = 图像中底层边缘的 y 坐标 2 = 过渡区域的宽度（锐度） 3 = 黑色单元格中的信号强度（最小亮度） 4 = 白色单元格中的信号强度（最大亮度）
    
    返回值
    
    Scalar(平均锐度，平均最小亮度，平均最大亮度，0)
  - estimateChessboardSharpness
```
public static Scalar estimateChessboardSharpness(Mat image,
                                                 Size patternSize,
                                                 Mat corners,
                                                 float rise_distance)
```
    估计检测到的棋盘的锐度。图像锐度和亮度都是精确相机标定的关键参数。为了访问这些参数以过滤掉有问题的标定图像，此方法通过从黑色到白色棋盘单元中心移动来计算边缘轮廓。基于此，计算从黑色过渡到白色的像素数。过渡区域的宽度很好地指示了棋盘成像的锐度，应低于 ~3.0 像素。
    
    参数
    
    image - 用于查找棋盘角点的灰度图像
    
    patternSize - 找到的棋盘图案的大小
    
    corners - 由 #findChessboardCornersSB 找到的角点
    
    rise_distance - 上升距离 0.8 表示最终信号强度的 10% ... 90%。可选的锐度数组的类型为 CV_32FC1，每个计算出的轮廓有一行，包含以下五个条目：0 = 图像中底层边缘的 x 坐标 1 = 图像中底层边缘的 y 坐标 2 = 过渡区域的宽度（锐度） 3 = 黑色单元格中的信号强度（最小亮度） 4 = 白色单元格中的信号强度（最大亮度）
    
    返回值
    
    Scalar(平均锐度，平均最小亮度，平均最大亮度，0)
  - estimateChessboardSharpness
```
public static Scalar estimateChessboardSharpness(Mat image,
                                                 Size patternSize,
                                                 Mat corners)
```
    估计检测到的棋盘的锐度。图像锐度和亮度都是精确相机标定的关键参数。为了访问这些参数以过滤掉有问题的标定图像，此方法通过从黑色到白色棋盘单元中心移动来计算边缘轮廓。基于此，计算从黑色过渡到白色的像素数。过渡区域的宽度很好地指示了棋盘成像的锐度，应低于 ~3.0 像素。
    
    参数
    
    image - 用于查找棋盘角点的灰度图像
    
    patternSize - 找到的棋盘图案的大小
    
    corners - 由 #findChessboardCornersSB 找到的角点。可选的锐度数组的类型为 CV_32FC1，每个计算出的轮廓有一行，包含以下五个条目：0 = 图像中底层边缘的 x 坐标 1 = 图像中底层边缘的 y 坐标 2 = 过渡区域的宽度（锐度） 3 = 黑色单元格中的信号强度（最小亮度） 4 = 白色单元格中的信号强度（最大亮度）
    
    返回值
    
    Scalar(平均锐度，平均最小亮度，平均最大亮度，0)
  - find4QuadCornerSubpix
```
public static boolean find4QuadCornerSubpix(Mat img,
                                            Mat corners,
                                            Size region_size)
```
  - drawChessboardCorners
```
public static void drawChessboardCorners(Mat image,
                                         Size patternSize,
                                         MatOfPoint2f corners,
                                         boolean patternWasFound)
```
    绘制检测到的棋盘格角点。
    
    参数
    
    image - 目标图像。它必须是 8 位彩色图像。
    
    patternSize - 棋盘每行和每列的内角点数 (patternSize = cv::Size(points_per_row,points_per_column))。
    
    corners - 检测到的角点数组，#findChessboardCorners 的输出。
    
    patternWasFound - 参数指示是否找到完整的棋盘。应在此处传递 #findChessboardCorners 的返回值。如果未找到棋盘，则该函数绘制检测到的单个棋盘角点为红色圆圈；如果找到棋盘，则绘制为彩色角点并用线连接。
  - drawFrameAxes
```
public static void drawFrameAxes(Mat image,
                                 Mat cameraMatrix,
                                 Mat distCoeffs,
                                 Mat rvec,
                                 Mat tvec,
                                 float length,
                                 int thickness)
```
    绘制姿态估计的世界/物体坐标系的轴。参见：solvePnP
    
    参数
    
    image - 输入/输出图像。它必须有 1 个或 3 个通道。通道数不会改变。
    
    cameraMatrix - 输入的 3x3 浮点型相机内参矩阵。\(\cameramatrix{A}\)
    
    distCoeffs - 输入的畸变系数向量 \(\distcoeffs\)。如果向量为空，则假设为零畸变系数。
    
    rvec - 旋转向量（参见 REF: Rodrigues），与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 平移向量。
    
    length - 绘制轴的长度，单位与 tvec 相同（通常为米）。
    
    thickness - 绘制轴的线粗细。此函数绘制世界/物体坐标系相对于相机坐标系的轴。OX 以红色绘制，OY 以绿色绘制，OZ 以蓝色绘制。
  - drawFrameAxes
```
public static void drawFrameAxes(Mat image,
                                 Mat cameraMatrix,
                                 Mat distCoeffs,
                                 Mat rvec,
                                 Mat tvec,
                                 float length)
```
    绘制姿态估计的世界/物体坐标系的轴。参见：solvePnP
    
    参数
    
    image - 输入/输出图像。它必须有 1 个或 3 个通道。通道数不会改变。
    
    cameraMatrix - 输入的 3x3 浮点型相机内参矩阵。\(\cameramatrix{A}\)
    
    distCoeffs - 输入的畸变系数向量 \(\distcoeffs\)。如果向量为空，则假设为零畸变系数。
    
    rvec - 旋转向量（参见 REF: Rodrigues），与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 平移向量。
    
    length - 绘制轴的长度，单位与 tvec 相同（通常为米）。此函数绘制世界/物体坐标系相对于相机坐标系的轴。OX 以红色绘制，OY 以绿色绘制，OZ 以蓝色绘制。
  - findCirclesGrid
```
public static boolean findCirclesGrid(Mat image,
                                      Size patternSize,
                                      Mat centers,
                                      int flags)
```
  - findCirclesGrid
```
public static boolean findCirclesGrid(Mat image,
                                      Size patternSize,
                                      Mat centers)
```
  - calibrateCameraExtended
```
public static double calibrateCameraExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors,
                                             int flags,
                                             TermCriteria criteria)
```
    根据校准图案的多个视图查找相机内参和外参。
    参数
    
    objectPoints - 在新接口中，这是一个向量，包含标定图案在标定图案坐标系中的点 (例如 std::vector<std::vector<cv::Vec3f>>)。外层向量包含的元素个数与图案视图的个数相同。如果每个视图都显示相同的标定图案且完全可见，则所有向量都相同。但是，也可以使用部分遮挡的图案，甚至在不同视图中使用不同的图案。在这种情况下，向量将不同。如果使用的标定图案是平面标靶，则尽管点是3D点，但它们都位于标定图案的XY坐标平面内（因此Z坐标为0）。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imagePoints - 在新接口中，这是一个向量，包含标定图案点的投影 (例如 std::vector<std::vector<cv::Vec2f>>)。imagePoints.size() 和 objectPoints.size() 必须相等，对于每个 i，imagePoints[i].size() 和 objectPoints[i].size() 也必须相等。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    cameraMatrix - 输入/输出 3x3 浮点型相机内参矩阵 \(\cameramatrix{A}\) 。如果指定了 REF: CALIB_USE_INTRINSIC_GUESS 和/或 REF: CALIB_FIX_ASPECT_RATIO，REF: CALIB_FIX_PRINCIPAL_POINT 或 REF: CALIB_FIX_FOCAL_LENGTH，则在调用函数之前必须初始化 fx、fy、cx、cy 中的一些或全部。
    
    distCoeffs - 输入/输出畸变系数向量 \(\distcoeffs\)。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues )，每个图案视图估计一个 (例如 std::vector<cv::Mat>>)。也就是说，每个第 i 个旋转向量与其对应的第 i 个平移向量（参见下一个输出参数说明）一起将标定图案从目标坐标空间（在其中指定目标点）转换到相机坐标空间。更技术性的说法是，第 i 个旋转和平移向量的元组执行从目标坐标空间到相机坐标空间的基变换。由于其对偶性，此元组等效于标定图案相对于相机坐标空间的位置。
    
    tvecs - 输出每个图案视图估计的平移向量向量，参见上面的参数说明。
    
    stdDeviationsIntrinsics - 输出估计的内参标准差向量。偏差值的顺序：\((f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\) 如果某个参数未被估计，则其偏差等于零。
    
    stdDeviationsExtrinsics - 输出估计的外参标准差向量。偏差值的顺序：\((R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})\) 其中 M 是图案视图的数量。\(R_i, T_i\) 是连接起来的 1x3 向量。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心 (使用 imageSize)，焦距以最小二乘法计算。请注意，如果已知内参，则无需仅为了估计外参而使用此函数。请改用 REF: solvePnP。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在全局优化期间，主点不会改变。它保持在中心或在设置 REF: CALIB_USE_INTRINSIC_GUESS 时指定的不同位置。
    
    REF: CALIB_FIX_ASPECT_RATIO 函数仅将 fy 视为自由参数。fx/fy 的比率与输入 cameraMatrix 中的比率相同。当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时，fx 和 fy 的实际输入值将被忽略，仅计算并使用它们的比率。
    
    REF: CALIB_ZERO_TANGENT_DIST 切向畸变系数 \((p_1, p_2)\) 被设置为零并保持为零。
    
    REF: CALIB_FIX_FOCAL_LENGTH 如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则在全局优化期间焦距不会改变。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化期间，相应的径向畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用有理模型并返回 8 个或更多系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用薄棱镜模型并返回 12 个或更多系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用倾斜传感器模型并返回 14 个系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    criteria - 迭代优化算法的终止条件。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000 和 CITE: BouguetMCT 。必须指定 3D 物体点的坐标及其在每个视图中的相应 2D 投影。这可以通过使用具有已知几何形状和易于检测的特征点的物体来实现。这样的物体称为标定标靶或标定图案，OpenCV 内置支持棋盘格作为标定标靶 (参见 REF: findChessboardCorners)。目前，仅针对平面标定图案 (其中物体点的 Z 坐标必须全部为零) 实现了内参的初始化 (当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时)。只要提供初始 cameraMatrix，也可以使用 3D 标定标靶。该算法执行以下步骤
    
    计算初始内参 (仅适用于平面标定图案) 或从输入参数中读取它们。除非指定了一些 CALIB_FIX_K?，否则畸变系数最初都设置为零。
    
    假设内参已知，估计初始相机位姿。这使用 REF: solvePnP 完成。
    
    运行全局 Levenberg-Marquardt 优化算法以最小化重投影误差，即观测特征点 imagePoints 与投影点 (使用相机参数和位姿的当前估计值投影) objectPoints 之间平方距离的总和。详情见 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N×N）网格和 REF: findChessboardCorners 进行标定，并且 REF: calibrateCamera 返回错误值（零畸变系数，\(c_x\) 和 \(c_y\) 远偏离图像中心，和/或 \(f_x\) 和 \(f_y\) 之间的差异很大（比例为 10:1 或更大）），那么您可能在 REF: findChessboardCorners 中使用了 patternSize=cvSize(rows,cols) 而不是 patternSize=cvSize(cols,rows)。注意：如果提供了不支持的参数组合或系统约束不足，则该函数可能会抛出异常。参见：calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCameraExtended
```
public static double calibrateCameraExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors,
                                             int flags)
```
    根据校准图案的多个视图查找相机内参和外参。
    参数
    
    objectPoints - 在新接口中，这是一个向量，包含标定图案在标定图案坐标系中的点 (例如 std::vector<std::vector<cv::Vec3f>>)。外层向量包含的元素个数与图案视图的个数相同。如果每个视图都显示相同的标定图案且完全可见，则所有向量都相同。但是，也可以使用部分遮挡的图案，甚至在不同视图中使用不同的图案。在这种情况下，向量将不同。如果使用的标定图案是平面标靶，则尽管点是3D点，但它们都位于标定图案的XY坐标平面内（因此Z坐标为0）。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imagePoints - 在新接口中，这是一个向量，包含标定图案点的投影 (例如 std::vector<std::vector<cv::Vec2f>>)。imagePoints.size() 和 objectPoints.size() 必须相等，对于每个 i，imagePoints[i].size() 和 objectPoints[i].size() 也必须相等。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    cameraMatrix - 输入/输出 3x3 浮点型相机内参矩阵 \(\cameramatrix{A}\) 。如果指定了 REF: CALIB_USE_INTRINSIC_GUESS 和/或 REF: CALIB_FIX_ASPECT_RATIO，REF: CALIB_FIX_PRINCIPAL_POINT 或 REF: CALIB_FIX_FOCAL_LENGTH，则在调用函数之前必须初始化 fx、fy、cx、cy 中的一些或全部。
    
    distCoeffs - 输入/输出畸变系数向量 \(\distcoeffs\)。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues )，每个图案视图估计一个 (例如 std::vector<cv::Mat>>)。也就是说，每个第 i 个旋转向量与其对应的第 i 个平移向量（参见下一个输出参数说明）一起将标定图案从目标坐标空间（在其中指定目标点）转换到相机坐标空间。更技术性的说法是，第 i 个旋转和平移向量的元组执行从目标坐标空间到相机坐标空间的基变换。由于其对偶性，此元组等效于标定图案相对于相机坐标空间的位置。
    
    tvecs - 输出每个图案视图估计的平移向量向量，参见上面的参数说明。
    
    stdDeviationsIntrinsics - 输出估计的内参标准差向量。偏差值的顺序：\((f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\) 如果某个参数未被估计，则其偏差等于零。
    
    stdDeviationsExtrinsics - 输出估计的外参标准差向量。偏差值的顺序：\((R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})\) 其中 M 是图案视图的数量。\(R_i, T_i\) 是连接起来的 1x3 向量。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心 (使用 imageSize)，焦距以最小二乘法计算。请注意，如果已知内参，则无需仅为了估计外参而使用此函数。请改用 REF: solvePnP。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在全局优化期间，主点不会改变。它保持在中心或在设置 REF: CALIB_USE_INTRINSIC_GUESS 时指定的不同位置。
    
    REF: CALIB_FIX_ASPECT_RATIO 函数仅将 fy 视为自由参数。fx/fy 的比率与输入 cameraMatrix 中的比率相同。当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时，fx 和 fy 的实际输入值将被忽略，仅计算并使用它们的比率。
    
    REF: CALIB_ZERO_TANGENT_DIST 切向畸变系数 \((p_1, p_2)\) 被设置为零并保持为零。
    
    REF: CALIB_FIX_FOCAL_LENGTH 如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则在全局优化期间焦距不会改变。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化期间，相应的径向畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用有理模型并返回 8 个或更多系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用薄棱镜模型并返回 12 个或更多系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用倾斜传感器模型并返回 14 个系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000 和 CITE: BouguetMCT 。必须指定 3D 物体点的坐标及其在每个视图中的相应 2D 投影。这可以通过使用具有已知几何形状和易于检测的特征点的物体来实现。这样的物体称为标定标靶或标定图案，OpenCV 内置支持棋盘格作为标定标靶 (参见 REF: findChessboardCorners)。目前，仅针对平面标定图案 (其中物体点的 Z 坐标必须全部为零) 实现了内参的初始化 (当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时)。只要提供初始 cameraMatrix，也可以使用 3D 标定标靶。该算法执行以下步骤
    
    计算初始内参 (仅适用于平面标定图案) 或从输入参数中读取它们。除非指定了一些 CALIB_FIX_K?，否则畸变系数最初都设置为零。
    
    假设内参已知，估计初始相机位姿。这使用 REF: solvePnP 完成。
    
    运行全局 Levenberg-Marquardt 优化算法以最小化重投影误差，即观测特征点 imagePoints 与投影点 (使用相机参数和位姿的当前估计值投影) objectPoints 之间平方距离的总和。详情见 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N×N）网格和 REF: findChessboardCorners 进行标定，并且 REF: calibrateCamera 返回错误值（零畸变系数，\(c_x\) 和 \(c_y\) 远偏离图像中心，和/或 \(f_x\) 和 \(f_y\) 之间的差异很大（比例为 10:1 或更大）），那么您可能在 REF: findChessboardCorners 中使用了 patternSize=cvSize(rows,cols) 而不是 patternSize=cvSize(cols,rows)。注意：如果提供了不支持的参数组合或系统约束不足，则该函数可能会抛出异常。参见：calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCameraExtended
```
public static double calibrateCameraExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors)
```
    根据校准图案的多个视图查找相机内参和外参。
    参数
    
    objectPoints - 在新接口中，这是一个向量，包含标定图案在标定图案坐标系中的点 (例如 std::vector<std::vector<cv::Vec3f>>)。外层向量包含的元素个数与图案视图的个数相同。如果每个视图都显示相同的标定图案且完全可见，则所有向量都相同。但是，也可以使用部分遮挡的图案，甚至在不同视图中使用不同的图案。在这种情况下，向量将不同。如果使用的标定图案是平面标靶，则尽管点是3D点，但它们都位于标定图案的XY坐标平面内（因此Z坐标为0）。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imagePoints - 在新接口中，这是一个向量，包含标定图案点的投影 (例如 std::vector<std::vector<cv::Vec2f>>)。imagePoints.size() 和 objectPoints.size() 必须相等，对于每个 i，imagePoints[i].size() 和 objectPoints[i].size() 也必须相等。在旧接口中，来自不同视图的所有目标点向量被连接在一起。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    cameraMatrix - 输入/输出 3x3 浮点型相机内参矩阵 \(\cameramatrix{A}\) 。如果指定了 REF: CALIB_USE_INTRINSIC_GUESS 和/或 REF: CALIB_FIX_ASPECT_RATIO，REF: CALIB_FIX_PRINCIPAL_POINT 或 REF: CALIB_FIX_FOCAL_LENGTH，则在调用函数之前必须初始化 fx、fy、cx、cy 中的一些或全部。
    
    distCoeffs - 输入/输出畸变系数向量 \(\distcoeffs\)。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues )，每个图案视图估计一个 (例如 std::vector<cv::Mat>>)。也就是说，每个第 i 个旋转向量与其对应的第 i 个平移向量（参见下一个输出参数说明）一起将标定图案从目标坐标空间（在其中指定目标点）转换到相机坐标空间。更技术性的说法是，第 i 个旋转和平移向量的元组执行从目标坐标空间到相机坐标空间的基变换。由于其对偶性，此元组等效于标定图案相对于相机坐标空间的位置。
    
    tvecs - 输出每个图案视图估计的平移向量向量，参见上面的参数说明。
    
    stdDeviationsIntrinsics - 输出估计的内参标准差向量。偏差值的顺序：\((f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\) 如果某个参数未被估计，则其偏差等于零。
    
    stdDeviationsExtrinsics - 输出估计的外参标准差向量。偏差值的顺序：\((R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})\) 其中 M 是图案视图的数量。\(R_i, T_i\) 是连接起来的 1x3 向量。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心 (使用 imageSize)，焦距以最小二乘法计算。请注意，如果已知内参，则无需仅为了估计外参而使用此函数。请改用 REF: solvePnP。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在全局优化期间，主点不会改变。它保持在中心或在设置 REF: CALIB_USE_INTRINSIC_GUESS 时指定的不同位置。
    
    REF: CALIB_FIX_ASPECT_RATIO 函数仅将 fy 视为自由参数。fx/fy 的比率与输入 cameraMatrix 中的比率相同。当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时，fx 和 fy 的实际输入值将被忽略，仅计算并使用它们的比率。
    
    REF: CALIB_ZERO_TANGENT_DIST 切向畸变系数 \((p_1, p_2)\) 被设置为零并保持为零。
    
    REF: CALIB_FIX_FOCAL_LENGTH 如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则在全局优化期间焦距不会改变。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化期间，相应的径向畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用有理模型并返回 8 个或更多系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用薄棱镜模型并返回 12 个或更多系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使校准函数使用倾斜传感器模型并返回 14 个系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000 和 CITE: BouguetMCT 。必须指定 3D 物体点的坐标及其在每个视图中的相应 2D 投影。这可以通过使用具有已知几何形状和易于检测的特征点的物体来实现。这样的物体称为标定标靶或标定图案，OpenCV 内置支持棋盘格作为标定标靶 (参见 REF: findChessboardCorners)。目前，仅针对平面标定图案 (其中物体点的 Z 坐标必须全部为零) 实现了内参的初始化 (当未设置 REF: CALIB_USE_INTRINSIC_GUESS 时)。只要提供初始 cameraMatrix，也可以使用 3D 标定标靶。该算法执行以下步骤
    
    计算初始内参 (仅适用于平面标定图案) 或从输入参数中读取它们。除非指定了一些 CALIB_FIX_K?，否则畸变系数最初都设置为零。
    
    假设内参已知，估计初始相机位姿。这使用 REF: solvePnP 完成。
    
    运行全局 Levenberg-Marquardt 优化算法以最小化重投影误差，即观测特征点 imagePoints 与投影点 (使用相机参数和位姿的当前估计值投影) objectPoints 之间平方距离的总和。详情见 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N×N）网格和 REF: findChessboardCorners 进行标定，并且 REF: calibrateCamera 返回错误值（零畸变系数，\(c_x\) 和 \(c_y\) 远偏离图像中心，和/或 \(f_x\) 和 \(f_y\) 之间的差异很大（比例为 10:1 或更大）），那么您可能在 REF: findChessboardCorners 中使用了 patternSize=cvSize(rows,cols) 而不是 patternSize=cvSize(cols,rows)。注意：如果提供了不支持的参数组合或系统约束不足，则该函数可能会抛出异常。参见：calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCamera
```
public static double calibrateCamera(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     java.util.List<Mat> rvecs,
                                     java.util.List<Mat> tvecs,
                                     int flags,
                                     TermCriteria criteria)
```
  - calibrateCamera
```
public static double calibrateCamera(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     java.util.List<Mat> rvecs,
                                     java.util.List<Mat> tvecs,
                                     int flags)
```
  - calibrateCamera
```
public static double calibrateCamera(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     java.util.List<Mat> rvecs,
                                     java.util.List<Mat> tvecs)
```
  - calibrateCameraROExtended
```
public static double calibrateCameraROExtended(java.util.List<Mat> objectPoints,
                                               java.util.List<Mat> imagePoints,
                                               Size imageSize,
                                               int iFixedPoint,
                                               Mat cameraMatrix,
                                               Mat distCoeffs,
                                               java.util.List<Mat> rvecs,
                                               java.util.List<Mat> tvecs,
                                               Mat newObjPoints,
                                               Mat stdDeviationsIntrinsics,
                                               Mat stdDeviationsExtrinsics,
                                               Mat stdDeviationsObjPoints,
                                               Mat perViewErrors,
                                               int flags,
                                               TermCriteria criteria)
```
    根据多个视角的标定图案查找相机内参和外参。此函数是 #calibrateCamera 的扩展，采用文献 CITE: strobl2011iccv 中提出的释放物体的方法。在许多常见情况下，对于不精确、未测量、大致平面的目标（标定板），此方法可以显著提高估计相机参数的精度。此函数同时支持物体释放方法和标准方法。使用参数 iFixedPoint 选择方法。在内部实现中，#calibrateCamera 是此函数的包装器。
    
    参数
    
    objectPoints - 标定图案坐标空间中标定图案点的向量集合。详情见 #calibrateCamera。如果使用物体释放方法，则每个视角必须使用相同的标定板并且必须完全可见，并且所有 objectPoints[i] 都必须相同，并且所有点都应大致接近平面。标定目标必须是刚性的，或者如果相机（而不是标定目标）移动以抓取图像，则至少是静态的。
    
    imagePoints - 标定图案点的投影的向量集合。详情见 #calibrateCamera。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    iFixedPoint - objectPoints[0] 中要固定的 3D 物体点的索引。它也充当标定方法选择的开关。如果使用物体释放方法，则将参数传递到 [1, objectPoints[0].size()-2] 范围内，否则此范围之外的值将选择标准标定方法。通常建议在使用物体释放方法时，将标定板网格的右上角点固定。根据 \cite strobl2011iccv，另外两个点也被固定。在此实现中，使用 objectPoints[0].front 和 objectPoints[0].back.z。使用物体释放方法时，只有当这三个固定点的坐标足够精确时，才能获得精确的 rvecs、tvecs 和 newObjPoints。
    
    cameraMatrix - 输出 3x3 浮点相机矩阵。详情见 #calibrateCamera。
    
    distCoeffs - 输出畸变系数向量。详情见 #calibrateCamera。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量。详情见 #calibrateCamera。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    newObjPoints - 更新后的标定图案点输出向量。坐标可能会根据三个固定点进行缩放。只有当上述三个固定点足够精确时，返回的坐标才是精确的。如果不需要，可以传入 noArray()。此参数在标准标定方法中被忽略。
    
    stdDeviationsIntrinsics - 输出内参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsExtrinsics - 输出外参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsObjPoints - 输出标定图案点精修坐标估计的标准差向量。它与 objectPoints[0] 向量具有相同的大小和顺序。此参数在标准标定方法中被忽略。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 可能为零或某些预定义值的组合的不同标志。详情见 #calibrateCamera。如果使用物体释放方法，则标定时间可能会长得多。CALIB_USE_QR 或 CALIB_USE_LU 可用于更快地标定，但在某些罕见情况下可能会精度较低且稳定性较差。
    
    criteria - 迭代优化算法的终止条件。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000、CITE: BouguetMCT 和 CITE: strobl2011iccv。有关其他详细说明，请参见 #calibrateCamera。参见：calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCameraROExtended
```
public static double calibrateCameraROExtended(java.util.List<Mat> objectPoints,
                                               java.util.List<Mat> imagePoints,
                                               Size imageSize,
                                               int iFixedPoint,
                                               Mat cameraMatrix,
                                               Mat distCoeffs,
                                               java.util.List<Mat> rvecs,
                                               java.util.List<Mat> tvecs,
                                               Mat newObjPoints,
                                               Mat stdDeviationsIntrinsics,
                                               Mat stdDeviationsExtrinsics,
                                               Mat stdDeviationsObjPoints,
                                               Mat perViewErrors,
                                               int flags)
```
    根据多个视角的标定图案查找相机内参和外参。此函数是 #calibrateCamera 的扩展，采用文献 CITE: strobl2011iccv 中提出的释放物体的方法。在许多常见情况下，对于不精确、未测量、大致平面的目标（标定板），此方法可以显著提高估计相机参数的精度。此函数同时支持物体释放方法和标准方法。使用参数 iFixedPoint 选择方法。在内部实现中，#calibrateCamera 是此函数的包装器。
    
    参数
    
    objectPoints - 标定图案坐标空间中标定图案点的向量集合。详情见 #calibrateCamera。如果使用物体释放方法，则每个视角必须使用相同的标定板并且必须完全可见，并且所有 objectPoints[i] 都必须相同，并且所有点都应大致接近平面。标定目标必须是刚性的，或者如果相机（而不是标定目标）移动以抓取图像，则至少是静态的。
    
    imagePoints - 标定图案点的投影的向量集合。详情见 #calibrateCamera。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    iFixedPoint - objectPoints[0] 中要固定的 3D 物体点的索引。它也充当标定方法选择的开关。如果使用物体释放方法，则将参数传递到 [1, objectPoints[0].size()-2] 范围内，否则此范围之外的值将选择标准标定方法。通常建议在使用物体释放方法时，将标定板网格的右上角点固定。根据 \cite strobl2011iccv，另外两个点也被固定。在此实现中，使用 objectPoints[0].front 和 objectPoints[0].back.z。使用物体释放方法时，只有当这三个固定点的坐标足够精确时，才能获得精确的 rvecs、tvecs 和 newObjPoints。
    
    cameraMatrix - 输出 3x3 浮点相机矩阵。详情见 #calibrateCamera。
    
    distCoeffs - 输出畸变系数向量。详情见 #calibrateCamera。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量。详情见 #calibrateCamera。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    newObjPoints - 更新后的标定图案点输出向量。坐标可能会根据三个固定点进行缩放。只有当上述三个固定点足够精确时，返回的坐标才是精确的。如果不需要，可以传入 noArray()。此参数在标准标定方法中被忽略。
    
    stdDeviationsIntrinsics - 输出内参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsExtrinsics - 输出外参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsObjPoints - 输出标定图案点精修坐标估计的标准差向量。它与 objectPoints[0] 向量具有相同的大小和顺序。此参数在标准标定方法中被忽略。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 可能为零或某些预定义值的组合的不同标志。详情见 #calibrateCamera。如果使用物体释放方法，则标定时间可能会长得多。CALIB_USE_QR 或 CALIB_USE_LU 可用于更快地标定，但在某些罕见情况下可能会精度较低且稳定性较差。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000、CITE: BouguetMCT 和 CITE: strobl2011iccv。有关其他详细说明，请参见 #calibrateCamera。参见：calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCameraROExtended
```
public static double calibrateCameraROExtended(java.util.List<Mat> objectPoints,
                                               java.util.List<Mat> imagePoints,
                                               Size imageSize,
                                               int iFixedPoint,
                                               Mat cameraMatrix,
                                               Mat distCoeffs,
                                               java.util.List<Mat> rvecs,
                                               java.util.List<Mat> tvecs,
                                               Mat newObjPoints,
                                               Mat stdDeviationsIntrinsics,
                                               Mat stdDeviationsExtrinsics,
                                               Mat stdDeviationsObjPoints,
                                               Mat perViewErrors)
```
    根据多个视角的标定图案查找相机内参和外参。此函数是 #calibrateCamera 的扩展，采用文献 CITE: strobl2011iccv 中提出的释放物体的方法。在许多常见情况下，对于不精确、未测量、大致平面的目标（标定板），此方法可以显著提高估计相机参数的精度。此函数同时支持物体释放方法和标准方法。使用参数 iFixedPoint 选择方法。在内部实现中，#calibrateCamera 是此函数的包装器。
    
    参数
    
    objectPoints - 标定图案坐标空间中标定图案点的向量集合。详情见 #calibrateCamera。如果使用物体释放方法，则每个视角必须使用相同的标定板并且必须完全可见，并且所有 objectPoints[i] 都必须相同，并且所有点都应大致接近平面。标定目标必须是刚性的，或者如果相机（而不是标定目标）移动以抓取图像，则至少是静态的。
    
    imagePoints - 标定图案点的投影的向量集合。详情见 #calibrateCamera。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    iFixedPoint - objectPoints[0] 中要固定的 3D 物体点的索引。它也充当标定方法选择的开关。如果使用物体释放方法，则将参数传递到 [1, objectPoints[0].size()-2] 范围内，否则此范围之外的值将选择标准标定方法。通常建议在使用物体释放方法时，将标定板网格的右上角点固定。根据 \cite strobl2011iccv，另外两个点也被固定。在此实现中，使用 objectPoints[0].front 和 objectPoints[0].back.z。使用物体释放方法时，只有当这三个固定点的坐标足够精确时，才能获得精确的 rvecs、tvecs 和 newObjPoints。
    
    cameraMatrix - 输出 3x3 浮点相机矩阵。详情见 #calibrateCamera。
    
    distCoeffs - 输出畸变系数向量。详情见 #calibrateCamera。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量。详情见 #calibrateCamera。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    newObjPoints - 更新后的标定图案点输出向量。坐标可能会根据三个固定点进行缩放。只有当上述三个固定点足够精确时，返回的坐标才是精确的。如果不需要，可以传入 noArray()。此参数在标准标定方法中被忽略。
    
    stdDeviationsIntrinsics - 输出内参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsExtrinsics - 输出外参估计的标准差向量。详情见 #calibrateCamera。
    
    stdDeviationsObjPoints - 输出标定图案点精修坐标估计的标准差向量。它与 objectPoints[0] 向量具有相同的大小和顺序。此参数在标准标定方法中被忽略。
    
    perViewErrors - 为每个图案视图估计的 RMS 重投影误差输出向量。#calibrateCamera 详情。如果使用物体释放方法，则标定时间可能会长得多。CALIB_USE_QR 或 CALIB_USE_LU 可用于更快地标定，但在某些罕见情况下可能会精度较低且稳定性较差。
    
    返回值
    
    整体 RMS 重投影误差。该函数估计每个视图的相机内参和外参。该算法基于 CITE: Zhang2000、CITE: BouguetMCT 和 CITE: strobl2011iccv。有关其他详细说明，请参见 #calibrateCamera。参见：calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
  - calibrateCameraRO
```
public static double calibrateCameraRO(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size imageSize,
                                       int iFixedPoint,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs,
                                       Mat newObjPoints,
                                       int flags,
                                       TermCriteria criteria)
```
  - calibrateCameraRO
```
public static double calibrateCameraRO(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size imageSize,
                                       int iFixedPoint,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs,
                                       Mat newObjPoints,
                                       int flags)
```
  - calibrateCameraRO
```
public static double calibrateCameraRO(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size imageSize,
                                       int iFixedPoint,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs,
                                       Mat newObjPoints)
```
  - calibrationMatrixValues
```
public static void calibrationMatrixValues(Mat cameraMatrix,
                                           Size imageSize,
                                           double apertureWidth,
                                           double apertureHeight,
                                           double[] fovx,
                                           double[] fovy,
                                           double[] focalLength,
                                           Point principalPoint,
                                           double[] aspectRatio)
```
    根据相机内参矩阵计算有用的相机特性。
    
    参数
    
    cameraMatrix - 输入相机内参矩阵，可由 #calibrateCamera 或 #stereoCalibrate 估计。
    
    imageSize - 输入图像大小（以像素为单位）。
    
    apertureWidth - 传感器的物理宽度（以毫米为单位）。
    
    apertureHeight - 传感器的物理高度（以毫米为单位）。
    
    fovx - 水平传感器轴上以度为单位的输出视场。
    
    fovy - 垂直传感器轴上以度为单位的输出视场。
    
    focalLength - 镜头焦距（以毫米为单位）。
    
    principalPoint - 主点（以毫米为单位）。
    
    aspectRatio - \(f_y/f_x\) 该函数根据先前估计的相机矩阵计算各种有用的相机特性。注意：请记住，单位“毫米”代表棋盘格间距所选择的任何测量单位（因此它可以是任何值）。
  - stereoCalibrateExtended
```
public static double stereoCalibrateExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat cameraMatrix1,
                                             Mat distCoeffs1,
                                             Mat cameraMatrix2,
                                             Mat distCoeffs2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             Mat E,
                                             Mat F,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat perViewErrors,
                                             int flags,
                                             TermCriteria criteria)
```
    标定立体相机设置。此函数查找两个相机的内参以及两个相机之间的外参。
    参数
    
    objectPoints - 标定图案点的向量集合。与 REF: calibrateCamera 中的结构相同。对于每个图案视图，两个相机都需要看到相同的物体点。因此，objectPoints.size()、imagePoints1.size() 和 imagePoints2.size() 需要相等，并且对于每个 i，objectPoints[i].size()、imagePoints1[i].size() 和 imagePoints2[i].size() 也需要相等。
    
    imagePoints1 - 第一个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    imagePoints2 - 第二个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    cameraMatrix1 - 第一个相机的输入/输出相机内参矩阵，与 REF: calibrateCamera 中相同。此外，对于立体情况，可以使用其他标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个相机的输入/输出第二个相机内参矩阵。参见 cameraMatrix1 的描述。
    
    distCoeffs2 - 第二个相机的输入/输出镜头畸变系数。参见 distCoeffs1 的描述。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    R - 输出旋转矩阵。该矩阵与平移向量 T 一起，将第一个相机坐标系中的点转换到第二个相机坐标系中的点。更专业的术语来说，R 和 T 的组合实现了从第一个相机坐标系到第二个相机坐标系的基变换。由于其对偶性，该组合等效于第一个相机相对于第二个相机坐标系的位置。
    
    T - 输出平移向量，见上文描述。
    
    E - 输出本质矩阵。
    
    F - 输出基础矩阵。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: CALIB_FIX_INTRINSIC 固定 cameraMatrix? 和 distCoeffs?，以便仅估计 R、T、E 和 F 矩阵。
    
    REF: CALIB_USE_INTRINSIC_GUESS 根据指定的标志优化部分或全部内参。初始值由用户提供。
    
    REF: CALIB_USE_EXTRINSIC_GUESS R 和 T 包含有效的初始值，这些值将被进一步优化。否则，R 和 T 将初始化为图案视图的中值（每个维度单独计算）。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在优化过程中固定主点。
    
    REF: CALIB_FIX_FOCAL_LENGTH 固定 \(f^{(j)}_x\) 和 \(f^{(j)}_y\) 。
    
    REF: CALIB_FIX_ASPECT_RATIO 优化 \(f^{(j)}_y\) 。固定比率 \(f^{(j)}_x/f^{(j)}_y\) 。
    
    REF: CALIB_SAME_FOCAL_LENGTH 强制 \(f^{(0)}_x=f^{(1)}_x\) 和 \(f^{(0)}_y=f^{(1)}_y\) 。
    
    REF: CALIB_ZERO_TANGENT_DIST 将每个相机的切向畸变系数设置为零并固定。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化过程中不更改相应的径向畸变系数。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用有理模型并返回 8 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用薄棱镜模型并返回 12 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用倾斜传感器模型并返回 14 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    criteria - 迭代优化算法的终止准则。该函数估计构成立体相机对的两个相机之间的变换。如果分别计算物体相对于第一个相机和第二个相机的姿态 ( \(R_1\),\(T_1\) ) 和 (\(R_2\),\(T_2\))，对于两个相机之间的相对位置和方向固定的立体相机，则这些姿态肯定相互关联。这意味着，如果已知两个相机的相对位置和方向 (\(R\),\(T\))，则可以在给出 (\(R_1\),\(T_1\)) 时计算 (\(R_2\),\(T_2\))。这就是所述函数的作用。它计算 (\(R\),\(T\)) 使得：\(R_2=R R_1\) \(T_2=R T_1 + T.\) 因此，当给出 3D 点在第一个相机坐标系中的坐标表示时，可以计算该 3D 点在第二个相机坐标系中的坐标表示：\(\begin{bmatrix} X_2 \\ Y_2 \\ Z_2 \\ 1 \end{bmatrix} = \begin{bmatrix} R & T \\ 0 & 1 \end{bmatrix} \begin{bmatrix} X_1 \\ Y_1 \\ Z_1 \\ 1 \end{bmatrix}.\) 可选地，它计算本质矩阵 E：\(E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R\)，其中 \(T_i\) 是平移向量 \(T\) 的分量：\(T=[T_0, T_1, T_2]^T\) 。并且该函数还可以计算基础矩阵 F：\(F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}\) 除了与立体相关的的信息外，该函数还可以执行两个相机的完整标定。但是，由于参数空间的高维度和输入数据中的噪声，该函数可能会偏离正确的解。如果可以对每个相机的内参进行高精度估计（例如，使用 #calibrateCamera），建议这样做，然后将 REF: CALIB_FIX_INTRINSIC 标志与计算出的内参一起传递给该函数。否则，如果一次估计所有参数，则有必要限制某些参数，例如，传递 REF: CALIB_SAME_FOCAL_LENGTH 和 REF: CALIB_ZERO_TANGENT_DIST 标志，这通常是一个合理的假设。与 #calibrateCamera 类似，该函数最小化来自两个相机的所有可用视图中所有点的总重投影误差。该函数返回重投影误差的最终值。
    
    返回值
    
    自动生成
  - stereoCalibrateExtended
```
public static double stereoCalibrateExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat cameraMatrix1,
                                             Mat distCoeffs1,
                                             Mat cameraMatrix2,
                                             Mat distCoeffs2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             Mat E,
                                             Mat F,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat perViewErrors,
                                             int flags)
```
    标定立体相机设置。此函数查找两个相机的内参以及两个相机之间的外参。
    参数
    
    objectPoints - 标定图案点的向量集合。与 REF: calibrateCamera 中的结构相同。对于每个图案视图，两个相机都需要看到相同的物体点。因此，objectPoints.size()、imagePoints1.size() 和 imagePoints2.size() 需要相等，并且对于每个 i，objectPoints[i].size()、imagePoints1[i].size() 和 imagePoints2[i].size() 也需要相等。
    
    imagePoints1 - 第一个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    imagePoints2 - 第二个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    cameraMatrix1 - 第一个相机的输入/输出相机内参矩阵，与 REF: calibrateCamera 中相同。此外，对于立体情况，可以使用其他标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个相机的输入/输出第二个相机内参矩阵。参见 cameraMatrix1 的描述。
    
    distCoeffs2 - 第二个相机的输入/输出镜头畸变系数。参见 distCoeffs1 的描述。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    R - 输出旋转矩阵。该矩阵与平移向量 T 一起，将第一个相机坐标系中的点转换到第二个相机坐标系中的点。更专业的术语来说，R 和 T 的组合实现了从第一个相机坐标系到第二个相机坐标系的基变换。由于其对偶性，该组合等效于第一个相机相对于第二个相机坐标系的位置。
    
    T - 输出平移向量，见上文描述。
    
    E - 输出本质矩阵。
    
    F - 输出基础矩阵。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: CALIB_FIX_INTRINSIC 固定 cameraMatrix? 和 distCoeffs?，以便仅估计 R、T、E 和 F 矩阵。
    
    REF: CALIB_USE_INTRINSIC_GUESS 根据指定的标志优化部分或全部内参。初始值由用户提供。
    
    REF: CALIB_USE_EXTRINSIC_GUESS R 和 T 包含有效的初始值，这些值将被进一步优化。否则，R 和 T 将初始化为图案视图的中值（每个维度单独计算）。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在优化过程中固定主点。
    
    REF: CALIB_FIX_FOCAL_LENGTH 固定 \(f^{(j)}_x\) 和 \(f^{(j)}_y\) 。
    
    REF: CALIB_FIX_ASPECT_RATIO 优化 \(f^{(j)}_y\) 。固定比率 \(f^{(j)}_x/f^{(j)}_y\) 。
    
    REF: CALIB_SAME_FOCAL_LENGTH 强制 \(f^{(0)}_x=f^{(1)}_x\) 和 \(f^{(0)}_y=f^{(1)}_y\) 。
    
    REF: CALIB_ZERO_TANGENT_DIST 将每个相机的切向畸变系数设置为零并固定。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化过程中不更改相应的径向畸变系数。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用有理模型并返回 8 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用薄棱镜模型并返回 12 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用倾斜传感器模型并返回 14 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    该函数估计构成立体相机对的两个相机之间的变换。如果分别计算物体相对于第一个相机和第二个相机的姿态 ( \(R_1\),\(T_1\) ) 和 (\(R_2\),\(T_2\))，对于两个相机之间的相对位置和方向固定的立体相机，则这些姿态肯定相互关联。这意味着，如果已知两个相机的相对位置和方向 (\(R\),\(T\))，则可以在给出 (\(R_1\),\(T_1\)) 时计算 (\(R_2\),\(T_2\))。这就是所述函数的作用。它计算 (\(R\),\(T\)) 使得：\(R_2=R R_1\) \(T_2=R T_1 + T.\) 因此，当给出 3D 点在第一个相机坐标系中的坐标表示时，可以计算该 3D 点在第二个相机坐标系中的坐标表示：\(\begin{bmatrix} X_2 \\ Y_2 \\ Z_2 \\ 1 \end{bmatrix} = \begin{bmatrix} R & T \\ 0 & 1 \end{bmatrix} \begin{bmatrix} X_1 \\ Y_1 \\ Z_1 \\ 1 \end{bmatrix}.\) 可选地，它计算本质矩阵 E：\(E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R\)，其中 \(T_i\) 是平移向量 \(T\) 的分量：\(T=[T_0, T_1, T_2]^T\) 。并且该函数还可以计算基础矩阵 F：\(F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}\) 除了与立体相关的的信息外，该函数还可以执行两个相机的完整标定。但是，由于参数空间的高维度和输入数据中的噪声，该函数可能会偏离正确的解。如果可以对每个相机的内参进行高精度估计（例如，使用 #calibrateCamera），建议这样做，然后将 REF: CALIB_FIX_INTRINSIC 标志与计算出的内参一起传递给该函数。否则，如果一次估计所有参数，则有必要限制某些参数，例如，传递 REF: CALIB_SAME_FOCAL_LENGTH 和 REF: CALIB_ZERO_TANGENT_DIST 标志，这通常是一个合理的假设。与 #calibrateCamera 类似，该函数最小化来自两个相机的所有可用视图中所有点的总重投影误差。该函数返回重投影误差的最终值。
    
    返回值
    
    自动生成
  - stereoCalibrateExtended
```
public static double stereoCalibrateExtended(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat cameraMatrix1,
                                             Mat distCoeffs1,
                                             Mat cameraMatrix2,
                                             Mat distCoeffs2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             Mat E,
                                             Mat F,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             Mat perViewErrors)
```
    标定立体相机设置。此函数查找两个相机的内参以及两个相机之间的外参。
    参数
    
    objectPoints - 标定图案点的向量集合。与 REF: calibrateCamera 中的结构相同。对于每个图案视图，两个相机都需要看到相同的物体点。因此，objectPoints.size()、imagePoints1.size() 和 imagePoints2.size() 需要相等，并且对于每个 i，objectPoints[i].size()、imagePoints1[i].size() 和 imagePoints2[i].size() 也需要相等。
    
    imagePoints1 - 第一个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    imagePoints2 - 第二个相机观察到的标定图案点投影的向量集合。与 REF: calibrateCamera 中的结构相同。
    
    cameraMatrix1 - 第一个相机的输入/输出相机内参矩阵，与 REF: calibrateCamera 中相同。此外，对于立体情况，可以使用其他标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个相机的输入/输出第二个相机内参矩阵。参见 cameraMatrix1 的描述。
    
    distCoeffs2 - 第二个相机的输入/输出镜头畸变系数。参见 distCoeffs1 的描述。
    
    imageSize - 图像大小，仅用于初始化相机内参矩阵。
    
    R - 输出旋转矩阵。该矩阵与平移向量 T 一起，将第一个相机坐标系中的点转换到第二个相机坐标系中的点。更专业的术语来说，R 和 T 的组合实现了从第一个相机坐标系到第二个相机坐标系的基变换。由于其对偶性，该组合等效于第一个相机相对于第二个相机坐标系的位置。
    
    T - 输出平移向量，见上文描述。
    
    E - 输出本质矩阵。
    
    F - 输出基础矩阵。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    perViewErrors - 输出每个图案视图估计的 RMS 重投影误差向量。
    
    REF: CALIB_FIX_INTRINSIC 固定 cameraMatrix? 和 distCoeffs?，以便仅估计 R、T、E 和 F 矩阵。
    
    REF: CALIB_USE_INTRINSIC_GUESS 根据指定的标志优化部分或全部内参。初始值由用户提供。
    
    REF: CALIB_USE_EXTRINSIC_GUESS R 和 T 包含有效的初始值，这些值将被进一步优化。否则，R 和 T 将初始化为图案视图的中值（每个维度单独计算）。
    
    REF: CALIB_FIX_PRINCIPAL_POINT 在优化过程中固定主点。
    
    REF: CALIB_FIX_FOCAL_LENGTH 固定 \(f^{(j)}_x\) 和 \(f^{(j)}_y\) 。
    
    REF: CALIB_FIX_ASPECT_RATIO 优化 \(f^{(j)}_y\) 。固定比率 \(f^{(j)}_x/f^{(j)}_y\) 。
    
    REF: CALIB_SAME_FOCAL_LENGTH 强制 \(f^{(0)}_x=f^{(1)}_x\) 和 \(f^{(0)}_y=f^{(1)}_y\) 。
    
    REF: CALIB_ZERO_TANGENT_DIST 将每个相机的切向畸变系数设置为零并固定。
    
    REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 在优化过程中不更改相应的径向畸变系数。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_RATIONAL_MODEL 启用系数 k4、k5 和 k6。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用有理模型并返回 8 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_THIN_PRISM_MODEL 启用系数 s1、s2、s3 和 s4。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用薄棱镜模型并返回 12 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_S1_S2_S3_S4 在优化期间，薄棱镜畸变系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    REF: CALIB_TILTED_MODEL 启用系数 tauX 和 tauY。为了提供向后兼容性，应显式指定此额外标志，以使标定函数使用倾斜传感器模型并返回 14 个系数。如果未设置此标志，则函数仅计算并返回 5 个畸变系数。
    
    REF: CALIB_FIX_TAUX_TAUY 在优化期间，倾斜传感器模型的系数不会改变。如果设置了 REF: CALIB_USE_INTRINSIC_GUESS，则使用提供的 distCoeffs 矩阵中的系数。否则，将其设置为 0。
    
    该函数估计构成立体相机对的两个相机之间的变换。如果分别计算物体相对于第一个相机和第二个相机的姿态 ( \(R_1\),\(T_1\) ) 和 (\(R_2\),\(T_2\))，对于两个相机之间的相对位置和方向固定的立体相机，则这些姿态肯定相互关联。这意味着，如果已知两个相机的相对位置和方向 (\(R\),\(T\))，则可以在给出 (\(R_1\),\(T_1\)) 时计算 (\(R_2\),\(T_2\))。这就是所述函数的作用。它计算 (\(R\),\(T\)) 使得：\(R_2=R R_1\) \(T_2=R T_1 + T.\) 因此，当给出 3D 点在第一个相机坐标系中的坐标表示时，可以计算该 3D 点在第二个相机坐标系中的坐标表示：\(\begin{bmatrix} X_2 \\ Y_2 \\ Z_2 \\ 1 \end{bmatrix} = \begin{bmatrix} R & T \\ 0 & 1 \end{bmatrix} \begin{bmatrix} X_1 \\ Y_1 \\ Z_1 \\ 1 \end{bmatrix}.\) 可选地，它计算本质矩阵 E：\(E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R\)，其中 \(T_i\) 是平移向量 \(T\) 的分量：\(T=[T_0, T_1, T_2]^T\) 。并且该函数还可以计算基础矩阵 F：\(F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}\) 除了与立体相关的的信息外，该函数还可以执行两个相机的完整标定。但是，由于参数空间的高维度和输入数据中的噪声，该函数可能会偏离正确的解。如果可以对每个相机的内参进行高精度估计（例如，使用 #calibrateCamera），建议这样做，然后将 REF: CALIB_FIX_INTRINSIC 标志与计算出的内参一起传递给该函数。否则，如果一次估计所有参数，则有必要限制某些参数，例如，传递 REF: CALIB_SAME_FOCAL_LENGTH 和 REF: CALIB_ZERO_TANGENT_DIST 标志，这通常是一个合理的假设。与 #calibrateCamera 类似，该函数最小化来自两个相机的所有可用视图中所有点的总重投影误差。该函数返回重投影误差的最终值。
    
    返回值
    
    自动生成
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     int flags,
                                     TermCriteria criteria)
```
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     int flags)
```
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F)
```
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     Mat perViewErrors,
                                     int flags,
                                     TermCriteria criteria)
```
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     Mat perViewErrors,
                                     int flags)
```
  - stereoCalibrate
```
public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     Mat perViewErrors)
```
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q,
                                 int flags,
                                 double alpha,
                                 Size newImageSize,
                                 Rect validPixROI1,
                                 Rect validPixROI2)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: CALIB_ZERO_DISPARITY 。如果设置了该标志，则函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有效的图像区域。
    
    alpha - 自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应在 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效的像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便摄像机的原始图像中的所有像素都保留在校正后的图像中（不会丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。
    
    newImageSize - 校正后的新图像分辨率。应将相同的大小传递给 #initUndistortRectifyMap（参见 OpenCV 示例目录中的 stereo_calib.cpp 示例）。当传递 (0,0)（默认值）时，它被设置为原始 imageSize 。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变的情况下。
    
    validPixROI1 - 校正后的图像内可选的输出矩形区域，其中所有像素均有效。如果 alpha=0 ，则 ROI 覆盖整个图像。否则，它们可能更小（参见下图）。
    
    validPixROI2 - 校正后的图像内可选的输出矩形区域，其中所有像素均有效。如果 alpha=0 ，则 ROI 覆盖整个图像。否则，它们可能更小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机的图像平面成为同一个平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数将由 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供了两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q,
                                 int flags,
                                 double alpha,
                                 Size newImageSize,
                                 Rect validPixROI1)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: CALIB_ZERO_DISPARITY 。如果设置了该标志，则函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有效的图像区域。
    
    alpha - 自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应在 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效的像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便摄像机的原始图像中的所有像素都保留在校正后的图像中（不会丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。
    
    newImageSize - 校正后的新图像分辨率。应将相同的大小传递给 #initUndistortRectifyMap（参见 OpenCV 示例目录中的 stereo_calib.cpp 示例）。当传递 (0,0)（默认值）时，它被设置为原始 imageSize 。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变的情况下。
    
    validPixROI1 - 可选输出矩形，位于校正后的图像内，所有像素均有效。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机图像平面成为同一平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数以 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q,
                                 int flags,
                                 double alpha,
                                 Size newImageSize)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: CALIB_ZERO_DISPARITY 。如果设置了该标志，则函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有效的图像区域。
    
    alpha - 自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应在 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效的像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便摄像机的原始图像中的所有像素都保留在校正后的图像中（不会丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。
    
    newImageSize - 校正后新的图像分辨率。应将相同大小传递给 #initUndistortRectifyMap（参见 OpenCV 样例目录中的 stereo_calib.cpp 样例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变时。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机图像平面成为同一平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数以 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q,
                                 int flags,
                                 double alpha)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: CALIB_ZERO_DISPARITY 。如果设置了该标志，则函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有效的图像区域。
    
    alpha - 自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应介于 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便保留来自摄像机的原始图像的所有像素（没有丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。应将相同大小传递给 #initUndistortRectifyMap（参见 OpenCV 样例目录中的 stereo_calib.cpp 样例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变时。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机图像平面成为同一平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数以 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q,
                                 int flags)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: CALIB_ZERO_DISPARITY。如果设置了该标志，则该函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数可能仍然沿水平或垂直方向（取决于极线的取向）移动图像，以最大化有用的图像区域。自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应介于 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便保留来自摄像机的原始图像的所有像素（没有丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。应将相同大小传递给 #initUndistortRectifyMap（参见 OpenCV 样例目录中的 stereo_calib.cpp 样例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变时。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机图像平面成为同一平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数以 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectify
```
public static void stereoRectify(Mat cameraMatrix1,
                                 Mat distCoeffs1,
                                 Mat cameraMatrix2,
                                 Mat distCoeffs2,
                                 Size imageSize,
                                 Mat R,
                                 Mat T,
                                 Mat R1,
                                 Mat R2,
                                 Mat P1,
                                 Mat P2,
                                 Mat Q)
```
    计算已标定立体相机的每个头的校正变换。
    参数
    
    cameraMatrix1 - 第一个相机的内参矩阵。
    
    distCoeffs1 - 第一个相机的畸变参数。
    
    cameraMatrix2 - 第二个相机的内参矩阵。
    
    distCoeffs2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 从第一个摄像机的坐标系到第二个摄像机的旋转矩阵，参见 REF: stereoCalibrate。
    
    T - 从第一个摄像机的坐标系到第二个摄像机的平移向量，参见 REF: stereoCalibrate。
    
    R1 - 第一个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第一个摄像机坐标系中的点转换到校正后的第一个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第一个摄像机坐标系到校正后的第一个摄像机坐标系的基变换。
    
    R2 - 第二个摄像机的输出 3x3 校正变换（旋转矩阵）。此矩阵将给定在未校正的第二个摄像机坐标系中的点转换到校正后的第二个摄像机坐标系中的点。更专业的术语来说，它执行从未校正的第二个摄像机坐标系到校正后的第二个摄像机坐标系的基变换。
    
    P1 - 在新的（校正后的）坐标系中第一个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第一个摄像机的图像中。
    
    P2 - 在新的（校正后的）坐标系中第二个摄像机的输出 3x4 投影矩阵，即它将给定在校正后的第一个摄像机坐标系中的点投影到校正后的第二个摄像机的图像中。
    
    Q - 输出 \(4 \times 4\)视差到深度的映射矩阵（参见 REF: reprojectImageTo3D）。如果设置了该标志，则该函数使每个摄像机的principal points在校正后的视图中具有相同的像素坐标。如果没有设置该标志，则该函数可能仍然沿水平或垂直方向（取决于极线的取向）移动图像，以最大化有用的图像区域。自由缩放参数。如果它是 -1 或不存在，则函数执行默认缩放。否则，参数应介于 0 和 1 之间。alpha=0 表示校正后的图像被缩放和平移，以便只有有效像素可见（校正后没有黑色区域）。alpha=1 表示校正后的图像被缩小和平移，以便保留来自摄像机的原始图像的所有像素（没有丢失源图像像素）。任何中间值都会产生这两个极端情况之间的中间结果。应将相同大小传递给 #initUndistortRectifyMap（参见 OpenCV 样例目录中的 stereo_calib.cpp 样例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在较大径向畸变时。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。如果 alpha=0，则 ROI 覆盖整个图像。否则，它们可能较小（参见下图）。该函数计算每个摄像机的旋转矩阵，这些矩阵（虚拟地）使两个摄像机图像平面成为同一平面。因此，这使得所有极线平行，从而简化了密集立体匹配问题。该函数以 #stereoCalibrate 计算的矩阵作为输入。作为输出，它提供两个旋转矩阵以及在新坐标系中的两个投影矩阵。该函数区分以下两种情况
    
    水平立体：第一个和第二个摄像机的视图主要沿 x 轴（可能带有少量垂直位移）相互偏移。在校正后的图像中，左摄像机和右摄像机中的对应极线是水平的，并且具有相同的 y 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x \cdot f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx_1 \\ 0 & 1 & 0 & -cy \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x} \end{bmatrix} \) 其中 \(T_x\) 是摄像机之间的水平偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cx_1=cx_2\)。
    
    垂直立体：第一个和第二个摄像机的视图主要在垂直方向上（也可能在水平方向上有一点）相互偏移。校正后的图像中的极线是垂直的，并且具有相同的 x 坐标。P1 和 P2 看起来像
    
    \(\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\) \(\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y \cdot f \\ 0 & 0 & 1 & 0 \end{bmatrix},\) \(\texttt{Q} = \begin{bmatrix} 1 & 0 & 0 & -cx \\ 0 & 1 & 0 & -cy_1 \\ 0 & 0 & 0 & f \\ 0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y} \end{bmatrix} \) 其中 \(T_y\) 是摄像机之间的垂直偏移，如果设置了 REF: CALIB_ZERO_DISPARITY，则 \(cy_1=cy_2\)。可以看到，P1 和 P2 的前三列实际上将成为新的“校正后的”摄像机矩阵。然后，这些矩阵与 R1 和 R2 一起可以传递给 #initUndistortRectifyMap 以初始化每个摄像机的校正映射。请参见下面 stereo_calib.cpp 示例的屏幕截图。一些红色的水平线穿过对应的图像区域。这意味着图像已很好地校正，这是大多数立体匹配算法所依赖的。绿色矩形是 roi1 和 roi2 。您可以看到它们的内部都是有效的像素。![image](pics/stereo_undistort.jpg)
  - stereoRectifyUncalibrated
```
public static boolean stereoRectifyUncalibrated(Mat points1,
                                                Mat points2,
                                                Mat F,
                                                Size imgSize,
                                                Mat H1,
                                                Mat H2,
                                                double threshold)
```
    计算未标定的立体摄像机的校正变换。
    
    参数
    
    points1 - 第一幅图像中的特征点数组。
    
    points2 - 第二幅图像中对应的点。支持与 #findFundamentalMat 中相同的格式。
    
    F - 输入基本矩阵。可以使用 #findFundamentalMat 从相同的点对集合计算它。
    
    imgSize - 图像大小。
    
    H1 - 第一张图像的输出校正单应性矩阵。
    
    H2 - 第二张图像的输出校正单应性矩阵。
    
    threshold - 用于过滤异常值的可选阈值。如果参数大于零，则在计算单应性之前，所有不符合极线几何的点对（即，满足\(|\texttt{points2[i]}^T \cdot \texttt{F} \cdot \texttt{points1[i]}|>\texttt{threshold}\) 的点）都会被拒绝。否则，所有点都被视为内点。该函数在不知道摄像机的内参及其在空间中的相对位置的情况下计算校正变换，这就是“未标定”后缀的含义。与 #stereoRectify 的另一个相关区别在于，该函数输出的不是物体（3D）空间中的校正变换，而是由单应性矩阵 H1 和 H2 编码的平面透视变换。该函数实现了算法 CITE: Hartley99 。注意：虽然该算法不需要知道摄像机的内参，但它严重依赖于极线几何。因此，如果相机镜头存在明显的畸变，最好在计算基本矩阵和调用此函数之前对其进行校正。例如，可以使用 #calibrateCamera 分别为立体摄像机的每个头部估计畸变系数。然后，可以使用 #undistort 校正图像，或者只使用 #undistortPoints 校正点坐标。
    
    返回值
    
    自动生成
  - stereoRectifyUncalibrated
```
public static boolean stereoRectifyUncalibrated(Mat points1,
                                                Mat points2,
                                                Mat F,
                                                Size imgSize,
                                                Mat H1,
                                                Mat H2)
```
    计算未标定的立体摄像机的校正变换。
    
    参数
    
    points1 - 第一幅图像中的特征点数组。
    
    points2 - 第二幅图像中对应的点。支持与 #findFundamentalMat 中相同的格式。
    
    F - 输入基本矩阵。可以使用 #findFundamentalMat 从相同的点对集合计算它。
    
    imgSize - 图像大小。
    
    H1 - 第一张图像的输出校正单应性矩阵。
    
    H2 - 第二张图像的输出校正单应性矩阵。大于零，则在计算单应性之前，所有不符合极线几何的点对（即，满足\(|\texttt{points2[i]}^T \cdot \texttt{F} \cdot \texttt{points1[i]}|>\texttt{threshold}\) 的点）都会被拒绝。否则，所有点都被视为内点。该函数在不知道摄像机的内参及其在空间中的相对位置的情况下计算校正变换，这就是“未标定”后缀的含义。与 #stereoRectify 的另一个相关区别在于，该函数输出的不是物体（3D）空间中的校正变换，而是由单应性矩阵 H1 和 H2 编码的平面透视变换。该函数实现了算法 CITE: Hartley99 。注意：虽然该算法不需要知道摄像机的内参，但它严重依赖于极线几何。因此，如果相机镜头存在明显的畸变，最好在计算基本矩阵和调用此函数之前对其进行校正。例如，可以使用 #calibrateCamera 分别为立体摄像机的每个头部估计畸变系数。然后，可以使用 #undistort 校正图像，或者只使用 #undistortPoints 校正点坐标。
    
    返回值
    
    自动生成
  - rectify3Collinear
```
public static float rectify3Collinear(Mat cameraMatrix1,
                                      Mat distCoeffs1,
                                      Mat cameraMatrix2,
                                      Mat distCoeffs2,
                                      Mat cameraMatrix3,
                                      Mat distCoeffs3,
                                      java.util.List<Mat> imgpt1,
                                      java.util.List<Mat> imgpt3,
                                      Size imageSize,
                                      Mat R12,
                                      Mat T12,
                                      Mat R13,
                                      Mat T13,
                                      Mat R1,
                                      Mat R2,
                                      Mat R3,
                                      Mat P1,
                                      Mat P2,
                                      Mat P3,
                                      Mat Q,
                                      double alpha,
                                      Size newImgSize,
                                      Rect roi1,
                                      Rect roi2,
                                      int flags)
```
  - getOptimalNewCameraMatrix
```
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                            Mat distCoeffs,
                                            Size imageSize,
                                            double alpha,
                                            Size newImgSize,
                                            Rect validPixROI,
                                            boolean centerPrincipalPoint)
```
    基于自由缩放参数返回新的相机内参矩阵。
    
    参数
    
    cameraMatrix - 输入相机内参矩阵。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    imageSize - 原始图像尺寸。
    
    alpha - 0（当未畸变图像中的所有像素均有效）到 1（当未畸变图像中保留所有源图像像素）之间的自由缩放参数。详情请参见 #stereoRectify。
    
    newImgSize - 校正后图像尺寸。默认情况下，设置为 imageSize。
    
    validPixROI - 可选输出矩形，用于描绘未畸变图像中所有有效像素区域。参见 #stereoRectify 中 roi1、roi2 的描述。
    
    centerPrincipalPoint - 可选标志，指示在新相机内参矩阵中主点是否应位于图像中心。默认情况下，选择主点以最佳方式将源图像的子集（由 alpha 确定）拟合到校正后的图像。
    
    返回值
    
    new_camera_matrix 输出新的相机内参矩阵。该函数基于自由缩放参数计算并返回最佳的新相机内参矩阵。通过改变此参数，您可以仅检索有效的像素 alpha=0 ，如果角点中有有价值的信息，则保留所有原始图像像素 alpha=1 ，或者获得介于两者之间的结果。当 alpha>0 时，未畸变的结果可能包含一些对应于捕获的畸变图像外部“虚拟”像素的黑色像素。原始相机内参矩阵、畸变系数、计算出的新相机内参矩阵和 newImageSize 应传递给 #initUndistortRectifyMap 以生成 #remap 的映射。
  - getOptimalNewCameraMatrix
```
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                            Mat distCoeffs,
                                            Size imageSize,
                                            double alpha,
                                            Size newImgSize,
                                            Rect validPixROI)
```
    基于自由缩放参数返回新的相机内参矩阵。
    
    参数
    
    cameraMatrix - 输入相机内参矩阵。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    imageSize - 原始图像尺寸。
    
    alpha - 0（当未畸变图像中的所有像素均有效）到 1（当未畸变图像中保留所有源图像像素）之间的自由缩放参数。详情请参见 #stereoRectify。
    
    newImgSize - 校正后图像尺寸。默认情况下，设置为 imageSize。
    
    validPixROI - 可选输出矩形，用于描绘未畸变图像中所有有效像素区域。参见 #stereoRectify 中 roi1、roi2 的描述。主点是否应位于图像中心。默认情况下，选择主点以最佳方式将源图像的子集（由 alpha 确定）拟合到校正后的图像。
    
    返回值
    
    new_camera_matrix 输出新的相机内参矩阵。该函数基于自由缩放参数计算并返回最佳的新相机内参矩阵。通过改变此参数，您可以仅检索有效的像素 alpha=0 ，如果角点中有有价值的信息，则保留所有原始图像像素 alpha=1 ，或者获得介于两者之间的结果。当 alpha>0 时，未畸变的结果可能包含一些对应于捕获的畸变图像外部“虚拟”像素的黑色像素。原始相机内参矩阵、畸变系数、计算出的新相机内参矩阵和 newImageSize 应传递给 #initUndistortRectifyMap 以生成 #remap 的映射。
  - getOptimalNewCameraMatrix
```
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                            Mat distCoeffs,
                                            Size imageSize,
                                            double alpha,
                                            Size newImgSize)
```
    基于自由缩放参数返回新的相机内参矩阵。
    
    参数
    
    cameraMatrix - 输入相机内参矩阵。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    imageSize - 原始图像尺寸。
    
    alpha - 0（当未畸变图像中的所有像素均有效）到 1（当未畸变图像中保留所有源图像像素）之间的自由缩放参数。详情请参见 #stereoRectify。
    
    newImgSize - 校正后图像尺寸。默认情况下，设置为 imageSize。未畸变图像。参见 #stereoRectify 中 roi1、roi2 的描述。主点是否应位于图像中心。默认情况下，选择主点以最佳方式将源图像的子集（由 alpha 确定）拟合到校正后的图像。
    
    返回值
    
    new_camera_matrix 输出新的相机内参矩阵。该函数基于自由缩放参数计算并返回最佳的新相机内参矩阵。通过改变此参数，您可以仅检索有效的像素 alpha=0 ，如果角点中有有价值的信息，则保留所有原始图像像素 alpha=1 ，或者获得介于两者之间的结果。当 alpha>0 时，未畸变的结果可能包含一些对应于捕获的畸变图像外部“虚拟”像素的黑色像素。原始相机内参矩阵、畸变系数、计算出的新相机内参矩阵和 newImageSize 应传递给 #initUndistortRectifyMap 以生成 #remap 的映射。
  - getOptimalNewCameraMatrix
```
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                            Mat distCoeffs,
                                            Size imageSize,
                                            double alpha)
```
    基于自由缩放参数返回新的相机内参矩阵。
    
    参数
    
    cameraMatrix - 输入相机内参矩阵。
    
    distCoeffs - 输入畸变系数向量 \(\distcoeffs\)。如果向量为 NULL/空，则假定为零畸变系数。
    
    imageSize - 原始图像尺寸。
    
    alpha - 0（当未畸变图像中的所有像素均有效）到 1（当未畸变图像中保留所有源图像像素）之间的自由缩放参数。详情请参见 #stereoRectify。未畸变图像。参见 #stereoRectify 中 roi1、roi2 的描述。主点是否应位于图像中心。默认情况下，选择主点以最佳方式将源图像的子集（由 alpha 确定）拟合到校正后的图像。
    
    返回值
    
    new_camera_matrix 输出新的相机内参矩阵。该函数基于自由缩放参数计算并返回最佳的新相机内参矩阵。通过改变此参数，您可以仅检索有效的像素 alpha=0 ，如果角点中有有价值的信息，则保留所有原始图像像素 alpha=1 ，或者获得介于两者之间的结果。当 alpha>0 时，未畸变的结果可能包含一些对应于捕获的畸变图像外部“虚拟”像素的黑色像素。原始相机内参矩阵、畸变系数、计算出的新相机内参矩阵和 newImageSize 应传递给 #initUndistortRectifyMap 以生成 #remap 的映射。
  - calibrateHandEye
```
public static void calibrateHandEye(java.util.List<Mat> R_gripper2base,
                                    java.util.List<Mat> t_gripper2base,
                                    java.util.List<Mat> R_target2cam,
                                    java.util.List<Mat> t_target2cam,
                                    Mat R_cam2gripper,
                                    Mat t_cam2gripper,
                                    int method)
```
    计算手眼标定：\(_{}^{g}\textrm{T}_c\)
    参数
    
    R_gripper2base - 从齐次矩阵中提取的旋转部分，该矩阵将以夹爪坐标系表示的点变换到机器人基坐标系 (\(_{}^{b}\textrm{T}_g\))。这是一个向量 (vector<Mat>)，包含所有从夹爪坐标系到机器人基坐标系的变换的旋转，(3x3) 旋转矩阵或 (3x1) 旋转向量。
    
    t_gripper2base - 从齐次矩阵中提取的平移部分，该矩阵将以夹爪坐标系表示的点变换到机器人基坐标系 (\(_{}^{b}\textrm{T}_g\))。这是一个向量 (vector<Mat>)，包含所有从夹爪坐标系到机器人基坐标系的变换的 (3x1) 平移向量。
    
    R_target2cam - 从齐次矩阵中提取的旋转部分，该矩阵将以目标坐标系表示的点变换到相机坐标系 (\(_{}^{c}\textrm{T}_t\))。这是一个向量 (vector<Mat>)，包含所有从标定目标坐标系到相机坐标系的变换的旋转，(3x3) 旋转矩阵或 (3x1) 旋转向量。
    
    t_target2cam - 从齐次矩阵中提取的旋转部分，该矩阵将以目标坐标系表示的点变换到相机坐标系 (\(_{}^{c}\textrm{T}_t\))。这是一个向量 (vector<Mat>)，包含所有从标定目标坐标系到相机坐标系的变换的 (3x1) 平移向量。
    
    R_cam2gripper - 估计的 (3x3) 旋转部分，从将相机坐标系中表示的点变换到夹爪坐标系的齐次矩阵中提取 (\(_{}^{g}\textrm{T}_c\))。
    
    t_cam2gripper - 估计的 (3x1) 平移部分，从将相机坐标系中表示的点变换到夹爪坐标系的齐次矩阵中提取 (\(_{}^{g}\textrm{T}_c\))。
    
    method - 实现的手眼标定方法之一，参见 cv::HandEyeCalibrationMethod 该函数使用各种方法执行手眼标定。一种方法包括先估计旋转再估计平移（可分离解），并实现以下方法
    
    R. Tsai, R. Lenz 一种新的全自动高效 3D 机器人手眼标定技术 \cite Tsai89
    
    F. Park, B. Martin 机器人传感器标定：在欧几里得群上求解 AX = XB \cite Park94
    
    R. Horaud, F. Dornaika 手眼标定 \cite Horaud95
    
    另一种方法包括同时估计旋转和平移（同时解），并实现以下方法
    
    N. Andreff, R. Horaud, B. Espiau 在线手眼标定 \cite Andreff99
    
    K. Daniilidis 使用对偶四元数的手眼标定 \cite Daniilidis98
    
    下图描述了手眼标定问题，其中需要估计安装在机器人夹爪（“手”）上的相机（“眼”）之间的变换。此配置称为眼在手中。眼到手配置包括一个静态相机观察安装在机器人末端执行器上的标定图案。然后可以通过将合适的变换输入到函数中来估计从相机到机器人基座坐标系的变换，见下文。![](pics/hand-eye_figure.png) 标定过程如下：
    
    使用静态标定图案来估计目标坐标系和相机坐标系之间的变换。
    
    移动机器人夹爪以获取多个姿态。
    
    对于每个姿态，使用机器人运动学记录夹爪坐标系和机器人基座坐标系之间的齐次变换，例如 \( \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \)
    
    对于每个姿态，使用例如基于二维三维点对应关系的姿态估计方法 (PnP) 记录标定目标坐标系和相机坐标系之间的齐次变换 \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_t\\ Y_t\\ Z_t\\ 1 \end{bmatrix} \)
    
    手眼标定过程返回以下齐次变换 \( \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \) 此问题也称为求解 \(\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\) 方程。
    
    对于眼在手中配置 \( \begin{align*} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
    
    (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &= \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \)
    
    对于眼到手配置 \( \begin{align*} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
    
    (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &= \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \) \note 更多信息可在[此网站](http://campar.in.tum.de/Chair/HandEyeCalibration)上找到。\note 至少需要两个旋转轴不平行的运动来确定手眼变换。因此至少需要3个不同的姿态，但强烈建议使用更多姿态。
  - calibrateHandEye
```
public static void calibrateHandEye(java.util.List<Mat> R_gripper2base,
                                    java.util.List<Mat> t_gripper2base,
                                    java.util.List<Mat> R_target2cam,
                                    java.util.List<Mat> t_target2cam,
                                    Mat R_cam2gripper,
                                    Mat t_cam2gripper)
```
    计算手眼标定：\(_{}^{g}\textrm{T}_c\)
    参数
    
    R_gripper2base - 从齐次矩阵中提取的旋转部分，该矩阵将以夹爪坐标系表示的点变换到机器人基坐标系 (\(_{}^{b}\textrm{T}_g\))。这是一个向量 (vector<Mat>)，包含所有从夹爪坐标系到机器人基坐标系的变换的旋转，(3x3) 旋转矩阵或 (3x1) 旋转向量。
    
    t_gripper2base - 从齐次矩阵中提取的平移部分，该矩阵将以夹爪坐标系表示的点变换到机器人基坐标系 (\(_{}^{b}\textrm{T}_g\))。这是一个向量 (vector<Mat>)，包含所有从夹爪坐标系到机器人基坐标系的变换的 (3x1) 平移向量。
    
    R_target2cam - 从齐次矩阵中提取的旋转部分，该矩阵将以目标坐标系表示的点变换到相机坐标系 (\(_{}^{c}\textrm{T}_t\))。这是一个向量 (vector<Mat>)，包含所有从标定目标坐标系到相机坐标系的变换的旋转，(3x3) 旋转矩阵或 (3x1) 旋转向量。
    
    t_target2cam - 从齐次矩阵中提取的旋转部分，该矩阵将以目标坐标系表示的点变换到相机坐标系 (\(_{}^{c}\textrm{T}_t\))。这是一个向量 (vector<Mat>)，包含所有从标定目标坐标系到相机坐标系的变换的 (3x1) 平移向量。
    
    R_cam2gripper - 估计的 (3x3) 旋转部分，从将相机坐标系中表示的点变换到夹爪坐标系的齐次矩阵中提取 (\(_{}^{g}\textrm{T}_c\))。
    
    t_cam2gripper - 从将相机坐标系中表示的点变换到夹爪坐标系的齐次矩阵(\(_{}^{g}\textrm{T}_c\))中提取的估计的(3x1)平移部分。该函数使用多种方法执行手眼标定。一种方法包括先估计旋转然后估计平移（可分离解），并实现以下方法：
    
    R. Tsai, R. Lenz 一种新的全自动高效 3D 机器人手眼标定技术 \cite Tsai89
    
    F. Park, B. Martin 机器人传感器标定：在欧几里得群上求解 AX = XB \cite Park94
    
    R. Horaud, F. Dornaika 手眼标定 \cite Horaud95
    
    另一种方法包括同时估计旋转和平移（同时解），并实现以下方法
    
    N. Andreff, R. Horaud, B. Espiau 在线手眼标定 \cite Andreff99
    
    K. Daniilidis 使用对偶四元数的手眼标定 \cite Daniilidis98
    
    下图描述了手眼标定问题，其中需要估计安装在机器人夹爪（“手”）上的相机（“眼”）之间的变换。此配置称为眼在手中。眼到手配置包括一个静态相机观察安装在机器人末端执行器上的标定图案。然后可以通过将合适的变换输入到函数中来估计从相机到机器人基座坐标系的变换，见下文。![](pics/hand-eye_figure.png) 标定过程如下：
    
    使用静态标定图案来估计目标坐标系和相机坐标系之间的变换。
    
    移动机器人夹爪以获取多个姿态。
    
    对于每个姿态，使用机器人运动学记录夹爪坐标系和机器人基座坐标系之间的齐次变换，例如 \( \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \)
    
    对于每个姿态，使用例如基于二维三维点对应关系的姿态估计方法 (PnP) 记录标定目标坐标系和相机坐标系之间的齐次变换 \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_t\\ Y_t\\ Z_t\\ 1 \end{bmatrix} \)
    
    手眼标定过程返回以下齐次变换 \( \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \) 此问题也称为求解 \(\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\) 方程。
    
    对于眼在手中配置 \( \begin{align*} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
    
    (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &= \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \)
    
    对于眼到手配置 \( \begin{align*} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
    
    (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &= \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \) \note 更多信息可在[此网站](http://campar.in.tum.de/Chair/HandEyeCalibration)上找到。\note 至少需要两个旋转轴不平行的运动来确定手眼变换。因此至少需要3个不同的姿态，但强烈建议使用更多姿态。
  - calibrateRobotWorldHandEye
```
public static void calibrateRobotWorldHandEye(java.util.List<Mat> R_world2cam,
                                              java.util.List<Mat> t_world2cam,
                                              java.util.List<Mat> R_base2gripper,
                                              java.util.List<Mat> t_base2gripper,
                                              Mat R_base2world,
                                              Mat t_base2world,
                                              Mat R_gripper2cam,
                                              Mat t_gripper2cam,
                                              int method)
```
    计算机器人-世界/手眼标定：\(_{}^{w}\textrm{T}_b\) 和 \(_{}^{c}\textrm{T}_g\)
    参数
    
    R_world2cam - 从将世界坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_w\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从世界坐标系到相机坐标系的变换的旋转，(3x3)旋转矩阵或(3x1)旋转向量。
    
    t_world2cam - 从将世界坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_w\))中提取的平移部分。这是一个向量 (vector<Mat>)，包含所有从世界坐标系到相机坐标系的变换的(3x1)平移向量。
    
    R_base2gripper - 从将机器人基座坐标系中表示的点变换到夹爪坐标系的齐次矩阵(\(_{}^{g}\textrm{T}_b\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从机器人基座坐标系到夹爪坐标系的变换的旋转，(3x3)旋转矩阵或(3x1)旋转向量。
    
    t_base2gripper - 从将机器人基座坐标系中表示的点变换到夹爪坐标系的齐次矩阵(\(_{}^{g}\textrm{T}_b\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从机器人基座坐标系到夹爪坐标系的变换的(3x1)平移向量。
    
    R_base2world - 从将机器人基座坐标系中表示的点变换到世界坐标系的齐次矩阵(\(_{}^{w}\textrm{T}_b\))中提取的估计的(3x3)旋转部分。
    
    t_base2world - 从将机器人基座坐标系中表示的点变换到世界坐标系的齐次矩阵(\(_{}^{w}\textrm{T}_b\))中提取的估计的(3x1)平移部分。
    
    R_gripper2cam - 从将夹爪坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_g\))中提取的估计的(3x3)旋转部分。
    
    t_gripper2cam - 从将夹爪坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_g\))中提取的估计的(3x1)平移部分。
    
    method - 已实现的机器人-世界/手眼标定方法之一，参见cv::RobotWorldHandEyeCalibrationMethod。该函数使用多种方法执行机器人-世界/手眼标定。一种方法包括先估计旋转然后估计平移（可分离解）。
    
    M. Shah，使用克罗内克积求解机器人-世界/手眼标定问题 \cite Shah2013SolvingTR
    
    另一种方法包括同时估计旋转和平移（同时解），并使用以下实现方法：
    
    A. Li，L. Wang和D. Wu，使用对偶四元数和克罗内克积同时进行机器人-世界和手眼标定 \cite Li2010SimultaneousRA
    
    下图描述了机器人-世界/手眼标定问题，其中需要估计机器人和世界坐标系之间的变换以及安装在机器人末端执行器上的机器人夹爪（“手”）和相机（“眼”）之间的变换。![](pics/robot-world_hand-eye_figure.png) 标定过程如下：
    
    使用静态标定图案来估计目标坐标系和相机坐标系之间的变换。
    
    移动机器人夹爪以获取多个姿态。
    
    对于每个姿态，使用机器人运动学记录夹爪坐标系和机器人基座坐标系之间的齐次变换，例如 \( \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \)
    
    对于每个姿态，使用例如基于二维三维点对应关系的姿态估计方法（PnP）记录校准目标坐标系（世界坐标系）和相机坐标系之间的齐次变换： \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \)
    
    机器人-世界/手眼标定过程返回以下齐次变换： \( \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \) \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \) 这个问题也称为求解 \(\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\) 方程，其中
    
    \(\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\)
    
    \(\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\)
    
    \(\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\)
    
    \(\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\)
    
    注意：至少需要 3 个测量值（输入向量大小必须大于或等于 3）。
  - calibrateRobotWorldHandEye
```
public static void calibrateRobotWorldHandEye(java.util.List<Mat> R_world2cam,
                                              java.util.List<Mat> t_world2cam,
                                              java.util.List<Mat> R_base2gripper,
                                              java.util.List<Mat> t_base2gripper,
                                              Mat R_base2world,
                                              Mat t_base2world,
                                              Mat R_gripper2cam,
                                              Mat t_gripper2cam)
```
    计算机器人-世界/手眼标定：\(_{}^{w}\textrm{T}_b\) 和 \(_{}^{c}\textrm{T}_g\)
    参数
    
    R_world2cam - 从将世界坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_w\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从世界坐标系到相机坐标系的变换的旋转，(3x3)旋转矩阵或(3x1)旋转向量。
    
    t_world2cam - 从将世界坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_w\))中提取的平移部分。这是一个向量 (vector<Mat>)，包含所有从世界坐标系到相机坐标系的变换的(3x1)平移向量。
    
    R_base2gripper - 从将机器人基座坐标系中表示的点变换到夹爪坐标系的齐次矩阵(\(_{}^{g}\textrm{T}_b\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从机器人基座坐标系到夹爪坐标系的变换的旋转，(3x3)旋转矩阵或(3x1)旋转向量。
    
    t_base2gripper - 从将机器人基座坐标系中表示的点变换到夹爪坐标系的齐次矩阵(\(_{}^{g}\textrm{T}_b\))中提取的旋转部分。这是一个向量 (vector<Mat>)，包含所有从机器人基座坐标系到夹爪坐标系的变换的(3x1)平移向量。
    
    R_base2world - 从将机器人基座坐标系中表示的点变换到世界坐标系的齐次矩阵(\(_{}^{w}\textrm{T}_b\))中提取的估计的(3x3)旋转部分。
    
    t_base2world - 从将机器人基座坐标系中表示的点变换到世界坐标系的齐次矩阵(\(_{}^{w}\textrm{T}_b\))中提取的估计的(3x1)平移部分。
    
    R_gripper2cam - 从将夹爪坐标系中表示的点变换到相机坐标系的齐次矩阵(\(_{}^{c}\textrm{T}_g\))中提取的估计的(3x3)旋转部分。
    
    t_gripper2cam - 从将夹持器坐标系中表示的点转换为相机坐标系的齐次矩阵 (\(_{}^{c}\textrm{T}_g\)) 中提取的估计的 (3x1) 平移部分。该函数使用各种方法执行机器人-世界/手眼标定。一种方法包括先估计旋转然后估计平移（可分离解）
    
    M. Shah，使用克罗内克积求解机器人-世界/手眼标定问题 \cite Shah2013SolvingTR
    
    另一种方法包括同时估计旋转和平移（同时解），并使用以下实现方法：
    
    A. Li，L. Wang和D. Wu，使用对偶四元数和克罗内克积同时进行机器人-世界和手眼标定 \cite Li2010SimultaneousRA
    
    下图描述了机器人-世界/手眼标定问题，其中需要估计机器人和世界坐标系之间的变换以及安装在机器人末端执行器上的机器人夹爪（“手”）和相机（“眼”）之间的变换。![](pics/robot-world_hand-eye_figure.png) 标定过程如下：
    
    使用静态标定图案来估计目标坐标系和相机坐标系之间的变换。
    
    移动机器人夹爪以获取多个姿态。
    
    对于每个姿态，使用机器人运动学记录夹爪坐标系和机器人基座坐标系之间的齐次变换，例如 \( \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \)
    
    对于每个姿态，使用例如基于二维三维点对应关系的姿态估计方法（PnP）记录校准目标坐标系（世界坐标系）和相机坐标系之间的齐次变换： \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \)
    
    机器人-世界/手眼标定过程返回以下齐次变换： \( \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \) \( \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} = \begin{bmatrix} _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \) 这个问题也称为求解 \(\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\) 方程，其中
    
    \(\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\)
    
    \(\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\)
    
    \(\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\)
    
    \(\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\)
    
    注意：至少需要 3 个测量值（输入向量大小必须大于或等于 3）。
  - convertPointsToHomogeneous
```
public static void convertPointsToHomogeneous(Mat src,
                                              Mat dst)
```
    将点从欧几里德空间转换为齐次空间。
    
    参数
    
    src - N 维点的输入向量。
    
    dst - N+1 维点的输出向量。该函数通过将 1 附加到点坐标元组来将点从欧几里得空间转换为齐次空间。也就是说，每个点 (x1, x2, ..., xn) 都被转换为 (x1, x2, ..., xn, 1)。
  - convertPointsFromHomogeneous
```
public static void convertPointsFromHomogeneous(Mat src,
                                                Mat dst)
```
    将点从齐次空间转换为欧几里德空间。
    
    参数
    
    src - N 维点的输入向量。
    
    dst - N-1 维点的输出向量。该函数使用透视投影将点从齐次空间转换为欧几里得空间。也就是说，每个点 (x1, x2, ... x(n-1), xn) 都被转换为 (x1/xn, x2/xn, ..., x(n-1)/xn)。当 xn=0 时，输出点坐标将为 (0,0,0,...）。
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double ransacReprojThreshold,
                                     double confidence,
                                     int maxIters,
                                     Mat mask)
```
    根据两幅图像中对应的点计算基本矩阵。
    参数
    
    points1 - 第一张图像中 N 个点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    method - 计算基本矩阵的方法。
    
    参考：FM_7POINT 用于 7 点算法。(N = 7)
    
    参考：FM_8POINT 用于 8 点算法。(N ≥ 8)
    
    参考：FM_RANSAC 用于 RANSAC 算法。(N ≥ 8)
    
    参考：FM_LMEDS 用于 LMedS 算法。(N ≥ 8)
    
    ransacReprojThreshold - 仅用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    confidence - 仅用于 RANSAC 和 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    mask - 可选输出掩码
    
    maxIters - 鲁棒方法迭代的最大次数。极几何由以下等式描述：[p_2; 1]^T F [p_1; 1] = 0，其中 F 是基本矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。该函数使用上面列出的四种方法之一计算基本矩阵，并返回找到的基本矩阵。通常只找到一个矩阵。但是，对于 7 点算法，该函数最多可以返回 3 个解（9×3 矩阵，按顺序存储所有 3 个矩阵）。计算出的基本矩阵可以进一步传递给 #computeCorrespondEpilines 以查找与指定点对应的极线。它也可以传递给 #stereoRectifyUncalibrated 以计算校正变换。: // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } Mat fundamental_matrix = findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
    
    返回值
    
    自动生成
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double ransacReprojThreshold,
                                     double confidence,
                                     int maxIters)
```
    根据两幅图像中对应的点计算基本矩阵。
    参数
    
    points1 - 第一张图像中 N 个点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    method - 计算基本矩阵的方法。
    
    参考：FM_7POINT 用于 7 点算法。(N = 7)
    
    参考：FM_8POINT 用于 8 点算法。(N ≥ 8)
    
    参考：FM_RANSAC 用于 RANSAC 算法。(N ≥ 8)
    
    参考：FM_LMEDS 用于 LMedS 算法。(N ≥ 8)
    
    ransacReprojThreshold - 仅用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    confidence - 仅用于 RANSAC 和 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    maxIters - 鲁棒方法迭代的最大次数。极几何由以下等式描述：[p_2; 1]^T F [p_1; 1] = 0，其中 F 是基本矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。该函数使用上面列出的四种方法之一计算基本矩阵，并返回找到的基本矩阵。通常只找到一个矩阵。但是，对于 7 点算法，该函数最多可以返回 3 个解（9×3 矩阵，按顺序存储所有 3 个矩阵）。计算出的基本矩阵可以进一步传递给 #computeCorrespondEpilines 以查找与指定点对应的极线。它也可以传递给 #stereoRectifyUncalibrated 以计算校正变换。: // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } Mat fundamental_matrix = findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
    
    返回值
    
    自动生成
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double ransacReprojThreshold,
                                     double confidence,
                                     Mat mask)
```
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double ransacReprojThreshold,
                                     double confidence)
```
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double ransacReprojThreshold)
```
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method)
```
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2)
```
  - findFundamentalMat
```
public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     Mat mask,
                                     UsacParams params)
```
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix,
                                   int method,
                                   double prob,
                                   double threshold,
                                   int maxIters,
                                   Mat mask)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    mask - N 个元素的输出数组，其中每个元素对于离群值设置为 0，对于其他点设置为 1。仅在 RANSAC 和 LMedS 方法中计算此数组。
    
    maxIters - 鲁棒方法迭代的最大次数。此函数基于文献 CITE: Nister03 中的五点算法求解器估计本质矩阵。CITE: SteweniusCFS 也与之相关。极几何由以下等式描述：[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0，其中 E 是本质矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix,
                                   int method,
                                   double prob,
                                   double threshold,
                                   int maxIters)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算此数组。
    
    maxIters - 鲁棒方法迭代的最大次数。此函数基于文献 CITE: Nister03 中的五点算法求解器估计本质矩阵。CITE: SteweniusCFS 也与之相关。极几何由以下等式描述：[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0，其中 E 是本质矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix,
                                   int method,
                                   double prob,
                                   double threshold)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算此数组。此函数基于文献 CITE: Nister03 中的五点算法求解器估计本质矩阵。CITE: SteweniusCFS 也与之相关。极几何由以下等式描述：[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0，其中 E 是本质矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix,
                                   int method,
                                   double prob)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的期望置信度（概率）。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix,
                                   int method)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix)
```
    根据两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\) 。请注意，此函数假设 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果您的用例不符合此假设，请使用另一个函数重载或使用 P = cv::NoArray() 对两个相机使用 #undistortPoints 将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵有效。传递这些坐标时，请为此参数传递单位矩阵。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp,
                                   int method,
                                   double prob,
                                   double threshold,
                                   int maxIters,
                                   Mat mask)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    method - 计算基本矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    mask - N 个元素的输出数组，其中每个元素对于离群值设置为 0，对于其他点设置为 1。仅在 RANSAC 和 LMedS 方法中计算此数组。
    
    maxIters - 稳健方法迭代的最大次数。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp,
                                   int method,
                                   double prob,
                                   double threshold,
                                   int maxIters)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    method - 计算基本矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的期望置信度（概率）。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。
    
    maxIters - 稳健方法迭代的最大次数。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp,
                                   int method,
                                   double prob,
                                   double threshold)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    method - 计算基本矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的期望置信度（概率）。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp,
                                   int method,
                                   double prob)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    method - 计算基本矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的期望置信度（概率）。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp,
                                   int method)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    method - 计算基本矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。置信度（概率），即估计矩阵正确的概率。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal,
                                   Point pp)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。置信度（概率），即估计矩阵正确的概率。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   double focal)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。置信度（概率），即估计矩阵正确的概率。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2)
```
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 与 points1 大小和格式相同的第二张图像点的数组。是来自焦距和主点相同的相机的特征点。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。置信度（概率），即估计矩阵正确的概率。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数与上述函数的不同之处在于它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat distCoeffs1,
                                   Mat cameraMatrix2,
                                   Mat distCoeffs2,
                                   int method,
                                   double prob,
                                   double threshold,
                                   Mat mask)
```
    根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    cameraMatrix2 - 第二个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs1 - 第一个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    distCoeffs2 - 第二个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    mask - N 个元素的输出数组，其中每个元素对于离群值设置为 0，对于其他点设置为 1。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat distCoeffs1,
                                   Mat cameraMatrix2,
                                   Mat distCoeffs2,
                                   int method,
                                   double prob,
                                   double threshold)
```
    根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    cameraMatrix2 - 第二个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs1 - 第一个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    distCoeffs2 - 第二个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算此数组。此函数基于文献 CITE: Nister03 中的五点算法求解器估计本质矩阵。CITE: SteweniusCFS 也与之相关。极几何由以下等式描述：[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0，其中 E 是本质矩阵，p_1 和 p_2 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat distCoeffs1,
                                   Mat cameraMatrix2,
                                   Mat distCoeffs2,
                                   int method,
                                   double prob)
```
    根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    cameraMatrix2 - 第二个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs1 - 第一个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    distCoeffs2 - 第二个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的期望置信度（概率）。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat distCoeffs1,
                                   Mat cameraMatrix2,
                                   Mat distCoeffs2,
                                   int method)
```
    根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    cameraMatrix2 - 第二个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs1 - 第一个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    distCoeffs2 - 第二个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat distCoeffs1,
                                   Mat cameraMatrix2,
                                   Mat distCoeffs2)
```
    根据可能来自两个不同摄像机的两幅图像中对应的点计算本质矩阵。
    参数
    
    points1 - 第一张图像中 N (N >= 5) 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    cameraMatrix2 - 第二个相机的相机矩阵 \(K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs1 - 第一个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    distCoeffs2 - 第二个相机的畸变系数输入向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为空/NULL，则假设畸变系数为零。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。像素线，超出此线的点被认为是离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，可以将其设置为 1-3 之间的值。对于其他点。仅在 RANSAC 和 LMedS 方法中计算该数组。此函数基于文献 [Nister03] 中的五点算法求解器估计本质矩阵。文献 [SteweniusCFS] 也与之相关。对极几何由以下等式描述：\([p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\) 其中 \(E\) 是本质矩阵，\(p_1\) 和 \(p_2\) 分别是第一张和第二张图像中对应的点。此函数的结果可以进一步传递给 #decomposeEssentialMat 或 #recoverPose 以恢复相机之间的相对姿态。
    
    返回值
    
    自动生成
  - findEssentialMat
```
public static Mat findEssentialMat(Mat points1,
                                   Mat points2,
                                   Mat cameraMatrix1,
                                   Mat cameraMatrix2,
                                   Mat dist_coeff1,
                                   Mat dist_coeff2,
                                   Mat mask,
                                   UsacParams params)
```
  - decomposeEssentialMat
```
public static void decomposeEssentialMat(Mat E,
                                         Mat R1,
                                         Mat R2,
                                         Mat t)
```
    将本质矩阵分解为可能的旋转和平移。
    
    参数
    
    E - 输入本质矩阵。
    
    R1 - 一个可能的旋转矩阵。
    
    R2 - 另一个可能的旋转矩阵。
    
    t - 一个可能的平移向量。此函数使用 SVD 分解 [HartleyZ00] 对本质矩阵 E 进行分解。通常，E 的分解存在四种可能的姿态。它们是 \([R_1, t]\), \([R_1, -t]\), \([R_2, t]\), \([R_2, -t]\)。如果 E 给出图像点 \(p_1\)（在第一张图像中）和 \(p_2\)（在第二张图像中）之间的对极约束 \([p_2; 1]^T A^{-T} E A^{-1} [p_1; 1] = 0\)，则任何元组 \([R_1, t]\), \([R_1, -t]\), \([R_2, t]\), \([R_2, -t]\) 都是从第一个相机坐标系到第二个相机坐标系的基变换。但是，通过分解 E，只能获得平移的方向。因此，返回的平移向量 t 的长度为单位长度。
  - recoverPose
```
public static int recoverPose(Mat points1,
                              Mat points2,
                              Mat cameraMatrix1,
                              Mat distCoeffs1,
                              Mat cameraMatrix2,
                              Mat distCoeffs2,
                              Mat E,
                              Mat R,
                              Mat t,
                              int method,
                              double prob,
                              double threshold,
                              Mat mask)
```
    使用手性检验从两个不同相机的两张图像中对应的点恢复相对相机旋转和平移。返回通过检查的内点的数量。
    参数
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs2 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    E - 输出本质矩阵。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线的最大距离（以像素为单位），超过此距离的点将被视为离群值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果它不为空，则它标记给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。在输出掩码中，只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 输入：两个摄像机的摄像机标定，例如使用内参棋盘格标定。 Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2; // 输出：本质矩阵、相对旋转和相对平移。 Mat E, R, t, mask; recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat points1,
                              Mat points2,
                              Mat cameraMatrix1,
                              Mat distCoeffs1,
                              Mat cameraMatrix2,
                              Mat distCoeffs2,
                              Mat E,
                              Mat R,
                              Mat t,
                              int method,
                              double prob,
                              double threshold)
```
    使用手性检验从两个不同相机的两张图像中对应的点恢复相对相机旋转和平移。返回通过检查的内点的数量。
    参数
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs2 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    E - 输出本质矩阵。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）。
    
    threshold - 用于 RANSAC 的参数。它是点到极线（以像素为单位）的最大距离，超出此距离的点将被视为异常值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。points1 和 points2 中给定本质矩阵 E 的内点。只有这些内点将用于恢复姿态。在输出掩码中，只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 输入：两个摄像机的摄像机标定，例如使用内参棋盘格标定。 Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2; // 输出：本质矩阵、相对旋转和相对平移。 Mat E, R, t, mask; recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat points1,
                              Mat points2,
                              Mat cameraMatrix1,
                              Mat distCoeffs1,
                              Mat cameraMatrix2,
                              Mat distCoeffs2,
                              Mat E,
                              Mat R,
                              Mat t,
                              int method,
                              double prob)
```
    使用手性检验从两个不同相机的两张图像中对应的点恢复相对相机旋转和平移。返回通过检查的内点的数量。
    参数
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs2 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    E - 输出本质矩阵。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    prob - 仅用于 RANSAC 或 LMedS 方法的参数。它指定估计矩阵正确的理想置信度（概率）水平。点到极线（以像素为单位）的最大距离，超出此距离的点将被视为异常值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。points1 和 points2 中给定本质矩阵 E 的内点。只有这些内点将用于恢复姿态。在输出掩码中，只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 输入：两个摄像机的摄像机标定，例如使用内参棋盘格标定。 Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2; // 输出：本质矩阵、相对旋转和相对平移。 Mat E, R, t, mask; recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat points1,
                              Mat points2,
                              Mat cameraMatrix1,
                              Mat distCoeffs1,
                              Mat cameraMatrix2,
                              Mat distCoeffs2,
                              Mat E,
                              Mat R,
                              Mat t,
                              int method)
```
    使用手性检验从两个不同相机的两张图像中对应的点恢复相对相机旋转和平移。返回通过检查的内点的数量。
    参数
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs2 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    E - 输出本质矩阵。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    method - 计算本质矩阵的方法。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。点到极线（以像素为单位）的最大距离，超出此距离的点将被视为异常值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。points1 和 points2 中给定本质矩阵 E 的内点。只有这些内点将用于恢复姿态。在输出掩码中，只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 输入：两个摄像机的摄像机标定，例如使用内参棋盘格标定。 Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2; // 输出：本质矩阵、相对旋转和相对平移。 Mat E, R, t, mask; recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat points1,
                              Mat points2,
                              Mat cameraMatrix1,
                              Mat distCoeffs1,
                              Mat cameraMatrix2,
                              Mat distCoeffs2,
                              Mat E,
                              Mat R,
                              Mat t)
```
    使用手性检验从两个不同相机的两张图像中对应的点恢复相对相机旋转和平移。返回通过检查的内点的数量。
    参数
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix1 - 第一个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs1 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    cameraMatrix2 - 第二个摄像机的输入/输出摄像机矩阵，与 REF: calibrateCamera 中相同。此外，对于立体视觉的情况，可以使用附加标志，见下文。
    
    distCoeffs2 - 输入/输出畸变系数向量，与 REF: calibrateCamera 中相同。
    
    E - 输出本质矩阵。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    参考：RANSAC 用于 RANSAC 算法。
    
    参考：LMEDS 用于 LMedS 算法。
    
    置信度（概率），即估计矩阵正确的概率。点到极线（以像素为单位）的最大距离，超出此距离的点将被视为异常值，不会用于计算最终的基本矩阵。根据点定位精度、图像分辨率和图像噪声，它可以设置为 1-3 之类的值。points1 和 points2 中给定本质矩阵 E 的内点。只有这些内点将用于恢复姿态。在输出掩码中，只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 输入：两个摄像机的摄像机标定，例如使用内参棋盘格标定。 Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2; // 输出：本质矩阵、相对旋转和相对平移。 Mat E, R, t, mask; recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat cameraMatrix,
                              Mat R,
                              Mat t,
                              Mat mask)
```
    使用手性检查，从估计的本质矩阵和两幅图像中的对应点恢复相对相机旋转和平移。返回通过检查的内点数。
    
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \( \cameramatrix{A} \)。请注意，此函数假设 points1 和 points2 是具有相同相机内参矩阵的摄像机的特征点。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果它非空，则它标记给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化后的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 #findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 焦距均为 1，主点为 (0, 0) 的相机矩阵 Mat cameraMatrix = Mat::eye(3, 3, CV_64F); Mat E, R, t, mask; E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask); recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat cameraMatrix,
                              Mat R,
                              Mat t)
```
    使用手性检查，从估计的本质矩阵和两幅图像中的对应点恢复相对相机旋转和平移。返回通过检查的内点数。
    
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \( \cameramatrix{A} \)。请注意，此函数假设 points1 和 points2 是具有相同相机内参矩阵的摄像机的特征点。
    
    R - 输出旋转矩阵。与平移向量一起，该矩阵构成一个元组，该元组执行从第一个摄像机坐标系到第二个摄像机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面描述的参数。
    
    t - 输出平移向量。此向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向且长度为单位长度。给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本质矩阵，然后通过进行手性检查来验证可能的姿态假设。手性检查意味着三角化后的 3D 点应具有正深度。一些细节可以在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和掩码。在这种情况下，points1 和 points2 是 #findEssentialMat 的相同输入： // 示例。使用 RANSAC 算法估计基本矩阵 int point_count = 100; vector<Point2f> points1(point_count); vector<Point2f> points2(point_count); // 在此处初始化点 ... for( int i = 0; i < point_count; i++ ) { points1[i] = ...; points2[i] = ...; } // 焦距均为 1，主点为 (0, 0) 的相机矩阵 Mat cameraMatrix = Mat::eye(3, 3, CV_64F); Mat E, R, t, mask; E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask); recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat R,
                              Mat t,
                              double focal,
                              Point pp,
                              Mat mask)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果它非空，则它标记给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat R,
                              Mat t,
                              double focal,
                              Point pp)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。
    
    pp - 相机的主点。给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat R,
                              Mat t,
                              double focal)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    focal - 相机的焦距。请注意，此函数假设 points1 和 points2 是来自焦距和主点相同的相机的特征点。给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat R,
                              Mat t)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。此向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向且长度为单位长度。是来自焦距和主点相同的相机的特征点。给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它根据焦距和主点计算相机内参矩阵：\(A = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\)
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat cameraMatrix,
                              Mat R,
                              Mat t,
                              double distanceThresh,
                              Mat mask,
                              Mat triangulatedPoints)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \( \cameramatrix{A} \)。请注意，此函数假设 points1 和 points2 是具有相同相机内参矩阵的摄像机的特征点。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    distanceThresh - 用于过滤掉远点（即无限远点）的阈值距离。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果它非空，则它标记给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。
    
    triangulatedPoints - 通过三角化重建的 3D 点。此函数与上面的函数不同，它输出用于手性检查的三角化 3D 点。
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat cameraMatrix,
                              Mat R,
                              Mat t,
                              double distanceThresh,
                              Mat mask)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \( \cameramatrix{A} \)。请注意，此函数假设 points1 和 points2 是具有相同相机内参矩阵的摄像机的特征点。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    distanceThresh - 用于过滤掉远点（即无限远点）的阈值距离。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果它非空，则它标记给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它输出用于手性检查的三角化 3D 点。
    
    返回值
    
    自动生成
  - recoverPose
```
public static int recoverPose(Mat E,
                              Mat points1,
                              Mat points2,
                              Mat cameraMatrix,
                              Mat R,
                              Mat t,
                              double distanceThresh)
```
    参数
    
    E - 输入本质矩阵。
    
    points1 - 来自第一张图像的 N 个 2D 点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二张图像中与 points1 大小和格式相同的点数组。
    
    cameraMatrix - 相机内参矩阵 \( \cameramatrix{A} \)。请注意，此函数假设 points1 和 points2 是具有相同相机内参矩阵的摄像机的特征点。
    
    R - 输出旋转矩阵。此矩阵与平移向量一起构成一个元组，该元组执行从第一个相机坐标系到第二个相机坐标系的基变换。请注意，通常情况下，t 不能用于此元组，请参见下面的参数说明。
    
    t - 输出平移向量。该向量由 REF: decomposeEssentialMat 获得，因此仅在比例上已知，即 t 是平移向量的方向，长度为单位长度。
    
    distanceThresh - 用于过滤掉远点（即无限远点）的阈值距离。给定本质矩阵 E 的 points1 和 points2 中的内点。只有这些内点将用于恢复姿态。输出掩码中只有通过手性检查的内点。此函数与上面的函数不同，它输出用于手性检查的三角化 3D 点。
    
    返回值
    
    自动生成
  - computeCorrespondEpilines
```
public static void computeCorrespondEpilines(Mat points,
                                             int whichImage,
                                             Mat F,
                                             Mat lines)
```
    对于立体图像对中的一幅图像中的点，计算另一幅图像中对应的极线。
    
    参数
    
    points - 输入点。类型为 CV_32FC2 的 N×1 或 1×N 矩阵或 vector<Point2f>。
    
    whichImage - 包含点的图像索引 (1 或 2)。
    
    F - 基本矩阵，可以使用 #findFundamentalMat 或 #stereoRectify 估计。
    
    lines - 输出向量，包含对应于另一幅图像中点的极线。每条线 \(ax + by + c=0\) 由 3 个数字 \((a, b, c)\) 编码。对于立体图像对的两幅图像中的一幅图像中的每个点，该函数都会找到另一幅图像中对应极线的方程。从基本矩阵定义（见 #findFundamentalMat）来看，对于第一幅图像（当 whichImage=1 时）中的点 \(p^{(1)}_i\)，第二幅图像中的线 \(l^{(2)}_i\) 计算如下：\(l^{(2)}_i = F p^{(1)}_i\) 反之亦然，当 whichImage=2 时，\(l^{(1)}_i\) 从 \(p^{(2)}_i\) 计算如下：\(l^{(1)}_i = F^T p^{(2)}_i\) 线系数最多到一个比例因子。它们被归一化，使得 \(a_i^2+b_i^2=1\) 。
  - triangulatePoints
```
public static void triangulatePoints(Mat projMatr1,
                                     Mat projMatr2,
                                     Mat projPoints1,
                                     Mat projPoints2,
                                     Mat points4D)
```
    此函数使用立体摄像机观察到的点来重建三维点（齐次坐标）。
    
    参数
    
    projMatr1 - 第一个相机的 3x4 投影矩阵，即此矩阵将以世界坐标系给出的 3D 点投影到第一幅图像中。
    
    projMatr2 - 第二个相机的 3x4 投影矩阵，即此矩阵将以世界坐标系给出的 3D 点投影到第二幅图像中。
    
    projPoints1 - 第一张图像中 2xN 的特征点数组。对于 C++ 版本，它也可以是特征点的向量或大小为 1xN 或 Nx1 的双通道矩阵。
    
    projPoints2 - 第二张图像中对应点的 2xN 数组。对于 C++ 版本，它也可以是特征点的向量或大小为 1xN 或 Nx1 的双通道矩阵。
    
    points4D - 以齐次坐标重建的 4xN 点数组。这些点以世界坐标系返回。**注意：**请记住，为了使此函数正常工作，所有输入数据都应为浮点型。**注意：**如果使用 REF: stereoRectify 中的投影矩阵，则返回的点表示在第一个摄像机的校正坐标系中。参见：reprojectImageTo3D
  - correctMatches
```
public static void correctMatches(Mat F,
                                  Mat points1,
                                  Mat points2,
                                  Mat newPoints1,
                                  Mat newPoints2)
```
    细化对应点的坐标。
    
    参数
    
    F - 3x3 基本矩阵。
    
    points1 - 包含第一组点的 1xN 数组。
    
    points2 - 包含第二组点的 1xN 数组。
    
    newPoints1 - 优化后的 points1。
    
    newPoints2 - 优化后的 points2。该函数实现了最优三角测量方法（详情见 Multiple View Geometry CITE: HartleyZ00）。对于每个给定的点对应关系 points1[i] <-> points2[i] 和基本矩阵 F，它计算校正后的对应关系 newPoints1[i] <-> newPoints2[i]，以最小化几何误差 \(d(points1[i], newPoints1[i])^2 + d(points2[i],newPoints2[i])^2\)（其中 \(d(a,b)\) 是点 \(a\) 和 \(b\) 之间的几何距离），同时满足极线约束 \(newPoints2^T \cdot F \cdot newPoints1 = 0\) 。
  - filterSpeckles
```
public static void filterSpeckles(Mat img,
                                  double newVal,
                                  int maxSpeckleSize,
                                  double maxDiff,
                                  Mat buf)
```
    过滤视差图中小的噪点斑块（斑点）。
    
    参数
    
    img - 输入的 16 位有符号视差图像
    
    newVal - 用于去除斑点的视差值
    
    maxSpeckleSize - 将其视为斑点的最大斑点大小。较大的斑点不受算法影响
    
    maxDiff - 相邻视差像素之间的最大差异，将它们放入同一个斑点中。请注意，由于 StereoBM、StereoSGBM 和其他算法可能返回定点视差图，其中视差值乘以 16，因此在指定此参数值时应考虑此比例因子。
    
    buf - 可选的临时缓冲区，用于避免在函数内进行内存分配。
  - filterSpeckles
```
public static void filterSpeckles(Mat img,
                                  double newVal,
                                  int maxSpeckleSize,
                                  double maxDiff)
```
    过滤视差图中小的噪点斑块（斑点）。
    
    参数
    
    img - 输入的 16 位有符号视差图像
    
    newVal - 用于去除斑点的视差值
    
    maxSpeckleSize - 将其视为斑点的最大斑点大小。较大的斑点不受算法影响
    
    maxDiff - 相邻视差像素之间的最大差异，将它们放入同一个斑点中。请注意，由于 StereoBM、StereoSGBM 和其他算法可能返回定点视差图，其中视差值乘以 16，因此在指定此参数值时应考虑此比例因子。
  - getValidDisparityROI
```
public static Rect getValidDisparityROI(Rect roi1,
                                        Rect roi2,
                                        int minDisparity,
                                        int numberOfDisparities,
                                        int blockSize)
```
  - validateDisparity
```
public static void validateDisparity(Mat disparity,
                                     Mat cost,
                                     int minDisparity,
                                     int numberOfDisparities,
                                     int disp12MaxDisp)
```
  - validateDisparity
```
public static void validateDisparity(Mat disparity,
                                     Mat cost,
                                     int minDisparity,
                                     int numberOfDisparities)
```
  - reprojectImageTo3D
```
public static void reprojectImageTo3D(Mat disparity,
                                      Mat _3dImage,
                                      Mat Q,
                                      boolean handleMissingValues,
                                      int ddepth)
```
    将视差图像重新投影到3D空间。
    
    参数
    
    disparity - 输入单通道 8 位无符号、16 位有符号、32 位有符号或 32 位浮点视差图像。假设 8 位/16 位有符号格式的值没有小数位。如果视差是 16 位有符号格式，如 REF: StereoBM 或 REF: StereoSGBM 和其他算法计算的那样，则应将其除以 16（并缩放为浮点数）后再在此处使用。
    
    _3dImage - 与视差大小相同的输出 3 通道浮点图像。_3dImage(x,y) 的每个元素包含根据视差图计算的点 (x,y) 的 3D 坐标。如果使用 REF: stereoRectify 获得的 Q，则返回的点表示在第一个摄像机的校正坐标系中。
    
    Q - 可以使用 REF: stereoRectify 获得的 \(4 \times 4\) 透视变换矩阵。
    
    handleMissingValues - 指示函数是否应该处理缺失值（即未计算视差的点）。如果 handleMissingValues=true，则将对应于异常值的最小视差的像素转换为具有非常大的 Z 值的 3D 点（当前设置为 10000）。
    
    ddepth - 可选的输出数组深度。如果为 -1，则输出图像将具有 CV_32F 深度。ddepth 也可以设置为 CV_16S、CV_32S 或 CV_32F。该函数将单通道视差图转换为表示 3D 表面的 3 通道图像。也就是说，对于每个像素 (x,y) 和相应的视差 d=disparity(x,y)，它计算：\(\begin{bmatrix} X \\ Y \\ Z \\ W \end{bmatrix} = Q \begin{bmatrix} x \\ y \\ \texttt{disparity} (x,y) \\ 1 \end{bmatrix}.\) 参见：要将稀疏点集 {(x,y,d),...} 投影到 3D 空间，请使用 perspectiveTransform。
  - reprojectImageTo3D
```
public static void reprojectImageTo3D(Mat disparity,
                                      Mat _3dImage,
                                      Mat Q,
                                      boolean handleMissingValues)
```
    将视差图像重新投影到3D空间。
    
    参数
    
    disparity - 输入单通道 8 位无符号、16 位有符号、32 位有符号或 32 位浮点视差图像。假设 8 位/16 位有符号格式的值没有小数位。如果视差是 16 位有符号格式，如 REF: StereoBM 或 REF: StereoSGBM 和其他算法计算的那样，则应将其除以 16（并缩放为浮点数）后再在此处使用。
    
    _3dImage - 与视差大小相同的输出 3 通道浮点图像。_3dImage(x,y) 的每个元素包含根据视差图计算的点 (x,y) 的 3D 坐标。如果使用 REF: stereoRectify 获得的 Q，则返回的点表示在第一个摄像机的校正坐标系中。
    
    Q - 可以使用 REF: stereoRectify 获得的 \(4 \times 4\) 透视变换矩阵。
    
    handleMissingValues - 指示函数是否应该处理缺失值（即未计算视差的点）。如果 handleMissingValues=true，则将对应于异常值的最小视差的像素转换为具有非常大的 Z 值的 3D 点（当前设置为 10000）。深度。ddepth 也可以设置为 CV_16S、CV_32S 或 CV_32F。该函数将单通道视差图转换为表示 3D 表面的 3 通道图像。也就是说，对于每个像素 (x,y) 和相应的视差 d=disparity(x,y)，它计算：\(\begin{bmatrix} X \\ Y \\ Z \\ W \end{bmatrix} = Q \begin{bmatrix} x \\ y \\ \texttt{disparity} (x,y) \\ 1 \end{bmatrix}.\) 参见：要将稀疏点集 {(x,y,d),...} 投影到 3D 空间，请使用 perspectiveTransform。
  - reprojectImageTo3D
```
public static void reprojectImageTo3D(Mat disparity,
                                      Mat _3dImage,
                                      Mat Q)
```
    将视差图像重新投影到3D空间。
    
    参数
    
    disparity - 输入单通道 8 位无符号、16 位有符号、32 位有符号或 32 位浮点视差图像。假设 8 位/16 位有符号格式的值没有小数位。如果视差是 16 位有符号格式，如 REF: StereoBM 或 REF: StereoSGBM 和其他算法计算的那样，则应将其除以 16（并缩放为浮点数）后再在此处使用。
    
    _3dImage - 与视差大小相同的输出 3 通道浮点图像。_3dImage(x,y) 的每个元素包含根据视差图计算的点 (x,y) 的 3D 坐标。如果使用 REF: stereoRectify 获得的 Q，则返回的点表示在第一个摄像机的校正坐标系中。
    
    Q - 可以使用 REF: stereoRectify 获得的 \(4 \times 4\) 透视变换矩阵。未计算视差的点）。如果 handleMissingValues=true，则将对应于异常值的最小视差的像素转换为具有非常大的 Z 值的 3D 点（当前设置为 10000）。深度。ddepth 也可以设置为 CV_16S、CV_32S 或 CV_32F。该函数将单通道视差图转换为表示 3D 表面的 3 通道图像。也就是说，对于每个像素 (x,y) 和相应的视差 d=disparity(x,y)，它计算：\(\begin{bmatrix} X \\ Y \\ Z \\ W \end{bmatrix} = Q \begin{bmatrix} x \\ y \\ \texttt{disparity} (x,y) \\ 1 \end{bmatrix}.\) 参见：要将稀疏点集 {(x,y,d),...} 投影到 3D 空间，请使用 perspectiveTransform。
  - sampsonDistance
```
public static double sampsonDistance(Mat pt1,
                                     Mat pt2,
                                     Mat F)
```
    计算两点之间的 Sampson 距离。函数 cv::sampsonDistance 计算并返回几何误差的一阶近似值，如下所示：\( sd( \texttt{pt1} , \texttt{pt2} )= \frac{(\texttt{pt2}^t \cdot \texttt{F} \cdot \texttt{pt1})^2} {((\texttt{F} \cdot \texttt{pt1})(0))^2 + ((\texttt{F} \cdot \texttt{pt1})(1))^2 + ((\texttt{F}^t \cdot \texttt{pt2})(0))^2 + ((\texttt{F}^t \cdot \texttt{pt2})(1))^2} \) 可以使用 #findFundamentalMat 函数计算基本矩阵。详情见 CITE: HartleyZ00 11.4.3。
    
    参数
    
    pt1 - 第一个齐次 2d 点
    
    pt2 - 第二个齐次 2d 点
    
    F - 基本矩阵
    
    返回值
    
    计算出的 Sampson 距离。
  - estimateAffine3D
```
public static int estimateAffine3D(Mat src,
                                   Mat dst,
                                   Mat out,
                                   Mat inliers,
                                   double ransacThreshold,
                                   double confidence)
```
    计算两个 3D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12} & a_{13}\\ a_{21} & a_{22} & a_{23}\\ a_{31} & a_{32} & a_{33}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 输出 3D 仿射变换矩阵 \(3 \times 4\)，形式为 \( \begin{bmatrix} a_{11} & a_{12} & a_{13} & b_1\\ a_{21} & a_{22} & a_{23} & b_2\\ a_{31} & a_{32} & a_{33} & b_3\\ \end{bmatrix} \)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    ransacThreshold - RANSAC 算法中将点视为内点的最大重投影误差。
    
    confidence - 估计变换的置信度，介于 0 和 1 之间。通常 0.95 到 0.99 之间就足够了。太接近 1 的值会显著减慢估计速度。低于 0.8-0.9 的值可能会导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 仿射变换。
    
    返回值
    
    自动生成
  - estimateAffine3D
```
public static int estimateAffine3D(Mat src,
                                   Mat dst,
                                   Mat out,
                                   Mat inliers,
                                   double ransacThreshold)
```
    计算两个 3D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12} & a_{13}\\ a_{21} & a_{22} & a_{23}\\ a_{31} & a_{32} & a_{33}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 输出 3D 仿射变换矩阵 \(3 \times 4\)，形式为 \( \begin{bmatrix} a_{11} & a_{12} & a_{13} & b_1\\ a_{21} & a_{22} & a_{23} & b_2\\ a_{31} & a_{32} & a_{33} & b_3\\ \end{bmatrix} \)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    ransacThreshold - RANSAC 算法中将点视为内点的最大重投影误差。0.95 到 0.99 之间通常就足够了。太接近 1 的值会显著减慢估计速度。低于 0.8-0.9 的值可能会导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 仿射变换。
    
    返回值
    
    自动生成
  - estimateAffine3D
```
public static int estimateAffine3D(Mat src,
                                   Mat dst,
                                   Mat out,
                                   Mat inliers)
```
    计算两个 3D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12} & a_{13}\\ a_{21} & a_{22} & a_{23}\\ a_{31} & a_{32} & a_{33}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 输出 3D 仿射变换矩阵 \(3 \times 4\)，形式为 \( \begin{bmatrix} a_{11} & a_{12} & a_{13} & b_1\\ a_{21} & a_{22} & a_{23} & b_2\\ a_{31} & a_{32} & a_{33} & b_3\\ \end{bmatrix} \)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。内点。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 仿射变换。
    
    返回值
    
    自动生成
  - estimateAffine3D
```
public static Mat estimateAffine3D(Mat src,
                                   Mat dst,
                                   double[] scale,
                                   boolean force_rotation)
```
    计算两个 3D 点集之间的最优仿射变换。它计算最小化\(\sum{i} dst_i - c \cdot R \cdot src_i \) 的\(R,s,t\)，其中\(R\) 是一个 3x3 旋转矩阵，\(t\) 是一个 3x1 平移向量，\(s\) 是一个标量大小值。这是 Umeyama \cite umeyama1991least 算法的实现。估计的仿射变换具有齐次比例，它是具有 7 个自由度的仿射变换的子类。配对的点集至少需要包含 3 个点。
    
    参数
    
    src - 第一个输入 3D 点集。
    
    dst - 第二个输入 3D 点集。
    
    scale - 如果传入 null，则比例参数 c 将被假定为 1.0。否则，指向的变量将被设置为最佳比例。
    
    force_rotation - 如果为真，则返回的旋转永远不会是反射。这可能是不想要的，例如，当优化左右手坐标系之间的变换时。
    
    返回值
    
    形式为 \(T = \begin{bmatrix} R & t\\ \end{bmatrix}\) 的 3D 仿射变换矩阵 \(3 \times 4\)
  - estimateAffine3D
```
public static Mat estimateAffine3D(Mat src,
                                   Mat dst,
                                   double[] scale)
```
    计算两个 3D 点集之间的最优仿射变换。它计算最小化\(\sum{i} dst_i - c \cdot R \cdot src_i \) 的\(R,s,t\)，其中\(R\) 是一个 3x3 旋转矩阵，\(t\) 是一个 3x1 平移向量，\(s\) 是一个标量大小值。这是 Umeyama \cite umeyama1991least 算法的实现。估计的仿射变换具有齐次比例，它是具有 7 个自由度的仿射变换的子类。配对的点集至少需要包含 3 个点。
    
    参数
    
    src - 第一个输入 3D 点集。
    
    dst - 第二个输入 3D 点集。
    
    scale - 如果传入 null，则比例参数 c 将被假定为 1.0。否则，指向的变量将被设置为最佳比例。这可能是不想要的，例如，当优化左右手坐标系之间的变换时。
    
    返回值
    
    形式为 \(T = \begin{bmatrix} R & t\\ \end{bmatrix}\) 的 3D 仿射变换矩阵 \(3 \times 4\)
  - estimateAffine3D
```
public static Mat estimateAffine3D(Mat src,
                                   Mat dst)
```
    计算两个 3D 点集之间的最优仿射变换。它计算最小化\(\sum{i} dst_i - c \cdot R \cdot src_i \) 的\(R,s,t\)，其中\(R\) 是一个 3x3 旋转矩阵，\(t\) 是一个 3x1 平移向量，\(s\) 是一个标量大小值。这是 Umeyama \cite umeyama1991least 算法的实现。估计的仿射变换具有齐次比例，它是具有 7 个自由度的仿射变换的子类。配对的点集至少需要包含 3 个点。
    
    参数
    
    src - 第一个输入 3D 点集。
    
    dst - 第二个输入 3D 点集。否则，指向的变量将被设置为最佳比例。这可能是不想要的，例如，当优化左右手坐标系之间的变换时。
    
    返回值
    
    形式为 \(T = \begin{bmatrix} R & t\\ \end{bmatrix}\) 的 3D 仿射变换矩阵 \(3 \times 4\)
  - estimateTranslation3D
```
public static int estimateTranslation3D(Mat src,
                                        Mat dst,
                                        Mat out,
                                        Mat inliers,
                                        double ransacThreshold,
                                        double confidence)
```
    计算两个 3D 点集之间的最优平移。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 形式为 \( \begin{bmatrix} b_1 \\ b_2 \\ b_3 \\ \end{bmatrix} \) 的输出 3D 平移向量 \(3 \times 1\)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    ransacThreshold - RANSAC 算法中将点视为内点的最大重投影误差。
    
    confidence - 估计变换的置信度级别，介于 0 和 1 之间，0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 平移。
    
    返回值
    
    自动生成
  - estimateTranslation3D
```
public static int estimateTranslation3D(Mat src,
                                        Mat dst,
                                        Mat out,
                                        Mat inliers,
                                        double ransacThreshold)
```
    计算两个 3D 点集之间的最优平移。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 形式为 \( \begin{bmatrix} b_1 \\ b_2 \\ b_3 \\ \end{bmatrix} \) 的输出 3D 平移向量 \(3 \times 1\)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    ransacThreshold - RANSAC 算法中将点视为内点的最大重投影误差。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 平移。
    
    返回值
    
    自动生成
  - estimateTranslation3D
```
public static int estimateTranslation3D(Mat src,
                                        Mat dst,
                                        Mat out,
                                        Mat inliers)
```
    计算两个 3D 点集之间的最优平移。它计算 \( \begin{bmatrix} x\\ y\\ z\\ \end{bmatrix} = \begin{bmatrix} X\\ Y\\ Z\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ b_3\\ \end{bmatrix} \)
    
    参数
    
    src - 包含 \((X,Y,Z)\) 的第一个输入 3D 点集。
    
    dst - 包含 \((x,y,z)\) 的第二个输入 3D 点集。
    
    out - 形式为 \( \begin{bmatrix} b_1 \\ b_2 \\ b_3 \\ \end{bmatrix} \) 的输出 3D 平移向量 \(3 \times 1\)
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。内点。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。该函数使用 RANSAC 算法估计两个 3D 点集之间的最优 3D 平移。
    
    返回值
    
    自动生成
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers,
                                   int method,
                                   double ransacReprojThreshold,
                                   long maxIters,
                                   double confidence,
                                   long refineIters)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。
    
    confidence - 估计变换的置信度级别，介于 0 和 1 之间，0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。
    
    refineIters - 精化算法 (Levenberg-Marquardt) 的最大迭代次数。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers,
                                   int method,
                                   double ransacReprojThreshold,
                                   long maxIters,
                                   double confidence)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。
    
    confidence - 估计变换的置信度级别，介于 0 和 1 之间，0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers,
                                   int method,
                                   double ransacReprojThreshold,
                                   long maxIters)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers,
                                   int method,
                                   double ransacReprojThreshold)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers,
                                   int method)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to,
                                   Mat inliers)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点 (1-内点，0-外点)。
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat from,
                                   Mat to)
```
    计算两个 2D 点集之间的最优仿射变换。它计算 \( \begin{bmatrix} x\\ y\\ \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12}\\ a_{21} & a_{22}\\ \end{bmatrix} \begin{bmatrix} X\\ Y\\ \end{bmatrix} + \begin{bmatrix} b_1\\ b_2\\ \end{bmatrix} \)
    参数
    
    from - 包含 \((X,Y)\) 的第一个输入 2D 点集。
    
    to - 包含 \((x,y)\) 的第二个输入 2D 点集。
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出 2D 仿射变换矩阵 \(2 \times 3\) 或如果无法估计变换则为空矩阵。返回的矩阵具有以下形式：\( \begin{bmatrix} a_{11} & a_{12} & b_1\\ a_{21} & a_{22} & b_2\\ \end{bmatrix} \) 该函数使用选择的鲁棒算法估计两个 2D 点集之间的最优 2D 仿射变换。然后使用 Levenberg-Marquardt 方法进一步细化计算的变换（仅使用内点），以进一步减少重投影误差。注意：RANSAC 方法可以处理几乎任何比例的异常值，但需要一个阈值来区分内点和异常值。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffinePartial2D，getAffineTransform
  - estimateAffine2D
```
public static Mat estimateAffine2D(Mat pts1,
                                   Mat pts2,
                                   Mat inliers,
                                   UsacParams params)
```
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers,
                                          int method,
                                          double ransacReprojThreshold,
                                          long maxIters,
                                          double confidence,
                                          long refineIters)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。
    
    confidence - 估计变换的置信度级别，介于 0 和 1 之间，0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。
    
    refineIters - 精化算法 (Levenberg-Marquardt) 的最大迭代次数。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers,
                                          int method,
                                          double ransacReprojThreshold,
                                          long maxIters,
                                          double confidence)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。
    
    confidence - 估计变换的置信度级别，介于 0 和 1 之间，0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers,
                                          int method,
                                          double ransacReprojThreshold,
                                          long maxIters)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。
    
    maxIters - 鲁棒方法迭代的最大次数。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers,
                                          int method,
                                          double ransacReprojThreshold)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    ransacReprojThreshold - RANSAC 算法中将点视为内点的最大重投影误差。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers,
                                          int method)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    method - 用于计算变换的鲁棒方法。可能的算法如下：
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to,
                                          Mat inliers)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    inliers - 输出向量，指示哪些点是内点。
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - estimateAffinePartial2D
```
public static Mat estimateAffinePartial2D(Mat from,
                                          Mat to)
```
    计算两个二维点集之间具有4个自由度的最佳有限仿射变换。
    参数
    
    from - 第一个输入 2D 点集。
    
    to - 第二个输入 2D 点集。
    
    REF: RANSAC - 基于 RANSAC 的鲁棒方法
    
    REF: LMEDS - 最小中值鲁棒方法 RANSAC 为默认方法。
    
    将点视为内点。仅适用于 RANSAC。0.95 到 0.99 之间通常就足够好了。值过于接近 1 会显著减慢估计速度。值低于 0.8-0.9 可能导致变换估计错误。传递 0 将禁用精化，因此输出矩阵将是鲁棒方法的输出。
    
    返回值
    
    输出二维仿射变换（4自由度）矩阵 (2 × 3)，如果无法估计变换，则输出空矩阵。该函数估计最佳的二维仿射变换，其自由度限制为4，仅限于平移、旋转和均匀缩放的组合。使用选定的鲁棒估计算法。计算出的变换随后将使用 Levenberg-Marquardt 方法进一步细化（仅使用内点），以进一步减少重投影误差。估计的变换矩阵为：\( \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\ \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y \end{bmatrix} \) 其中 \( \theta \) 为旋转角，\( s \) 为缩放因子，\( t_x, t_y \) 分别为 \( x, y \) 轴上的平移量。注意：RANSAC 方法几乎可以处理任何比例的离群点，但需要一个阈值来区分内点和离群点。LMeDS 方法不需要任何阈值，但只有当内点超过 50% 时才能正确工作。参见：estimateAffine2D，getAffineTransform
  - decomposeHomographyMat
```
public static int decomposeHomographyMat(Mat H,
                                         Mat K,
                                         java.util.List<Mat> rotations,
                                         java.util.List<Mat> translations,
                                         java.util.List<Mat> normals)
```
    将单应性矩阵分解为旋转、平移和平面法向量。
    
    参数
    
    H - 两幅图像之间的输入单应性矩阵。
    
    K - 输入相机内参矩阵。
    
    rotations - 旋转矩阵数组。
    
    translations - 平移矩阵数组。
    
    normals - 平面法向量矩阵数组。此函数提取平面物体的两个视图之间的相对相机运动，并返回最多四个旋转、平移和平面法向量的数学解元组。单应性矩阵 H 的分解在 CITE: Malis2007 中有详细描述。如果由平面引起的单应性 H 给出约束 \(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\) 在源图像点 \(p_i\) 和目标图像点 \(p'_i\) 上，则 rotations[k] 和 translations[k] 的元组是从源相机的坐标系到目标相机的坐标系的基变换。但是，通过分解 H，只能得到被场景深度（通常未知）归一化的平移，即它的方向，但长度是归一化的。如果点对应可用，则可以通过应用正深度约束来进一步使至少两个解失效，即所有点必须位于相机前方。
    
    返回值
    
    自动生成
  - filterHomographyDecompByVisibleRefpoints
```
public static void filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations,
                                                            java.util.List<Mat> normals,
                                                            Mat beforePoints,
                                                            Mat afterPoints,
                                                            Mat possibleSolutions,
                                                            Mat pointsMask)
```
    基于额外信息过滤单应性分解。
    
    参数
    
    rotations - 旋转矩阵向量。
    
    normals - 平面法向量矩阵向量。
    
    beforePoints - 应用单应性变换之前（已校正的）可见参考点向量。
    
    afterPoints - 应用单应性变换之后（已校正的）可见参考点向量。
    
    possibleSolutions - 表示过滤后可行解集的整数索引向量。
    
    pointsMask - 可选的 Mat/Vector，类型为 8u，表示由 #findHomography 函数给出的内点掩码。此函数旨在根据 CITE: Malis2007 中描述的附加信息过滤 #decomposeHomographyMat 的输出。该方法的概要：#decomposeHomographyMat 函数返回 2 个唯一解及其“反解”，总共 4 个解。如果我们可以访问在应用单应性变换之前和之后在相机帧中可见的点集，则可以通过验证哪些单应性与所有可见参考点位于相机前方一致来确定哪些是真正的潜在解，哪些是反解。输入保持不变；过滤后的解集作为现有解集的索引返回。
  - filterHomographyDecompByVisibleRefpoints
```
public static void filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations,
                                                            java.util.List<Mat> normals,
                                                            Mat beforePoints,
                                                            Mat afterPoints,
                                                            Mat possibleSolutions)
```
    基于额外信息过滤单应性分解。
    
    参数
    
    rotations - 旋转矩阵向量。
    
    normals - 平面法向量矩阵向量。
    
    beforePoints - 应用单应性变换之前（已校正的）可见参考点向量。
    
    afterPoints - 应用单应性变换之后（已校正的）可见参考点向量。
    
    possibleSolutions - 表示过滤后可行解集的整数索引向量。此函数旨在根据 CITE: Malis2007 中描述的附加信息过滤 #decomposeHomographyMat 的输出。该方法的概要：#decomposeHomographyMat 函数返回 2 个唯一解及其“反解”，总共 4 个解。如果我们可以访问在应用单应性变换之前和之后在相机帧中可见的点集，则可以通过验证哪些单应性与所有可见参考点位于相机前方一致来确定哪些是真正的潜在解，哪些是反解。输入保持不变；过滤后的解集作为现有解集的索引返回。
  - undistort
```
public static void undistort(Mat src,
                             Mat dst,
                             Mat cameraMatrix,
                             Mat distCoeffs,
                             Mat newCameraMatrix)
```
    变换图像以补偿镜头畸变。该函数变换图像以补偿径向和切向镜头畸变。该函数只是 #initUndistortRectifyMap（具有单位 R）和 #remap（使用双线性插值）的组合。有关所执行变换的详细信息，请参见前一个函数。目标图像中没有对应源图像像素的像素将填充零（黑色）。可以通过 newCameraMatrix 来调整将在校正图像中可见的源图像的特定子集。您可以使用 #getOptimalNewCameraMatrix 根据您的要求计算合适的 newCameraMatrix。相机矩阵和畸变参数可以使用 #calibrateCamera 确定。如果图像的分辨率与校准阶段使用的分辨率不同，则需要相应地缩放 \(f_x, f_y, c_x\) 和 \(c_y\)，而畸变系数保持不变。
    
    参数
    
    src - 输入（畸变）图像。
    
    dst - 输出（校正）图像，大小和类型与 src 相同。
    
    cameraMatrix - 输入相机矩阵 \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。
    
    newCameraMatrix - 畸变图像的相机矩阵。默认情况下，它与 cameraMatrix 相同，但您可以通过使用不同的矩阵来额外缩放和移动结果。
  - undistort
```
public static void undistort(Mat src,
                             Mat dst,
                             Mat cameraMatrix,
                             Mat distCoeffs)
```
    变换图像以补偿镜头畸变。该函数变换图像以补偿径向和切向镜头畸变。该函数只是 #initUndistortRectifyMap（具有单位 R）和 #remap（使用双线性插值）的组合。有关所执行变换的详细信息，请参见前一个函数。目标图像中没有对应源图像像素的像素将填充零（黑色）。可以通过 newCameraMatrix 来调整将在校正图像中可见的源图像的特定子集。您可以使用 #getOptimalNewCameraMatrix 根据您的要求计算合适的 newCameraMatrix。相机矩阵和畸变参数可以使用 #calibrateCamera 确定。如果图像的分辨率与校准阶段使用的分辨率不同，则需要相应地缩放 \(f_x, f_y, c_x\) 和 \(c_y\)，而畸变系数保持不变。
    
    参数
    
    src - 输入（畸变）图像。
    
    dst - 输出（校正）图像，大小和类型与 src 相同。
    
    cameraMatrix - 输入相机矩阵 \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。cameraMatrix，但您可以通过使用不同的矩阵来额外缩放和移动结果。
  - initUndistortRectifyMap
```
public static void initUndistortRectifyMap(Mat cameraMatrix,
                                           Mat distCoeffs,
                                           Mat R,
                                           Mat newCameraMatrix,
                                           Size size,
                                           int m1type,
                                           Mat map1,
                                           Mat map2)
```
    计算畸变校正和校正变换映射。该函数计算联合畸变校正和校正变换，并以#remap的映射形式表示结果。校正后的图像看起来像原始图像，就好像它是使用摄像机矩阵 =newCameraMatrix 和零畸变的摄像机拍摄的一样。对于单目相机，newCameraMatrix 通常等于 cameraMatrix，或者可以使用 #getOptimalNewCameraMatrix 计算以更好地控制缩放。对于立体相机，newCameraMatrix 通常设置为由 #stereoRectify 计算的 P1 或 P2。此外，这个新的相机在坐标空间中的方向也根据 R 不同。例如，这有助于对齐立体相机的两个头部，以便两个图像上的极线变为水平线并具有相同的 y 坐标（对于水平对齐的立体相机）。该函数实际上构建了由 #remap 使用的反向映射算法的映射。也就是说，对于目标（校正后的）图像中的每个像素\((u, v)\)，该函数计算源图像（即相机中的原始图像）中的对应坐标。应用以下过程：\( \begin{array}{l} x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\ {[X\,Y\,W]} ^T \leftarrow R^{-1}*[x \, y \, 1]^T \\ x' \leftarrow X/W \\ y' \leftarrow Y/W \\ r^2 \leftarrow x'^2 + y'^2 \\ x'' \leftarrow x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2p_1 x' y' + p_2(r^2 + 2 x'^2) + s_1 r^2 + s_2 r^4\\ y'' \leftarrow y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\ s\vecthree{x'''}{y'''}{1} = \vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}((\tau_x, \tau_y)} {0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)} {0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\\ map_x(u,v) \leftarrow x''' f_x + c_x \\ map_y(u,v) \leftarrow y''' f_y + c_y \end{array} \) 其中 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) 是畸变系数。对于立体相机，此函数调用两次：一次用于每个相机头部，在 #stereoRectify 之后，而 #stereoRectify 又在 #stereoCalibrate 之后调用。但是，如果立体相机未校准，则仍然可以使用 #stereoRectifyUncalibrated 直接从基本矩阵计算校正变换。对于每个相机，该函数计算单应性 H 作为像素域中的校正变换，而不是 3D 空间中的旋转矩阵 R。R 可以从 H 计算为 \(\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\)，其中 cameraMatrix 可以任意选择。
    
    参数
    
    cameraMatrix - 输入相机矩阵 \(A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。
    
    R - 对象空间中的可选校正变换（3x3 矩阵）。可以在这里传递由 #stereoRectify 计算的 R1 或 R2。如果矩阵为空，则假定为单位变换。在 #initUndistortRectifyMap 中，R 假设为单位矩阵。
    
    newCameraMatrix - 新的相机矩阵 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\) 。
    
    size - 校正后图像大小。
    
    m1type - 第一个输出映射的类型，可以是 CV_32FC1、CV_32FC2 或 CV_16SC2，参见 #convertMaps
    
    map1 - 第一个输出映射。
    
    map2 - 第二个输出映射。
  - initInverseRectificationMap
```
public static void initInverseRectificationMap(Mat cameraMatrix,
                                               Mat distCoeffs,
                                               Mat R,
                                               Mat newCameraMatrix,
                                               Size size,
                                               int m1type,
                                               Mat map1,
                                               Mat map2)
```
    计算投影和逆校正变换映射。从本质上讲，这是 #initUndistortRectifyMap 的逆运算，用于适应投影仪-相机对中投影仪（“逆相机”）的立体校正。该函数计算联合投影和逆校正变换，并以 #remap 的映射形式表示结果。投影图像看起来像原始图像的畸变版本，一旦由投影仪投影，应该在视觉上与原始图像匹配。对于单目相机，newCameraMatrix 通常等于 cameraMatrix，或者可以使用 #getOptimalNewCameraMatrix 计算以更好地控制缩放。对于投影仪-相机对，newCameraMatrix 通常设置为由 #stereoRectify 计算的 P1 或 P2。投影仪在坐标空间中的方向根据 R 不同。对于投影仪-相机对，这有助于对齐投影仪（与相机 #initUndistortRectifyMap 的方式相同）以创建立体校正对。这允许两个图像上的极线变为水平线并具有相同的 y 坐标（对于水平对齐的投影仪-相机对）。该函数为 #remap 使用的反向映射算法构建映射。也就是说，对于目标（投影和逆校正）图像中的每个像素\((u, v)\)，该函数计算源图像（即原始数字图像）中的对应坐标。应用以下过程：\( \begin{array}{l} \text{newCameraMatrix}\\ x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\ \\\text{畸变校正} \\\scriptsize{\textit{尽管显示的公式是用于径向畸变校正，但函数实现了 cv::undistortPoints()}}\\ r^2 \leftarrow x^2 + y^2 \\ \theta \leftarrow \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}\\ x' \leftarrow \frac{x}{\theta} \\ y' \leftarrow \frac{y}{\theta} \\ \\\text{校正}\\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x'' \leftarrow X/W \\ y'' \leftarrow Y/W \\ \\\text{cameraMatrix}\\ map_x(u,v) \leftarrow x'' f_x + c_x \\ map_y(u,v) \leftarrow y'' f_y + c_y \end{array} \) 其中 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) 是畸变系数向量 distCoeffs。对于立体校正的投影仪-相机对，此函数用于投影仪，而 #initUndistortRectifyMap 用于相机头部。这在 #stereoRectify 之后完成，而 #stereoRectify 又在 #stereoCalibrate 之后调用。如果投影仪-相机对未校准，则仍然可以使用 #stereoRectifyUncalibrated 直接从基本矩阵计算校正变换。对于投影仪和相机，该函数计算单应性 H 作为像素域中的校正变换，而不是 3D 空间中的旋转矩阵 R。R 可以从 H 计算为 \(\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\)，其中 cameraMatrix 可以任意选择。
    
    参数
    
    cameraMatrix - 输入相机矩阵 \(A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。
    
    R - 对象空间中的可选校正变换（3x3 矩阵）。可以在这里传递由 #stereoRectify 计算的 R1 或 R2。如果矩阵为空，则假定为单位变换。
    
    newCameraMatrix - 新的相机矩阵 \(A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\) 。
    
    size - 畸变图像大小。
    
    m1type - 第一个输出映射的类型。可以是 CV_32FC1、CV_32FC2 或 CV_16SC2，参见 #convertMaps
    
    map1 - 用于 #remap 的第一个输出映射。
    
    map2 - 用于 #remap 的第二个输出映射。
  - getDefaultNewCameraMatrix
```
public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix,
                                            Size imgsize,
                                            boolean centerPrincipalPoint)
```
    返回默认的新相机矩阵。该函数返回相机矩阵，该矩阵要么是输入 cameraMatrix 的精确副本（当 centerPrinicipalPoint=false 时），要么是修改后的矩阵（当 centerPrincipalPoint=true 时）。在后一种情况下，新的相机矩阵将是：\(\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5 \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5 \\ 0 && 0 && 1 \end{bmatrix} ,\) 其中 \(f_x\) 和 \(f_y\) 分别是 cameraMatrix 的 \((0,0)\) 和 \((1,1)\) 元素。默认情况下，OpenCV 中的畸变校正函数（参见 #initUndistortRectifyMap，#undistort）不会移动主点。但是，当您使用立体视觉时，将两个视图中的主点移动到相同的 y 坐标（大多数立体匹配算法都需要）非常重要，也可能需要移动到相同的 x 坐标。因此，您可以为每个视图形成新的相机矩阵，其中主点位于中心。
    
    参数
    
    cameraMatrix - 输入相机矩阵。
    
    imgsize - 相机视图图像大小（像素）。
    
    centerPrincipalPoint - 新相机矩阵中主点的位置。该参数指示此位置是否应该位于图像中心。
    
    返回值
    
    自动生成
  - getDefaultNewCameraMatrix
```
public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix,
                                            Size imgsize)
```
    返回默认的新相机矩阵。该函数返回相机矩阵，该矩阵要么是输入 cameraMatrix 的精确副本（当 centerPrinicipalPoint=false 时），要么是修改后的矩阵（当 centerPrincipalPoint=true 时）。在后一种情况下，新的相机矩阵将是：\(\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5 \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5 \\ 0 && 0 && 1 \end{bmatrix} ,\) 其中 \(f_x\) 和 \(f_y\) 分别是 cameraMatrix 的 \((0,0)\) 和 \((1,1)\) 元素。默认情况下，OpenCV 中的畸变校正函数（参见 #initUndistortRectifyMap，#undistort）不会移动主点。但是，当您使用立体视觉时，将两个视图中的主点移动到相同的 y 坐标（大多数立体匹配算法都需要）非常重要，也可能需要移动到相同的 x 坐标。因此，您可以为每个视图形成新的相机矩阵，其中主点位于中心。
    
    参数
    
    cameraMatrix - 输入相机矩阵。
    
    imgsize - 相机视图图像大小（像素）。参数指示此位置是否应该位于图像中心。
    
    返回值
    
    自动生成
  - getDefaultNewCameraMatrix
```
public static Mat getDefaultNewCameraMatrix(Mat cameraMatrix)
```
    返回默认的新相机矩阵。该函数返回相机矩阵，该矩阵要么是输入 cameraMatrix 的精确副本（当 centerPrinicipalPoint=false 时），要么是修改后的矩阵（当 centerPrincipalPoint=true 时）。在后一种情况下，新的相机矩阵将是：\(\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5 \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5 \\ 0 && 0 && 1 \end{bmatrix} ,\) 其中 \(f_x\) 和 \(f_y\) 分别是 cameraMatrix 的 \((0,0)\) 和 \((1,1)\) 元素。默认情况下，OpenCV 中的畸变校正函数（参见 #initUndistortRectifyMap，#undistort）不会移动主点。但是，当您使用立体视觉时，将两个视图中的主点移动到相同的 y 坐标（大多数立体匹配算法都需要）非常重要，也可能需要移动到相同的 x 坐标。因此，您可以为每个视图形成新的相机矩阵，其中主点位于中心。
    
    参数
    
    cameraMatrix - 输入相机矩阵。参数指示此位置是否应该位于图像中心。
    
    返回值
    
    自动生成
  - undistortPoints
```
public static void undistortPoints(MatOfPoint2f src,
                                   MatOfPoint2f dst,
                                   Mat cameraMatrix,
                                   Mat distCoeffs,
                                   Mat R,
                                   Mat P)
```
    根据观察到的点坐标计算理想的点坐标。该函数类似于 #undistort 和 #initUndistortRectifyMap，但它操作的是稀疏点集而不是栅格图像。该函数还执行 #projectPoints 的反向变换。对于 3D 对象，它不会重建其 3D 坐标，但对于平面对象，如果指定了正确的 R，则可以重建其坐标（直至平移向量）。对于每个观察到的点坐标 \((u, v)\)，函数计算：\( \begin{array}{l} x^{"} \leftarrow (u - c_x)/f_x \\ y^{"} \leftarrow (v - c_y)/f_y \\ (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x \leftarrow X/W \\ y \leftarrow Y/W \\ \text{仅当指定 P 时执行：} \\ u' \leftarrow x {f'}_x + {c'}_x \\ v' \leftarrow y {f'}_y + {c'}_y \end{array} \) 其中 *undistort* 是一个近似的迭代算法，它根据归一化畸变点坐标估算归一化原始点坐标（“归一化”表示坐标不依赖于相机矩阵）。该函数可用于立体摄像机或单目相机（当 R 为空时）。
    
    参数
    
    src - 观察到的点坐标，2xN/Nx2 单通道或 1xN/Nx1 双通道 (CV_32FC2 或 CV_64FC2)（或 vector<Point2f>）。
    
    dst - 畸变校正和反透视变换后的输出理想点坐标（1xN/Nx1 双通道或 vector<Point2f>）。如果矩阵 P 为单位矩阵或省略，则 dst 将包含归一化点坐标。
    
    cameraMatrix - 相机矩阵 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。
    
    R - 对象空间中的校正变换（3x3 矩阵）。可以将 #stereoRectify 计算的 R1 或 R2 传递到这里。如果矩阵为空，则使用单位变换。
    
    P - 新相机矩阵（3x3）或新的投影矩阵（3x4）\(\begin{bmatrix} {f'}_x & 0 & {c'}_x & t_x \\ 0 & {f'}_y & {c'}_y & t_y \\ 0 & 0 & 1 & t_z \end{bmatrix}\)。可以将 #stereoRectify 计算的 P1 或 P2 传递到这里。如果矩阵为空，则使用单位新相机矩阵。
  - undistortPoints
```
public static void undistortPoints(MatOfPoint2f src,
                                   MatOfPoint2f dst,
                                   Mat cameraMatrix,
                                   Mat distCoeffs,
                                   Mat R)
```
    根据观察到的点坐标计算理想的点坐标。该函数类似于 #undistort 和 #initUndistortRectifyMap，但它操作的是稀疏点集而不是栅格图像。该函数还执行 #projectPoints 的反向变换。对于 3D 对象，它不会重建其 3D 坐标，但对于平面对象，如果指定了正确的 R，则可以重建其坐标（直至平移向量）。对于每个观察到的点坐标 \((u, v)\)，函数计算：\( \begin{array}{l} x^{"} \leftarrow (u - c_x)/f_x \\ y^{"} \leftarrow (v - c_y)/f_y \\ (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x \leftarrow X/W \\ y \leftarrow Y/W \\ \text{仅当指定 P 时执行：} \\ u' \leftarrow x {f'}_x + {c'}_x \\ v' \leftarrow y {f'}_y + {c'}_y \end{array} \) 其中 *undistort* 是一个近似的迭代算法，它根据归一化畸变点坐标估算归一化原始点坐标（“归一化”表示坐标不依赖于相机矩阵）。该函数可用于立体摄像机或单目相机（当 R 为空时）。
    
    参数
    
    src - 观察到的点坐标，2xN/Nx2 单通道或 1xN/Nx1 双通道 (CV_32FC2 或 CV_64FC2)（或 vector<Point2f>）。
    
    dst - 畸变校正和反透视变换后的输出理想点坐标（1xN/Nx1 双通道或 vector<Point2f>）。如果矩阵 P 为单位矩阵或省略，则 dst 将包含归一化点坐标。
    
    cameraMatrix - 相机矩阵 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。
    
    R - 对象空间中的校正变换（3x3 矩阵）。可以将 #stereoRectify 计算的 R1 或 R2 传递到这里。如果矩阵为空，则使用单位变换。 #stereoRectify 可以传递到这里。如果矩阵为空，则使用单位新相机矩阵。
  - undistortPoints
```
public static void undistortPoints(MatOfPoint2f src,
                                   MatOfPoint2f dst,
                                   Mat cameraMatrix,
                                   Mat distCoeffs)
```
    根据观察到的点坐标计算理想的点坐标。该函数类似于 #undistort 和 #initUndistortRectifyMap，但它操作的是稀疏点集而不是栅格图像。该函数还执行 #projectPoints 的反向变换。对于 3D 对象，它不会重建其 3D 坐标，但对于平面对象，如果指定了正确的 R，则可以重建其坐标（直至平移向量）。对于每个观察到的点坐标 \((u, v)\)，函数计算：\( \begin{array}{l} x^{"} \leftarrow (u - c_x)/f_x \\ y^{"} \leftarrow (v - c_y)/f_y \\ (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\ {[X\,Y\,W]} ^T \leftarrow R*[x' \, y' \, 1]^T \\ x \leftarrow X/W \\ y \leftarrow Y/W \\ \text{仅当指定 P 时执行：} \\ u' \leftarrow x {f'}_x + {c'}_x \\ v' \leftarrow y {f'}_y + {c'}_y \end{array} \) 其中 *undistort* 是一个近似的迭代算法，它根据归一化畸变点坐标估算归一化原始点坐标（“归一化”表示坐标不依赖于相机矩阵）。该函数可用于立体摄像机或单目相机（当 R 为空时）。
    
    参数
    
    src - 观察到的点坐标，2xN/Nx2 单通道或 1xN/Nx1 双通道 (CV_32FC2 或 CV_64FC2)（或 vector<Point2f>）。
    
    dst - 畸变校正和反透视变换后的输出理想点坐标（1xN/Nx1 双通道或 vector<Point2f>）。如果矩阵 P 为单位矩阵或省略，则 dst 将包含归一化点坐标。
    
    cameraMatrix - 相机矩阵 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 输入畸变系数向量 \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\) ，包含 4、5、8、12 或 14 个元素。如果向量为 NULL/空，则假定为零畸变系数。 #stereoRectify 可以传递到这里。如果矩阵为空，则使用单位变换。 #stereoRectify 可以传递到这里。如果矩阵为空，则使用单位新相机矩阵。
  - undistortPointsIter
```
public static void undistortPointsIter(Mat src,
                                       Mat dst,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       Mat R,
                                       Mat P,
                                       TermCriteria criteria)
```
    注意： #undistortPoints 的默认版本进行 5 次迭代来计算未失真点。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    cameraMatrix - 自动生成
    
    distCoeffs - 自动生成
    
    R - 自动生成
    
    P - 自动生成
    
    criteria - 自动生成
  - undistortImagePoints
```
public static void undistortImagePoints(Mat src,
                                        Mat dst,
                                        Mat cameraMatrix,
                                        Mat distCoeffs,
                                        TermCriteria arg1)
```
    计算未失真的图像点位置
    
    参数
    
    src - 观察到的点位置，2xN/Nx2 单通道或 1xN/Nx1 双通道 (CV_32FC2 或 CV_64FC2)（或 vector<Point2f>）。
    
    dst - 输出的未畸变点位置（1xN/Nx1 双通道或 vector<Point2f>）。
    
    cameraMatrix - 相机矩阵 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 畸变系数
    
    arg1 - 自动生成
  - undistortImagePoints
```
public static void undistortImagePoints(Mat src,
                                        Mat dst,
                                        Mat cameraMatrix,
                                        Mat distCoeffs)
```
    计算未失真的图像点位置
    
    参数
    
    src - 观察到的点位置，2xN/Nx2 单通道或 1xN/Nx1 双通道 (CV_32FC2 或 CV_64FC2)（或 vector<Point2f>）。
    
    dst - 输出的未畸变点位置（1xN/Nx1 双通道或 vector<Point2f>）。
    
    cameraMatrix - 相机矩阵 \(\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) 。
    
    distCoeffs - 畸变系数
  - fisheye_projectPoints
```
public static void fisheye_projectPoints(Mat objectPoints,
                                         Mat imagePoints,
                                         Mat rvec,
                                         Mat tvec,
                                         Mat K,
                                         Mat D,
                                         double alpha,
                                         Mat jacobian)
```
  - fisheye_projectPoints
```
public static void fisheye_projectPoints(Mat objectPoints,
                                         Mat imagePoints,
                                         Mat rvec,
                                         Mat tvec,
                                         Mat K,
                                         Mat D,
                                         double alpha)
```
  - fisheye_projectPoints
```
public static void fisheye_projectPoints(Mat objectPoints,
                                         Mat imagePoints,
                                         Mat rvec,
                                         Mat tvec,
                                         Mat K,
                                         Mat D)
```
  - fisheye_distortPoints
```
public static void fisheye_distortPoints(Mat undistorted,
                                         Mat distorted,
                                         Mat K,
                                         Mat D,
                                         double alpha)
```
    使用鱼眼模型扭曲二维点。
    
    参数
    
    undistorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    alpha - 倾斜系数。
    
    distorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。请注意，该函数假设未畸变点的相机内参矩阵为单位矩阵。这意味着如果您想扭曲图像点，则必须将它们乘以 \(K^{-1}\) 或使用另一个函数重载。
  - fisheye_distortPoints
```
public static void fisheye_distortPoints(Mat undistorted,
                                         Mat distorted,
                                         Mat K,
                                         Mat D)
```
    使用鱼眼模型扭曲二维点。
    
    参数
    
    undistorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    distorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。请注意，该函数假设未畸变点的相机内参矩阵为单位矩阵。这意味着如果您想扭曲图像点，则必须将它们乘以 \(K^{-1}\) 或使用另一个函数重载。
  - fisheye_distortPoints
```
public static void fisheye_distortPoints(Mat undistorted,
                                         Mat distorted,
                                         Mat Kundistorted,
                                         Mat K,
                                         Mat D,
                                         double alpha)
```
    distortPoints 函数的重载，用于处理未畸变点使用非单位相机矩阵获得的情况，例如 #estimateNewCameraMatrixForUndistortRectify 的输出。
    
    参数
    
    undistorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    Kundistorted - 用作畸变校正新相机矩阵的相机内参矩阵。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    alpha - 倾斜系数。
    
    distorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。参见：estimateNewCameraMatrixForUndistortRectify
  - fisheye_distortPoints
```
public static void fisheye_distortPoints(Mat undistorted,
                                         Mat distorted,
                                         Mat Kundistorted,
                                         Mat K,
                                         Mat D)
```
    distortPoints 函数的重载，用于处理未畸变点使用非单位相机矩阵获得的情况，例如 #estimateNewCameraMatrixForUndistortRectify 的输出。
    
    参数
    
    undistorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    Kundistorted - 用作畸变校正新相机矩阵的相机内参矩阵。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    distorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。参见：estimateNewCameraMatrixForUndistortRectify
  - fisheye_undistortPoints
```
public static void fisheye_undistortPoints(Mat distorted,
                                           Mat undistorted,
                                           Mat K,
                                           Mat D,
                                           Mat R,
                                           Mat P,
                                           TermCriteria criteria)
```
    使用鱼眼模型对二维点进行去畸变
    
    参数
    
    distorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    criteria - 终止条件
    
    undistorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。
  - fisheye_undistortPoints
```
public static void fisheye_undistortPoints(Mat distorted,
                                           Mat undistorted,
                                           Mat K,
                                           Mat D,
                                           Mat R,
                                           Mat P)
```
    使用鱼眼模型对二维点进行去畸变
    
    参数
    
    distorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    undistorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。
  - fisheye_undistortPoints
```
public static void fisheye_undistortPoints(Mat distorted,
                                           Mat undistorted,
                                           Mat K,
                                           Mat D,
                                           Mat R)
```
    使用鱼眼模型对二维点进行去畸变
    
    参数
    
    distorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    undistorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。
  - fisheye_undistortPoints
```
public static void fisheye_undistortPoints(Mat distorted,
                                           Mat undistorted,
                                           Mat K,
                                           Mat D)
```
    使用鱼眼模型对二维点进行去畸变
    
    参数
    
    distorted - 对象点数组，1xN/Nx1 双通道（或 vector<Point2f>），其中 N 是视图中点的数量。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。单通道或 1x1 三通道
    
    undistorted - 输出图像点数组，1xN/Nx1 双通道，或 vector<Point2f>。
  - fisheye_initUndistortRectifyMap
```
public static void fisheye_initUndistortRectifyMap(Mat K,
                                                   Mat D,
                                                   Mat R,
                                                   Mat P,
                                                   Size size,
                                                   int m1type,
                                                   Mat map1,
                                                   Mat map2)
```
    计算用于#remap图像变换的去畸变和校正映射。如果D为空，则使用零畸变；如果R或P为空，则使用单位矩阵。
    
    参数
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    size - 校正后图像大小。
    
    m1type - 第一个输出映射的类型，可以是CV_32FC1或CV_16SC2。详情参见#convertMaps。
    
    map1 - 第一个输出映射。
    
    map2 - 第二个输出映射。
  - fisheye_undistortImage
```
public static void fisheye_undistortImage(Mat distorted,
                                          Mat undistorted,
                                          Mat K,
                                          Mat D,
                                          Mat Knew,
                                          Size new_size)
```
    变换图像以补偿鱼眼镜头畸变。
    参数
    
    distorted - 具有鱼眼镜头畸变的图像。
    
    undistorted - 补偿了鱼眼镜头畸变的输出图像。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    Knew - 畸变图像的相机内参矩阵。默认情况下，它是单位矩阵，但您可以通过使用不同的矩阵来额外缩放和移动结果。
    
    new_size - 新尺寸。该函数转换图像以补偿径向和切向镜头畸变。该函数只是#fisheye::initUndistortRectifyMap（使用单位矩阵R）和#remap（使用双线性插值）的组合。有关执行的变换的详细信息，请参见前一个函数。请参见下面undistortImage的结果。
    
    a）透视相机模型的去畸变结果（所有可能的畸变系数(k_1, k_2, k_3, k_4, k_5, k_6)都在标定过程中进行了优化）
    
    b）鱼眼相机模型的#fisheye::undistortImage结果（所有可能的鱼眼畸变系数(k_1, k_2, k_3, k_4)都在标定过程中进行了优化）
    
    c）原始图像使用鱼眼镜头拍摄
    
    图片a）和b）几乎相同。但是，如果我们考虑远离图像中心的图像点，我们可以注意到在图像a）中这些点是畸变的。
    
    ![image](pics/fisheye_undistorted.jpg)
  - fisheye_undistortImage
```
public static void fisheye_undistortImage(Mat distorted,
                                          Mat undistorted,
                                          Mat K,
                                          Mat D,
                                          Mat Knew)
```
    变换图像以补偿鱼眼镜头畸变。
    参数
    
    distorted - 具有鱼眼镜头畸变的图像。
    
    undistorted - 补偿了鱼眼镜头畸变的输出图像。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    Knew - 畸变图像的相机内参矩阵。默认情况下，它是单位矩阵，但您可以通过使用不同的矩阵来额外缩放和移动结果。该函数转换图像以补偿径向和切向镜头畸变。该函数只是#fisheye::initUndistortRectifyMap（使用单位矩阵R）和#remap（使用双线性插值）的组合。有关执行的变换的详细信息，请参见前一个函数。请参见下面undistortImage的结果。
    
    a）透视相机模型的去畸变结果（所有可能的畸变系数(k_1, k_2, k_3, k_4, k_5, k_6)都在标定过程中进行了优化）
    
    b）鱼眼相机模型的#fisheye::undistortImage结果（所有可能的鱼眼畸变系数(k_1, k_2, k_3, k_4)都在标定过程中进行了优化）
    
    c）原始图像使用鱼眼镜头拍摄
    
    图片a）和b）几乎相同。但是，如果我们考虑远离图像中心的图像点，我们可以注意到在图像a）中这些点是畸变的。
    
    ![image](pics/fisheye_undistorted.jpg)
  - fisheye_undistortImage
```
public static void fisheye_undistortImage(Mat distorted,
                                          Mat undistorted,
                                          Mat K,
                                          Mat D)
```
    变换图像以补偿鱼眼镜头畸变。
    参数
    
    distorted - 具有鱼眼镜头畸变的图像。
    
    undistorted - 补偿了鱼眼镜头畸变的输出图像。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 畸变系数输入向量\(\distcoeffsfisheye\)。您可以通过使用不同的矩阵来额外缩放和移动结果。该函数转换图像以补偿径向和切向镜头畸变。该函数只是#fisheye::initUndistortRectifyMap（使用单位矩阵R）和#remap（使用双线性插值）的组合。有关执行的变换的详细信息，请参见前一个函数。请参见下面undistortImage的结果。
    
    a）透视相机模型的去畸变结果（所有可能的畸变系数(k_1, k_2, k_3, k_4, k_5, k_6)都在标定过程中进行了优化）
    
    b）鱼眼相机模型的#fisheye::undistortImage结果（所有可能的鱼眼畸变系数(k_1, k_2, k_3, k_4)都在标定过程中进行了优化）
    
    c）原始图像使用鱼眼镜头拍摄
    
    图片a）和b）几乎相同。但是，如果我们考虑远离图像中心的图像点，我们可以注意到在图像a）中这些点是畸变的。
    
    ![image](pics/fisheye_undistorted.jpg)
  - fisheye_estimateNewCameraMatrixForUndistortRectify
```
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                      Mat D,
                                                                      Size image_size,
                                                                      Mat R,
                                                                      Mat P,
                                                                      double balance,
                                                                      Size new_size,
                                                                      double fov_scale)
```
    估计用于去畸变或校正的新相机内参矩阵。
    
    参数
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    image_size - 图像尺寸
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    balance - 设置新的焦距，范围在最小焦距和最大焦距之间。Balance的范围是[0, 1]。
    
    new_size - 新尺寸
    
    fov_scale - 新焦距的除数。
  - fisheye_estimateNewCameraMatrixForUndistortRectify
```
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                      Mat D,
                                                                      Size image_size,
                                                                      Mat R,
                                                                      Mat P,
                                                                      double balance,
                                                                      Size new_size)
```
    估计用于去畸变或校正的新相机内参矩阵。
    
    参数
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    image_size - 图像尺寸
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    balance - 设置新的焦距，范围在最小焦距和最大焦距之间。Balance的范围是[0, 1]。
    
    new_size - 新尺寸
  - fisheye_estimateNewCameraMatrixForUndistortRectify
```
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                      Mat D,
                                                                      Size image_size,
                                                                      Mat R,
                                                                      Mat P,
                                                                      double balance)
```
    估计用于去畸变或校正的新相机内参矩阵。
    
    参数
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    image_size - 图像尺寸
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新相机内参矩阵（3x3）或新的投影矩阵（3x4）
    
    balance - 设置新的焦距，范围在最小焦距和最大焦距之间。Balance的范围是[0, 1]。
  - fisheye_estimateNewCameraMatrixForUndistortRectify
```
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                      Mat D,
                                                                      Size image_size,
                                                                      Mat R,
                                                                      Mat P)
```
    估计用于去畸变或校正的新相机内参矩阵。
    
    参数
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    image_size - 图像尺寸
    
    D - 输入畸变系数向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3 单通道，或向量：3x1/1x3 单通道或 1x1 三通道
    
    P - 新的相机内参矩阵(3x3)或新的投影矩阵(3x4)长度。Balance的范围是[0, 1]。
  - fisheye_calibrate
```
public static double fisheye_calibrate(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs,
                                       int flags,
                                       TermCriteria criteria)
```
    执行相机标定
    参数
    
    objectPoints - 校准图案坐标空间中校准图案点的向量。
    
    imagePoints - 校准图案点投影的向量。imagePoints.size()和objectPoints.size()以及imagePoints[i].size()必须等于每个i的objectPoints[i].size()。
    
    image_size - 用于初始化相机内参矩阵的图像大小。
    
    K - 输出的3x3浮点相机内参矩阵\(\cameramatrix{A}\)。如果指定了REF: fisheye::CALIB_USE_INTRINSIC_GUESS，则在调用函数之前必须初始化fx、fy、cx、cy中的部分或全部。
    
    D - 畸变系数输出向量\(\distcoeffsfisheye\)。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量（参见REF: Rodrigues）。也就是说，每个第k个旋转向量与其对应的第k个平移向量（参见下一个输出参数说明）一起将校准图案从模型坐标空间（在其中指定物体点）带到世界坐标空间，即校准图案在第k个图案视图中的实际位置(k=0.. *M* -1)。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS cameraMatrix包含fx、fy、cx、cy的有效初始值，这些值将进一步优化。否则，(cx, cy)最初设置为图像中心（使用imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT 在全局优化过程中，主点不会改变。它保持在中心或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时指定的其他位置。
    
    REF: fisheye::CALIB_FIX_FOCAL_LENGTH 在全局优化过程中，焦距不会改变。它是\(max(width,height)/\pi\)或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时提供的\(f_x\)，\(f_y\)。
    
    criteria - 迭代优化算法的终止条件。
    
    返回值
    
    自动生成
  - fisheye_calibrate
```
public static double fisheye_calibrate(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs,
                                       int flags)
```
    执行相机标定
    参数
    
    objectPoints - 校准图案坐标空间中校准图案点的向量。
    
    imagePoints - 校准图案点投影的向量。imagePoints.size()和objectPoints.size()以及imagePoints[i].size()必须等于每个i的objectPoints[i].size()。
    
    image_size - 用于初始化相机内参矩阵的图像大小。
    
    K - 输出的3x3浮点相机内参矩阵\(\cameramatrix{A}\)。如果指定了REF: fisheye::CALIB_USE_INTRINSIC_GUESS，则在调用函数之前必须初始化fx、fy、cx、cy中的部分或全部。
    
    D - 畸变系数输出向量\(\distcoeffsfisheye\)。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量（参见REF: Rodrigues）。也就是说，每个第k个旋转向量与其对应的第k个平移向量（参见下一个输出参数说明）一起将校准图案从模型坐标空间（在其中指定物体点）带到世界坐标空间，即校准图案在第k个图案视图中的实际位置(k=0.. *M* -1)。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS cameraMatrix包含fx、fy、cx、cy的有效初始值，这些值将进一步优化。否则，(cx, cy)最初设置为图像中心（使用imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT 在全局优化过程中，主点不会改变。它保持在中心或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时指定的其他位置。
    
    REF: fisheye::CALIB_FIX_FOCAL_LENGTH 在全局优化过程中，焦距不会改变。它是\(max(width,height)/\pi\)或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时提供的\(f_x\)，\(f_y\)。
    
    返回值
    
    自动生成
  - fisheye_calibrate
```
public static double fisheye_calibrate(java.util.List<Mat> objectPoints,
                                       java.util.List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       java.util.List<Mat> rvecs,
                                       java.util.List<Mat> tvecs)
```
    执行相机标定
    参数
    
    objectPoints - 校准图案坐标空间中校准图案点的向量。
    
    imagePoints - 校准图案点投影的向量。imagePoints.size()和objectPoints.size()以及imagePoints[i].size()必须等于每个i的objectPoints[i].size()。
    
    image_size - 用于初始化相机内参矩阵的图像大小。
    
    K - 输出的3x3浮点相机内参矩阵\(\cameramatrix{A}\)。如果指定了REF: fisheye::CALIB_USE_INTRINSIC_GUESS，则在调用函数之前必须初始化fx、fy、cx、cy中的部分或全部。
    
    D - 畸变系数输出向量\(\distcoeffsfisheye\)。
    
    rvecs - 为每个图案视图估计的旋转向量输出向量（参见REF: Rodrigues）。也就是说，每个第k个旋转向量与其对应的第k个平移向量（参见下一个输出参数说明）一起将校准图案从模型坐标空间（在其中指定物体点）带到世界坐标空间，即校准图案在第k个图案视图中的实际位置(k=0.. *M* -1)。
    
    tvecs - 为每个图案视图估计的平移向量输出向量。
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS cameraMatrix包含fx、fy、cx、cy的有效初始值，这些值将进一步优化。否则，(cx, cy)最初设置为图像中心（使用imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT 在全局优化过程中，主点不会改变。它保持在中心或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时指定的其他位置。
    
    REF: fisheye::CALIB_FIX_FOCAL_LENGTH 在全局优化过程中，焦距不会改变。它是\(max(width,height)/\pi\)或在设置REF: fisheye::CALIB_USE_INTRINSIC_GUESS时提供的\(f_x\)，\(f_y\)。
    
    返回值
    
    自动生成
  - fisheye_stereoRectify
```
public static void fisheye_stereoRectify(Mat K1,
                                         Mat D1,
                                         Mat K2,
                                         Mat D2,
                                         Size imageSize,
                                         Mat R,
                                         Mat tvec,
                                         Mat R1,
                                         Mat R2,
                                         Mat P1,
                                         Mat P2,
                                         Mat Q,
                                         int flags,
                                         Size newImageSize,
                                         double balance,
                                         double fov_scale)
```
    鱼眼相机模型的立体校正
    
    参数
    
    K1 - 第一个相机内参矩阵。
    
    D1 - 第一个相机的畸变参数。
    
    K2 - 第二个相机内参矩阵。
    
    D2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 第一个相机和第二个相机坐标系之间的旋转矩阵。
    
    tvec - 相机坐标系之间的平移向量。
    
    R1 - 第一个相机的输出3x3校正变换（旋转矩阵）。
    
    R2 - 第二个相机的输出3x3校正变换（旋转矩阵）。
    
    P1 - 第一个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    P2 - 第二个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    Q - 输出的\(4 \times 4\)视差到深度的映射矩阵（参见#reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或REF: fisheye::CALIB_ZERO_DISPARITY。如果设置了该标志，则该函数使每个相机的中心点在校正视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有用的图像区域。
    
    newImageSize - 校正后的新图像分辨率。应将相同的大小传递给#initUndistortRectifyMap（参见OpenCV示例目录中的stereo_calib.cpp示例）。当传递(0,0)（默认值）时，它设置为原始imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在大的径向畸变时。
    
    balance - 设置新的焦距，范围在最小焦距和最大焦距之间。Balance的范围是[0, 1]。
    
    fov_scale - 新焦距的除数。
  - fisheye_stereoRectify
```
public static void fisheye_stereoRectify(Mat K1,
                                         Mat D1,
                                         Mat K2,
                                         Mat D2,
                                         Size imageSize,
                                         Mat R,
                                         Mat tvec,
                                         Mat R1,
                                         Mat R2,
                                         Mat P1,
                                         Mat P2,
                                         Mat Q,
                                         int flags,
                                         Size newImageSize,
                                         double balance)
```
    鱼眼相机模型的立体校正
    
    参数
    
    K1 - 第一个相机内参矩阵。
    
    D1 - 第一个相机的畸变参数。
    
    K2 - 第二个相机内参矩阵。
    
    D2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 第一个相机和第二个相机坐标系之间的旋转矩阵。
    
    tvec - 相机坐标系之间的平移向量。
    
    R1 - 第一个相机的输出3x3校正变换（旋转矩阵）。
    
    R2 - 第二个相机的输出3x3校正变换（旋转矩阵）。
    
    P1 - 第一个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    P2 - 第二个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    Q - 输出的\(4 \times 4\)视差到深度的映射矩阵（参见#reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或REF: fisheye::CALIB_ZERO_DISPARITY。如果设置了该标志，则该函数使每个相机的中心点在校正视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有用的图像区域。
    
    newImageSize - 校正后的新图像分辨率。应将相同的大小传递给#initUndistortRectifyMap（参见OpenCV示例目录中的stereo_calib.cpp示例）。当传递(0,0)（默认值）时，它设置为原始imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节，尤其是在存在大的径向畸变时。
    
    balance - 设置新的焦距，范围在最小焦距和最大焦距之间。Balance的范围是[0, 1]。
  - fisheye_stereoRectify
```
public static void fisheye_stereoRectify(Mat K1,
                                         Mat D1,
                                         Mat K2,
                                         Mat D2,
                                         Size imageSize,
                                         Mat R,
                                         Mat tvec,
                                         Mat R1,
                                         Mat R2,
                                         Mat P1,
                                         Mat P2,
                                         Mat Q,
                                         int flags,
                                         Size newImageSize)
```
    鱼眼相机模型的立体校正
    
    参数
    
    K1 - 第一个相机内参矩阵。
    
    D1 - 第一个相机的畸变参数。
    
    K2 - 第二个相机内参矩阵。
    
    D2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 第一个相机和第二个相机坐标系之间的旋转矩阵。
    
    tvec - 相机坐标系之间的平移向量。
    
    R1 - 第一个相机的输出3x3校正变换（旋转矩阵）。
    
    R2 - 第二个相机的输出3x3校正变换（旋转矩阵）。
    
    P1 - 第一个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    P2 - 第二个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    Q - 输出的\(4 \times 4\)视差到深度的映射矩阵（参见#reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或REF: fisheye::CALIB_ZERO_DISPARITY。如果设置了该标志，则该函数使每个相机的中心点在校正视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能沿水平或垂直方向（取决于极线的方向）移动图像，以最大化有用的图像区域。
    
    newImageSize - 校正后新的图像分辨率。应将相同大小传递给 #initUndistortRectifyMap（参见 OpenCV 示例目录中的 stereo_calib.cpp 示例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其是在存在较大的径向畸变时。
  - fisheye_stereoRectify
```
public static void fisheye_stereoRectify(Mat K1,
                                         Mat D1,
                                         Mat K2,
                                         Mat D2,
                                         Size imageSize,
                                         Mat R,
                                         Mat tvec,
                                         Mat R1,
                                         Mat R2,
                                         Mat P1,
                                         Mat P2,
                                         Mat Q,
                                         int flags)
```
    鱼眼相机模型的立体校正
    
    参数
    
    K1 - 第一个相机内参矩阵。
    
    D1 - 第一个相机的畸变参数。
    
    K2 - 第二个相机内参矩阵。
    
    D2 - 第二个相机的畸变参数。
    
    imageSize - 用于立体校准的图像大小。
    
    R - 第一个相机和第二个相机坐标系之间的旋转矩阵。
    
    tvec - 相机坐标系之间的平移向量。
    
    R1 - 第一个相机的输出3x3校正变换（旋转矩阵）。
    
    R2 - 第二个相机的输出3x3校正变换（旋转矩阵）。
    
    P1 - 第一个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    P2 - 第二个相机在新（校正）坐标系中的输出3x4投影矩阵。
    
    Q - 输出的\(4 \times 4\)视差到深度的映射矩阵（参见#reprojectImageTo3D）。
    
    flags - 操作标志，可以为零或 REF: fisheye::CALIB_ZERO_DISPARITY。如果设置了该标志，则该函数使每个摄像机的 principal points 在校正视图中具有相同的像素坐标。如果没有设置该标志，则该函数仍可能在水平或垂直方向上移动图像（取决于极线的方向），以最大限度地提高有效图像区域。#initUndistortRectifyMap（参见 OpenCV 示例目录中的 stereo_calib.cpp 示例）。当传递 (0,0)（默认值）时，它设置为原始 imageSize。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其是在存在较大的径向畸变时。
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             int flags,
                                             TermCriteria criteria)
```
    执行立体标定
    参数
    
    objectPoints - 校准图案点的向量集合。
    
    imagePoints1 - 第一个摄像机观察到的校准图案点投影的向量集合。
    
    imagePoints2 - 第二个摄像机观察到的校准图案点投影的向量集合。
    
    K1 - 输入/输出第一个摄像机内参矩阵：\(\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\) , \(j = 0,\, 1\) 。如果指定了 REF: fisheye::CALIB_USE_INTRINSIC_GUESS 或 REF: fisheye::CALIB_FIX_INTRINSIC 中的任何一个，则必须初始化矩阵的一些或所有组件。
    
    D1 - 输入/输出 4 元素的畸变系数向量 \(\distcoeffsfisheye\) 。
    
    K2 - 输入/输出第二个摄像机内参矩阵。该参数类似于 K1。
    
    D2 - 输入/输出第二个摄像机的镜头畸变系数。该参数类似于 D1。
    
    imageSize - 只用于初始化摄像机内参矩阵的图像大小。
    
    R - 第一个和第二个摄像机坐标系之间的输出旋转矩阵。
    
    T - 摄像机坐标系之间的输出平移向量。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: fisheye::CALIB_FIX_INTRINSIC 固定 K1、K2 和 D1、D2，以便仅估计 R、T 矩阵。
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS K1、K2 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心（使用 imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    criteria - 迭代优化算法的终止条件。
    
    返回值
    
    自动生成
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs,
                                             int flags)
```
    执行立体标定
    参数
    
    objectPoints - 校准图案点的向量集合。
    
    imagePoints1 - 第一个摄像机观察到的校准图案点投影的向量集合。
    
    imagePoints2 - 第二个摄像机观察到的校准图案点投影的向量集合。
    
    K1 - 输入/输出第一个摄像机内参矩阵：\(\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\) , \(j = 0,\, 1\) 。如果指定了 REF: fisheye::CALIB_USE_INTRINSIC_GUESS 或 REF: fisheye::CALIB_FIX_INTRINSIC 中的任何一个，则必须初始化矩阵的一些或所有组件。
    
    D1 - 输入/输出 4 元素的畸变系数向量 \(\distcoeffsfisheye\) 。
    
    K2 - 输入/输出第二个摄像机内参矩阵。该参数类似于 K1。
    
    D2 - 输入/输出第二个摄像机的镜头畸变系数。该参数类似于 D1。
    
    imageSize - 只用于初始化摄像机内参矩阵的图像大小。
    
    R - 第一个和第二个摄像机坐标系之间的输出旋转矩阵。
    
    T - 摄像机坐标系之间的输出平移向量。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    flags - 不同的标志，可以为零或以下值的组合
    
    REF: fisheye::CALIB_FIX_INTRINSIC 固定 K1、K2 和 D1、D2，以便仅估计 R、T 矩阵。
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS K1、K2 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心（使用 imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    返回值
    
    自动生成
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             java.util.List<Mat> rvecs,
                                             java.util.List<Mat> tvecs)
```
    执行立体标定
    参数
    
    objectPoints - 校准图案点的向量集合。
    
    imagePoints1 - 第一个摄像机观察到的校准图案点投影的向量集合。
    
    imagePoints2 - 第二个摄像机观察到的校准图案点投影的向量集合。
    
    K1 - 输入/输出第一个摄像机内参矩阵：\(\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\) , \(j = 0,\, 1\) 。如果指定了 REF: fisheye::CALIB_USE_INTRINSIC_GUESS 或 REF: fisheye::CALIB_FIX_INTRINSIC 中的任何一个，则必须初始化矩阵的一些或所有组件。
    
    D1 - 输入/输出 4 元素的畸变系数向量 \(\distcoeffsfisheye\) 。
    
    K2 - 输入/输出第二个摄像机内参矩阵。该参数类似于 K1。
    
    D2 - 输入/输出第二个摄像机的镜头畸变系数。该参数类似于 D1。
    
    imageSize - 只用于初始化摄像机内参矩阵的图像大小。
    
    R - 第一个和第二个摄像机坐标系之间的输出旋转矩阵。
    
    T - 摄像机坐标系之间的输出平移向量。
    
    rvecs - 输出旋转向量向量 (REF: Rodrigues)，针对立体相机对的第一个相机坐标系中每个图案视图进行估计 (例如，std::vector<cv::Mat>)。更详细地说，每个第 i 个旋转向量与其对应的第 i 个平移向量（见下一个输出参数描述）一起，将标定图案从物体坐标空间（其中指定物体点）转换到立体相机对第一个相机的相机坐标空间。更专业的术语来说，第 i 个旋转和平移向量的组合实现了从物体坐标空间到立体相机对第一个相机的相机坐标空间的基变换。
    
    tvecs - 输出针对每个图案视图估计的平移向量向量，见前一个输出参数 (rvecs) 的参数描述。
    
    REF: fisheye::CALIB_FIX_INTRINSIC 固定 K1、K2 和 D1、D2，以便仅估计 R、T 矩阵。
    
    REF: fisheye::CALIB_USE_INTRINSIC_GUESS K1、K2 包含 fx、fy、cx、cy 的有效初始值，这些值将被进一步优化。否则，(cx, cy) 最初设置为图像中心（使用 imageSize），焦距以最小二乘法计算。
    
    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC 在每次内参优化迭代后都会重新计算外参。
    
    REF: fisheye::CALIB_CHECK_COND 函数将检查条件数的有效性。
    
    REF: fisheye::CALIB_FIX_SKEW 斜率系数 (alpha) 设置为零并保持为零。
    
    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 选择的畸变系数设置为零并保持为零。
    
    返回值
    
    自动生成
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             int flags,
                                             TermCriteria criteria)
```
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T,
                                             int flags)
```
  - fisheye_stereoCalibrate
```
public static double fisheye_stereoCalibrate(java.util.List<Mat> objectPoints,
                                             java.util.List<Mat> imagePoints1,
                                             java.util.List<Mat> imagePoints2,
                                             Mat K1,
                                             Mat D1,
                                             Mat K2,
                                             Mat D2,
                                             Size imageSize,
                                             Mat R,
                                             Mat T)
```
  - fisheye_solvePnP
```
public static boolean fisheye_solvePnP(Mat objectPoints,
                                       Mat imagePoints,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       Mat rvec,
                                       Mat tvec,
                                       boolean useExtrinsicGuess,
                                       int flags,
                                       TermCriteria criteria)
```
    针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数的输入向量 (4x1/1x4)。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 用于解决 PnP 问题的算法：参见 REF: calib3d_solvePnP_flags 该函数返回旋转和平移向量，这些向量使用不同的方法将以对象坐标系表示的 3D 点变换到摄像机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    
    criteria - 内部 undistortPoints 调用的终止准则。该函数内部使用 REF: undistortPoints 对点进行去畸变并调用 REF: cv::solvePnP，因此输入非常相似。有关透视-n-点法的更多信息，请参见 REF: calib3d_solvePnP。
    
    返回值
    
    自动生成
  - fisheye_solvePnP
```
public static boolean fisheye_solvePnP(Mat objectPoints,
                                       Mat imagePoints,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       Mat rvec,
                                       Mat tvec,
                                       boolean useExtrinsicGuess,
                                       int flags)
```
    针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数的输入向量 (4x1/1x4)。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 用于解决 PnP 问题的算法：参见 REF: calib3d_solvePnP_flags 该函数返回旋转和平移向量，这些向量使用不同的方法将以对象坐标系表示的 3D 点变换到摄像机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    
    该函数内部使用 REF: undistortPoints 对点进行去畸变并调用 REF: cv::solvePnP，因此输入非常相似。有关透视-n-点法的更多信息，请参见 REF: calib3d_solvePnP。
    
    返回值
    
    自动生成
  - fisheye_solvePnP
```
public static boolean fisheye_solvePnP(Mat objectPoints,
                                       Mat imagePoints,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       Mat rvec,
                                       Mat tvec,
                                       boolean useExtrinsicGuess)
```
    针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数的输入向量 (4x1/1x4)。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为真 (1)，则该函数使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。该函数返回旋转和平移向量，这些向量使用不同的方法将以对象坐标系表示的 3D 点变换到摄像机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    
    该函数内部使用 REF: undistortPoints 对点进行去畸变并调用 REF: cv::solvePnP，因此输入非常相似。有关透视-n-点法的更多信息，请参见 REF: calib3d_solvePnP。
    
    返回值
    
    自动生成
  - fisheye_solvePnP
```
public static boolean fisheye_solvePnP(Mat objectPoints,
                                       Mat imagePoints,
                                       Mat cameraMatrix,
                                       Mat distCoeffs,
                                       Mat rvec,
                                       Mat tvec)
```
    针对鱼眼相机模型，根据3D-2D点对应关系查找物体姿态。
    参数
    
    objectPoints - 物体在物体坐标系中的点数组，Nx3 1 通道或 1xN/Nx1 3 通道，其中 N 是点数。也可以在此处传入 vector<Point3d>。
    
    imagePoints - 对应的图像点数组，Nx2 1 通道或 1xN/Nx1 2 通道，其中 N 是点数。也可以在此处传入 vector<Point2d>。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\) 。
    
    distCoeffs - 畸变系数的输入向量 (4x1/1x4)。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系转换到相机坐标系。
    
    tvec - 输出平移向量。使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。该函数返回旋转和平移向量，这些向量使用不同的方法将以对象坐标系表示的 3D 点变换到摄像机坐标系。
    
    P3P 方法 (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P)：需要 4 个输入点才能返回唯一解。
    
    REF: SOLVEPNP_IPPE 输入点数必须 >= 4，并且物体点必须共面。
    
    REF: SOLVEPNP_IPPE_SQUARE 特殊情况，适用于标记姿态估计。输入点数必须为 4。物体点必须按以下顺序定义：
    
    点 0：[-squareLength / 2, squareLength / 2, 0]
    
    点 1：[squareLength / 2, squareLength / 2, 0]
    
    点 2：[squareLength / 2, -squareLength / 2, 0]
    
    点 3：[-squareLength / 2, -squareLength / 2, 0]
    
    对于所有其他标志，输入点数必须 >= 4，并且物体点可以处于任何配置。
    
    该函数内部使用 REF: undistortPoints 对点进行去畸变并调用 REF: cv::solvePnP，因此输入非常相似。有关透视-n-点法的更多信息，请参见 REF: calib3d_solvePnP。
    
    返回值
    
    自动生成

类 Calib3d

字段摘要

构造器摘要

方法摘要

继承自类 java.lang.Object 的方法

字段详情

CV_ITERATIVE

CV_EPNP

CV_P3P

CV_DLS

CvLevMarq_DONE

CvLevMarq_STARTED

CvLevMarq_CALC_J

CvLevMarq_CHECK_ERR

LMEDS

RANSAC

RHO

USAC_DEFAULT

USAC_PARALLEL

USAC_FM_8PTS

USAC_FAST

USAC_ACCURATE

USAC_PROSAC

USAC_MAGSAC

CALIB_CB_ADAPTIVE_THRESH

CALIB_CB_NORMALIZE_IMAGE

CALIB_CB_FILTER_QUADS

CALIB_CB_FAST_CHECK

CALIB_CB_EXHAUSTIVE

CALIB_CB_ACCURACY

CALIB_CB_LARGER

CALIB_CB_MARKER

CALIB_CB_PLAIN

CALIB_CB_SYMMETRIC_GRID

CALIB_CB_ASYMMETRIC_GRID

CALIB_CB_CLUSTERING

CALIB_NINTRINSIC

CALIB_USE_INTRINSIC_GUESS

CALIB_FIX_ASPECT_RATIO

CALIB_FIX_PRINCIPAL_POINT

CALIB_ZERO_TANGENT_DIST

CALIB_FIX_FOCAL_LENGTH

CALIB_FIX_K1

CALIB_FIX_K2

CALIB_FIX_K3

CALIB_FIX_K4

CALIB_FIX_K5

CALIB_FIX_K6

CALIB_RATIONAL_MODEL

CALIB_THIN_PRISM_MODEL

CALIB_FIX_S1_S2_S3_S4

CALIB_TILTED_MODEL

CALIB_FIX_TAUX_TAUY

CALIB_USE_QR

CALIB_FIX_TANGENT_DIST

CALIB_FIX_INTRINSIC

CALIB_SAME_FOCAL_LENGTH

CALIB_ZERO_DISPARITY

CALIB_USE_LU

CALIB_USE_EXTRINSIC_GUESS

FM_7POINT

FM_8POINT

FM_LMEDS

FM_RANSAC

fisheye_CALIB_USE_INTRINSIC_GUESS

fisheye_CALIB_RECOMPUTE_EXTRINSIC

fisheye_CALIB_CHECK_COND

fisheye_CALIB_FIX_SKEW

fisheye_CALIB_FIX_K1

fisheye_CALIB_FIX_K2

fisheye_CALIB_FIX_K3

fisheye_CALIB_FIX_K4

fisheye_CALIB_FIX_INTRINSIC

fisheye_CALIB_FIX_PRINCIPAL_POINT

fisheye_CALIB_ZERO_DISPARITY

fisheye_CALIB_FIX_FOCAL_LENGTH

CirclesGridFinderParameters_SYMMETRIC_GRID

CirclesGridFinderParameters_ASYMMETRIC_GRID

CALIB_HAND_EYE_TSAI

CALIB_HAND_EYE_PARK