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()

方法摘要

所有方法静态方法具体方法
修饰符和类型	方法	描述
`静态双精度浮点型`	`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)`
`静态双精度浮点型`	`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(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)`
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`静态双精度浮点型`	`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)`
`静态双精度浮点型`	`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(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)`
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`静态双精度浮点型`	`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)`	从标定模式的多个视图中查找相机内参和外参。
`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\)
`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\)
`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\)
`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\)
`static void`	`calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio)`	从相机内参矩阵计算有用的相机特性。
`static boolean`	`checkChessboard(Mat img, Size size)`
`static void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3)`	组合两个旋转平移变换。
`static void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1)`	组合两个旋转平移变换。
`static void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1)`	组合两个旋转平移变换。
`static void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2)`	组合两个旋转平移变换。
`static void`	`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2)`	组合两个旋转平移变换。
`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)`	组合两个旋转平移变换。
`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)`	组合两个旋转平移变换。
`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)`	组合两个旋转平移变换。
`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)`	组合两个旋转平移变换。
`static void`	`computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines)`	对于立体图像对中的点，计算在另一幅图像中对应的对极线。
`static void`	`convertPointsFromHomogeneous(Mat src, Mat dst)`	将点从齐次坐标空间转换为欧几里得空间。
`static void`	`convertPointsToHomogeneous(Mat src, Mat dst)`	将点从欧几里得空间转换为齐次空间。
`static void`	`correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2)`	细化对应点的坐标。
`static 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)`	将单应性矩阵分解为旋转、平移和平面法线。
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles)`	将投影矩阵分解为旋转矩阵和相机内参矩阵。
`static void`	`drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound)`	渲染检测到的棋盘角点。
`static void`	`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)`	根据姿态估计绘制世界/物体坐标系的轴。
`static void`	`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness)`	根据姿态估计绘制世界/物体坐标系的轴。
`static Mat`	`estimateAffine2D(Mat from, Mat to)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`	计算两个二维点集之间的最优仿射变换。
`static Mat`	`estimateAffine2D(Mat pts1, Mat pts2, Mat inliers, UsacParams params)`
`static Mat`	`estimateAffine3D(Mat src, Mat dst)`	计算两个三维点集之间的最优仿射变换。
`static Mat`	`estimateAffine3D(Mat src, Mat dst, double[] scale)`	计算两个三维点集之间的最优仿射变换。
`static 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)`	计算两个三维点集之间的最优仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static Mat`	`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)`	计算两个二维点集之间具有4个自由度的最优受限仿射变换。
`static 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)`	计算两个三维点集之间的最优平移。
`static void`	`filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations, java.util.List<Mat> normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`	根据附加信息过滤单应性分解。
`static void`	`filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations, java.util.List<Mat> normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)`	根据附加信息过滤单应性分解。
`static void`	`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff)`	Filters off small noise blobs (speckles) in the disparity map
`static void`	`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf)`	Filters off small noise blobs (speckles) in the disparity map
`static boolean`	`find4QuadCornerSubpix(Mat img, Mat corners, Size region_size)`
`static boolean`	`findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners)`	查找棋盘内部角点的位置。
`static boolean`	`findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags)`	查找棋盘内部角点的位置。
`static boolean`	`findChessboardCornersSB(Mat image, Size patternSize, Mat corners)`
`static boolean`	`findChessboardCornersSB(Mat image, Size patternSize, Mat corners, int flags)`
`static boolean`	`findChessboardCornersSBWithMeta(Mat image, Size patternSize, Mat corners, int flags, Mat meta)`	使用基于扇区的方法查找棋盘内部角点的位置。
`static boolean`	`findCirclesGrid(Mat image, Size patternSize, Mat centers)`
`static boolean`	`findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, int maxIters)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, int maxIters, Mat mask)`
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters, Mat mask)`	从两幅图像中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2)`	从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method)`	从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob)`	从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold)`	从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold, Mat mask)`	从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
`static Mat`	`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat cameraMatrix2, Mat dist_coeff1, Mat dist_coeff2, Mat mask, UsacParams params)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, int maxIters)`	从两幅图像中的对应点计算基础矩阵。
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, int maxIters, Mat mask)`	从两幅图像中的对应点计算基础矩阵。
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, Mat mask)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, Mat mask, UsacParams params)`
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)`	在两个平面之间找到透视变换。
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, Mat mask, UsacParams params)`
`静态双精度浮点型`	`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)`	执行相机标定
`静态双精度浮点型`	`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)`	执行相机标定
`静态双精度浮点型`	`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)`	执行相机标定
`static void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)`	使用鱼眼模型扭曲 2D 点。
`static void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)`	使用鱼眼模型扭曲 2D 点。
`static void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat Kundistorted, Mat K, Mat D)`	distortPoints 函数的重载，用于处理非单位相机矩阵获取的未畸变点的情况，例如。
`static void`	`fisheye_distortPoints(Mat undistorted, Mat distorted, Mat Kundistorted, Mat K, Mat D, double alpha)`	distortPoints 函数的重载，用于处理非单位相机矩阵获取的未畸变点的情况，例如。
`static void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P)`	估计用于去畸变或校正的新相机内参矩阵。
`static void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance)`	估计用于去畸变或校正的新相机内参矩阵。
`static void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size)`	估计用于去畸变或校正的新相机内参矩阵。
`static void`	`fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale)`	估计用于去畸变或校正的新相机内参矩阵。
`static void`	`fisheye_initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat map1, Mat map2)`	计算用于通过 #remap 进行图像变换的去畸变和校正映射。
`static void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D)`
`static void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha)`
`static void`	`fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian)`
`static boolean`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
`static boolean`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
`static boolean`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)`	对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
`static boolean`	`fisheye_solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags, TermCriteria criteria)`	对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`static boolean`	`fisheye_solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags, TermCriteria criteria)`	使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
`静态双精度浮点型`	`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_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(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(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)`	执行立体标定。
`静态双精度浮点型`	`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)`	执行立体标定。
`静态双精度浮点型`	`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)`	执行立体标定。
`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)`	鱼眼相机模型的立体校正。
`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)`	鱼眼相机模型的立体校正。
`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)`	鱼眼相机模型的立体校正。
`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)`	鱼眼相机模型的立体校正。
`static void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D)`	转换图像以补偿鱼眼镜头畸变。
`static void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew)`	转换图像以补偿鱼眼镜头畸变。
`static void`	`fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size)`	转换图像以补偿鱼眼镜头畸变。
`static void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D)`	使用鱼眼模型对2D点进行去畸变。
`static void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R)`	使用鱼眼模型对2D点进行去畸变。
`static void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P)`	使用鱼眼模型对2D点进行去畸变。
`static void`	`fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P, TermCriteria criteria)`	使用鱼眼模型对2D点进行去畸变。
`static Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix)`	返回默认的新相机矩阵。
`static Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize)`	返回默认的新相机矩阵。
`static Mat`	`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)`	返回默认的新相机矩阵。
`static Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)`	根据自由缩放参数返回新的相机内参矩阵。
`static Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize)`	根据自由缩放参数返回新的相机内参矩阵。
`static Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI)`	根据自由缩放参数返回新的相机内参矩阵。
`static 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)`
`static Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize)`	从3D-2D点对应关系中找到初始相机内参矩阵。
`static Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize, double aspectRatio)`	从3D-2D点对应关系中找到初始相机内参矩阵。
`static void`	`initInverseRectificationMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)`	计算投影和逆校正变换图。
`static void`	`initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)`	计算去畸变和校正变换图。
`static void`	`matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB)`	计算每个相乘矩阵的矩阵积的偏导数。
`static void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints)`	将三维点投影到图像平面。
`static void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian)`	将三维点投影到图像平面。
`static void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio)`	将三维点投影到图像平面。
`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)`	使用手性检查，从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。
`静态浮点型`	`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)`
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)`	将视差图像重新投影到3D空间。
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues)`	将视差图像重新投影到3D空间。
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)`	将视差图像重新投影到3D空间。
`static void`	`Rodrigues(Mat src, Mat dst)`	将旋转矩阵转换为旋转向量，反之亦然。
`static void`	`Rodrigues(Mat src, Mat dst, Mat jacobian)`	将旋转矩阵转换为旋转向量，反之亦然。
`静态 double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)`	计算3x3矩阵的RQ分解。
`静态 double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx)`	计算3x3矩阵的RQ分解。
`静态 double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy)`	计算3x3矩阵的RQ分解。
`静态 double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)`	计算3x3矩阵的RQ分解。
`静态双精度浮点型`	`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`static boolean`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`	从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)： ![透视投影，从物体到相机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见： REF: calib3d_solvePnP 此函数使用不同的方法返回将对象坐标系中表示的3D点转换为相机坐标系的旋转和平移向量： P3P方法（REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P）：需要4个输入点才能返回唯一解。
`static boolean`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)： ![透视投影，从物体到相机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见： REF: calib3d_solvePnP 此函数使用不同的方法返回将对象坐标系中表示的3D点转换为相机坐标系的旋转和平移向量： P3P方法（REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P）：需要4个输入点才能返回唯一解。
`static boolean`	`solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)`	从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)： ![透视投影，从物体到相机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见： REF: calib3d_solvePnP 此函数使用不同的方法返回将对象坐标系中表示的3D点转换为相机坐标系的旋转和平移向量： P3P方法（REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P）：需要4个输入点才能返回唯一解。
`static int`	`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`	从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。
`static boolean`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`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点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)`	使用RANSAC方案，从3D-2D点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)，以处理不良匹配。
`static boolean`	`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, Mat inliers)`
`static boolean`	`solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, Mat inliers, UsacParams params)`
`static void`	`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	从3D-2D点对应关系和初始解开始，优化姿态（将对象坐标系中表示的3D点转换为相机坐标系的平移和旋转）。
`static void`	`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria)`	从3D-2D点对应关系和初始解开始，优化姿态（将对象坐标系中表示的3D点转换为相机坐标系的平移和旋转）。
`static void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`	从3D-2D点对应关系和初始解开始，优化姿态（将对象坐标系中表示的3D点转换为相机坐标系的平移和旋转）。
`static void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria)`	从3D-2D点对应关系和初始解开始，优化姿态（将对象坐标系中表示的3D点转换为相机坐标系的平移和旋转）。
`static void`	`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria, double VVSlambda)`	从3D-2D点对应关系和初始解开始，优化姿态（将对象坐标系中表示的3D点转换为相机坐标系的平移和旋转）。
`静态双精度浮点型`	`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(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(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(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)`
`静态双精度浮点型`	`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(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)`
`静态双精度浮点型`	`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)`	校准立体相机设置。
`静态双精度浮点型`	`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)`	校准立体相机设置。
`静态双精度浮点型`	`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)`	校准立体相机设置。
`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)`	计算已校准立体相机每个头的校正变换。
`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)`	计算已校准立体相机每个头的校正变换。
`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)`	计算已校准立体相机每个头的校正变换。
`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)`	计算已校准立体相机每个头的校正变换。
`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)`	计算已校准立体相机每个头的校正变换。
`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)`	计算已校准立体相机每个头的校正变换。
`static boolean`	`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2)`	计算未校准立体相机的校正变换。
`static boolean`	`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold)`	计算未校准立体相机的校正变换。
`static void`	`triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D)`	此函数通过使用立体相机对其进行观测来重建三维点（齐次坐标）。
`static void`	`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`	变换图像以补偿镜头畸变。
`static void`	`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix)`	变换图像以补偿镜头畸变。
`static void`	`undistortImagePoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`	计算未畸变图像点的位置
`static void`	`undistortImagePoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, TermCriteria arg1)`	计算未畸变图像点的位置
`static void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs)`	从观测到的点坐标计算理想点坐标。
`static void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs, Mat R)`	从观测到的点坐标计算理想点坐标。
`static void`	`undistortPoints(MatOfPoint2f src, MatOfPoint2f dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P)`	从观测到的点坐标计算理想点坐标。
`static void`	`undistortPointsIter(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P, TermCriteria criteria)`	注意： #undistortPoints 的默认版本执行 5 次迭代以计算未畸变点。
`static void`	`validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities)`
`static 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 - 可选输出 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 个自由度）。此表示用于全局三维几何优化过程，例如 REF: calibrateCamera、REF: stereoCalibrate 或 REF: solvePnP。注意：有关三维旋转矩阵相对于其指数坐标的导数计算的更多信息，请参阅
    
    A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi CITE: Gallego2014ACF
    
    注意：有关 SE(3) 和李群的有用信息，请参阅
    
    A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco CITE: blanco2010tutorial
    
    Lie Groups for 2D and 3D Transformation, Ethan Eade CITE: Eade17
    
    A micro Lie theory for state estimation in robotics, 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 个自由度）。此表示用于全局三维几何优化过程，例如 REF: calibrateCamera、REF: stereoCalibrate 或 REF: solvePnP。注意：有关三维旋转矩阵相对于其指数坐标的导数计算的更多信息，请参阅
    
    A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi CITE: Gallego2014ACF
    
    注意：有关 SE(3) 和李群的有用信息，请参阅
    
    A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco CITE: blanco2010tutorial
    
    Lie Groups for 2D and 3D Transformation, Ethan Eade CITE: Eade17
    
    A micro Lie theory for state estimation in robotics, 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 迭代的最大次数。其功能描述与 i=52 段落中的解释相同。
    
    返回
    
    自动生成
  - 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）设置的可选输出掩码。请注意，输入掩码值将被忽略。其功能描述与 i=52 段落中的解释相同。
    
    返回
    
    自动生成
  - 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 方法）。其功能描述与 i=52 段落中的解释相同。
    
    返回
    
    自动生成
  - 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 的范围内是有意义的。掩码值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换 \(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 的范围内是有意义的。掩码值将被忽略。该函数查找并返回源平面和目标平面之间的透视变换 \(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 - 可选输出绕 x 轴的 3x3 旋转矩阵。
    
    Qy - 可选输出绕 y 轴的 3x3 旋转矩阵。
    
    Qz - 可选输出绕 z 轴的 3x3 旋转矩阵。该函数使用给定的旋转计算 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 - 可选输出绕 x 轴的 3x3 旋转矩阵。
    
    Qy - 可选输出绕 y 轴的 3x3 旋转矩阵。其功能描述与 i=63 段落中的解释相同。
    
    返回
    
    自动生成
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ,
                                   Mat Qx)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。
    
    Qx - 可选输出绕 x 轴的 3x3 旋转矩阵。其功能描述与 i=63 段落中的解释相同。
    
    返回
    
    自动生成
  - RQDecomp3x3
```
public static double[] RQDecomp3x3(Mat src,
                                   Mat mtxR,
                                   Mat mtxQ)
```
    计算3x3矩阵的RQ分解。
    
    参数
    
    src - 3x3 输入矩阵。
    
    mtxR - 输出 3x3 上三角矩阵。
    
    mtxQ - 输出 3x3 正交矩阵。其功能描述与 i=63 段落中的解释相同。
    
    返回
    
    自动生成
  - 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 - 可选的绕 x 轴的 3x3 旋转矩阵。
    
    rotMatrixY - 可选的绕 y 轴的 3x3 旋转矩阵。
    
    rotMatrixZ - 可选的绕 z 轴的 3x3 旋转矩阵。
    
    eulerAngles - 可选的三元素向量，包含三个以度为单位的旋转欧拉角。该函数计算将投影矩阵分解为校准矩阵、旋转矩阵和相机位置。它可选地返回三个旋转矩阵，每个轴一个，以及可在 OpenGL 中使用的三个欧拉角。请注意，绕三个主轴的旋转序列不止一种，都可以产生物体的相同方向，例如参见 CITE: 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 - 可选的绕 x 轴的 3x3 旋转矩阵。
    
    rotMatrixY - 可选的绕 y 轴的 3x3 旋转矩阵。
    
    rotMatrixZ - 可选的绕 z 轴的 3x3 旋转矩阵。其功能描述与 i=75 段落中的解释相同。
  - 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 - 可选的绕 x 轴的 3x3 旋转矩阵。
    
    rotMatrixY - 可选的绕 y 轴的 3x3 旋转矩阵。其功能描述与 i=75 段落中的解释相同。
  - 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 - 可选的绕 x 轴的 3x3 旋转矩阵。其功能描述与 i=75 段落中的解释相同。
  - 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。其功能描述与 i=75 段落中的解释相同。
  - 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 中的 Jacobian 矩阵，但也可以用于任何其他类似的优化函数。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - 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 的导数。其功能描述与 i=99 段落中的解释相同。
  - composeRT
```
public static void composeRT(Mat rvec1,
                             Mat tvec1,
                             Mat rvec2,
                             Mat tvec2,
                             Mat rvec3,
                             Mat tvec3)
```
    组合两个旋转平移变换。
    
    参数
    
    rvec1 - 第一个旋转向量。
    
    tvec1 - 第一个平移向量。
    
    rvec2 - 第二个旋转向量。
    
    tvec2 - 第二个平移向量。
    
    rvec3 - 叠加的输出旋转向量。
    
    tvec3 - 叠加的输出平移向量。其功能描述与 i=99 段落中的解释相同。
  - projectPoints
```
public static void projectPoints(MatOfPoint3f objectPoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat cameraMatrix,
                                 MatOfDouble distCoeffs,
                                 MatOfPoint2f imagePoints,
                                 Mat jacobian,
                                 double aspectRatio)
```
    将三维点投影到图像平面。
    
    参数
    
    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>) 的 Jacobian 矩阵，包含图像点相对于旋转向量、平移向量、焦距、主点坐标和畸变系数分量的导数。在旧接口中，Jacobian 的不同分量通过不同的输出参数返回。
    
    aspectRatio - 可选的“固定长宽比”参数。如果参数不为 0，函数假定长宽比（\(f_x / f_y\)）是固定的，并相应地调整 Jacobian 矩阵。该函数根据给定的相机内参和外参，计算三维点在图像平面上的二维投影。可选地，该函数计算 Jacobian 矩阵，即图像点坐标（作为所有输入参数的函数）相对于特定参数（内参和/或外参）的偏导数矩阵。Jacobian 矩阵在 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)
```
    将三维点投影到图像平面。
    
    参数
    
    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>) 的 Jacobian 矩阵，包含图像点相对于旋转向量、平移向量、焦距、主点坐标和畸变系数分量的导数。其功能描述与 i=116 段落中的解释相同。
  - projectPoints
```
public static void projectPoints(MatOfPoint3f objectPoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat cameraMatrix,
                                 MatOfDouble distCoeffs,
                                 MatOfPoint2f imagePoints)
```
    将三维点投影到图像平面。
    
    参数
    
    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>。其功能描述与 i=116 段落中的解释相同。
  - solvePnP
```
public static boolean solvePnP(MatOfPoint3f objectPoints,
                               MatOfPoint2f imagePoints,
                               Mat cameraMatrix,
                               MatOfDouble distCoeffs,
                               Mat rvec,
                               Mat tvec,
                               boolean useExtrinsicGuess,
                               int flags)
```
    根据 3D-2D 点对应关系查找物体姿态 \( {}^{c}\mathbf{T}_o \)：![Perspective projection, from object to camera frame](pics/pinhole_homogeneous_transformation.png){ width=50% } SEE: REF: calib3d_solvePnP 此函数返回旋转和平移向量，它们将物体坐标系中的三维点变换到相机坐标系，使用不同方法：
    
    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 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags。有关 Perspective-n-Points 的更多信息，请参见 REF: calib3d_solvePnP。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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 点对应关系查找物体姿态 \( {}^{c}\mathbf{T}_o \)：![Perspective projection, from object to camera frame](pics/pinhole_homogeneous_transformation.png){ width=50% } SEE: REF: calib3d_solvePnP 此函数返回旋转和平移向量，它们将物体坐标系中的三维点变换到相机坐标系，使用不同方法：
    
    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 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。有关 Perspective-n-Points 的更多信息，请参见 REF: calib3d_solvePnP。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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 点对应关系查找物体姿态 \( {}^{c}\mathbf{T}_o \)：![Perspective projection, from object to camera frame](pics/pinhole_homogeneous_transformation.png){ width=50% } SEE: REF: calib3d_solvePnP 此函数返回旋转和平移向量，它们将物体坐标系中的三维点变换到相机坐标系，使用不同方法：
    
    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 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。分别将提供的 rvec 和 tvec 值用作旋转和平移向量的初始近似值，并对其进行进一步优化。有关透视-n-点 (Perspective-n-Points) 的更多信息，请参阅 REF: calib3d_solvePnP 注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 输出向量，包含 objectPoints 和 imagePoints 中的内点索引。
    
    flags - 解决 PnP 问题的方法（参见 REF: solvePnP）。该函数根据一组对象点、其对应的图像投影、摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 输出向量，包含 objectPoints 和 imagePoints 中的内点索引。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。
    
    iterationsCount - 迭代次数。是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #SOLVEPNP_EPNP 方法。
    
    返回
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec,
                                     boolean useExtrinsicGuess)
```
    使用 RANSAC 方案处理错误匹配，从 3D-2D 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。
    
    useExtrinsicGuess - 用于 REF: SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #SOLVEPNP_EPNP 方法。
    
    返回
    
    自动生成
  - solvePnPRansac
```
public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                     MatOfPoint2f imagePoints,
                                     Mat cameraMatrix,
                                     MatOfDouble distCoeffs,
                                     Mat rvec,
                                     Mat tvec)
```
    使用 RANSAC 方案处理错误匹配，从 3D-2D 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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 - 输出平移向量。分别将提供的 rvec 和 tvec 值用作旋转向量和平移向量的初始近似值，并对其进行进一步优化。是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。该函数根据一组对象点、其对应的图像投影、以及摄像机内参矩阵和畸变系数来估计对象姿态。此函数找到的姿态能够最小化重投影误差，即观测投影 imagePoints 与投影（使用 REF: projectPoints）objectPoints 之间的平方距离之和。RANSAC 的使用使得该函数对异常值具有鲁棒性。注意：
    
    有关如何使用 solvePnPRansac 进行对象检测的示例，请参阅 REF: tutorial_real_time_pose
    
    用于估计最小样本集 (Minimal Sample Sets) 步骤的摄像机姿态的默认方法是 #SOLVEPNP_EPNP。例外情况是：
    
    如果您选择 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P，将使用这些方法。
    
    如果输入点数量等于 4，则使用 #SOLVEPNP_P3P。
    
    使用所有内点估计摄像机姿态的方法由 flags 参数定义，除非它等于 #SOLVEPNP_P3P 或 #SOLVEPNP_AP3P。在这种情况下，将改用 #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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：REF: calib3d_solvePnP
    参数
    
    objectPoints - 对象坐标空间中的对象点数组，3x3 1 通道或 1x3/3x1 3 通道。也可以在此处传入 vector<Point3f>。
    
    imagePoints - 对应的图像点数组，3x2 1 通道或 1x3/3x1 2 通道。也可以在此处传入 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 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 - 输入/输出平移向量。输入值用作初始解。
    
    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 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 - 输入/输出平移向量。输入值用作初始解。该函数根据至少 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 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 - 输入/输出平移向量。输入值用作初始解。
    
    criteria - 停止 Levenberg-Marquardt 迭代算法的条件。
    
    VVSlambda - 虚拟视觉伺服控制律的增益，相当于阻尼高斯-牛顿公式中的 \(\alpha\) 增益。该函数根据至少 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 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 - 输入/输出平移向量。输入值用作初始解。
    
    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 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 - 输入/输出平移向量。输入值用作初始解。阻尼高斯-牛顿公式中的增益。该函数根据至少 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 用于初始化迭代 PnP 精炼算法的旋转向量，当 flag 为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时使用。
    
    tvec - 用于初始化迭代 PnP 精炼算法的平移向量，当 flag 为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时使用。
    
    reprojectionError - 可选的重投影误差向量，即输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 用于初始化迭代 PnP 精炼算法的旋转向量，当 flag 为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时使用。
    
    tvec - 用于初始化迭代 PnP 精炼算法的平移向量，当 flag 为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时使用。输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags
    
    rvec - 用于初始化迭代 PnP 精炼算法的旋转向量，当 flag 为 REF: SOLVEPNP_ITERATIVE 且 useExtrinsicGuess 设置为 true 时使用。且 useExtrinsicGuess 设置为 true。输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags 且 useExtrinsicGuess 设置为 true。且 useExtrinsicGuess 设置为 true。输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转向量和平移向量的初始近似值，并对其进行进一步优化。且 useExtrinsicGuess 设置为 true。且 useExtrinsicGuess 设置为 true。输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 点对应关系中找到对象姿态 \( {}^{c}\mathbf{T}_o \)。![透视投影，从对象坐标系到摄像机坐标系](pics/pinhole_homogeneous_transformation.png){ width=50% } 参见：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]
    
    对于所有其他 flags，输入点数量必须 >= 4，对象点可以是任意配置。只返回 1 个解。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数 \(\distcoeffs\) 的输入向量。如果向量为 NULL/空，则假定为零畸变系数。
    
    rvecs - 输出旋转向量（参见 REF: Rodrigues）的向量，它们与 tvecs 一起将点从模型坐标系转换到摄像机坐标系。
    
    tvecs - 输出平移向量的向量。分别将提供的 rvec 和 tvec 值用作旋转向量和平移向量的初始近似值，并对其进行进一步优化。且 useExtrinsicGuess 设置为 true。且 useExtrinsicGuess 设置为 true。输入图像点与使用估计姿态投影的 3D 对象点之间的均方根误差 (RMS)（\( \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} \)）。更多信息在 REF: calib3d_solvePnP 中描述。注意：
    
    在 opencv_source_code/samples/python/plane_ar.py 中可以找到使用 solvePnP 进行平面增强现实的示例。
    
    If you are using Python
    
    Numpy 数组切片不能作为输入，因为 solvePnP 需要连续数组（由 modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 55 行的 cv::Mat::checkVector() 断言强制执行）。
    
    P3P 算法要求图像点为 (N,1,2) 形状的数组，因为它调用了需要 2 通道信息的 #undistortPoints（modules/calib3d/src/solvepnp.cpp 2.4.9 版本大约第 75 行）。
    
    因此，给定一些数据 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。
    
    返回
    
    自动生成
  - 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 Python 脚本（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 Python 脚本（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 类似，但使用通过盒式滤波器近似的局部拉东变换，这种变换对各种噪声更具鲁棒性，在较大图像上速度更快，并且能够直接返回内部棋盘格角点的亚像素位置。该方法基于论文 CITE: duda2018《Accurate Detection and Localization of Checkerboard Corners for Calibration》，证明其返回的亚像素位置比 cornerSubPix 返回的更精确，从而为要求严苛的应用提供了精确的摄像机标定。如果给定标志 REF: CALIB_CB_LARGER 或 REF: CALIB_CB_MARKER，则结果可以从可选的 meta 数组中恢复。这两个标志都有助于使用超出摄像机视野的标定图案。这些超大图案允许更精确的标定，因为可以利用尽可能靠近图像边界的角点。为了在所有图像中保持一致的坐标系，可以使用可选的标记（见下图）将棋盘的原点移动到黑色圆圈所在的位置。注意：该函数要求棋盘格周围有一个与棋盘格一个字段宽度大致相同的白色边框，以改善在各种环境中的检测效果。此外，由于局部拉东变换，对于位于棋盘格外部的字段角点使用圆角是有益的。下图展示了一个为检测优化的示例棋盘格。但是，也可以使用任何其他棋盘格。使用 gen_pattern.py Python 脚本（REF: tutorial_camera_calibration_pattern）创建相应的棋盘格图案：\image html pics/checkerboard_radon.png width=60%
    
    返回
    
    自动生成
  - 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）。目前，内参的初始化（当 REF: CALIB_USE_INTRINSIC_GUESS 未设置时）仅针对平面标定图案（对象点的 Z 坐标必须全为零）实现。只要提供了初始 cameraMatrix，也可以使用 3D 标定设备。该算法执行以下步骤
    
    计算初始内参（该选项仅适用于平面标定图案）或从输入参数中读取。除非指定了 CALIB_FIX_K? 中的某些值，否则畸变系数最初全部设置为零。
    
    估计初始摄像机姿态，如同已知内参一样。这是使用 REF: solvePnP 完成的。
    
    运行全局 Levenberg-Marquardt 优化算法，以最小化重投影误差，即观测特征点 imagePoints 与投影（使用当前摄像机参数和姿态估计）对象点 objectPoints 之间的平方距离总和。有关详细信息，请参阅 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N x 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）。目前，内参的初始化（当 REF: CALIB_USE_INTRINSIC_GUESS 未设置时）仅针对平面标定图案（对象点的 Z 坐标必须全为零）实现。只要提供了初始 cameraMatrix，也可以使用 3D 标定设备。该算法执行以下步骤
    
    计算初始内参（该选项仅适用于平面标定图案）或从输入参数中读取。除非指定了 CALIB_FIX_K? 中的某些值，否则畸变系数最初全部设置为零。
    
    估计初始摄像机姿态，如同已知内参一样。这是使用 REF: solvePnP 完成的。
    
    运行全局 Levenberg-Marquardt 优化算法，以最小化重投影误差，即观测特征点 imagePoints 与投影（使用当前摄像机参数和姿态估计）对象点 objectPoints 之间的平方距离总和。有关详细信息，请参阅 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N x 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）。目前，内参的初始化（当 REF: CALIB_USE_INTRINSIC_GUESS 未设置时）仅针对平面标定图案（对象点的 Z 坐标必须全为零）实现。只要提供了初始 cameraMatrix，也可以使用 3D 标定设备。该算法执行以下步骤
    
    计算初始内参（该选项仅适用于平面标定图案）或从输入参数中读取。除非指定了 CALIB_FIX_K? 中的某些值，否则畸变系数最初全部设置为零。
    
    估计初始摄像机姿态，如同已知内参一样。这是使用 REF: solvePnP 完成的。
    
    运行全局 Levenberg-Marquardt 优化算法，以最小化重投影误差，即观测特征点 imagePoints 与投影（使用当前摄像机参数和姿态估计）对象点 objectPoints 之间的平方距离总和。有关详细信息，请参阅 REF: projectPoints。
    
    注意：如果您使用非方形（即非 N x 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.\) 因此，在给定点在第一个摄像机坐标系中的坐标表示时，可以计算该点在第二个摄像机坐标系中的坐标表示：\(\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.\) 因此，在给定点在第一个摄像机坐标系中的坐标表示时，可以计算该点在第二个摄像机坐标系中的坐标表示：\(\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.\) 因此，在给定点在第一个摄像机坐标系中的坐标表示时，可以计算该点在第二个摄像机坐标系中的坐标表示：\(\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 的操作标志。如果设置此标志，函数会使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。
    
    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。您会看到它们的内部都是有效像素。![图像](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 的操作标志。如果设置此标志，函数会使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。
    
    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。您会看到它们的内部都是有效像素。![图像](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 的操作标志。如果设置此标志，函数会使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。
    
    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。您会看到它们的内部都是有效像素。![图像](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 的操作标志。如果设置此标志，函数会使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。
    
    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。您会看到它们的内部都是有效像素。![图像](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 的操作标志。如果设置此标志，函数会使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。缩放。否则，参数应在 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。您会看到它们的内部都是有效像素。![图像](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）。该函数使每个摄像机的主点在校正后的视图中具有相同的像素坐标。如果未设置此标志，函数可能仍会水平或垂直移动图像（取决于对极线的方向），以最大化有用图像区域。缩放。否则，参数应在 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。您会看到它们的内部都是有效像素。![图像](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}\) 的点）将在计算单应矩阵之前被拒绝。否则，所有点都被视为内点。此函数在不知道相机内参及其在空间中的相对位置的情况下计算校正变换，这也是“uncalibrated”（未校准）后缀的由来。与 #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}\) 的点）将在计算单应矩阵之前被拒绝。否则，所有点都被视为内点。此函数在不知道相机内参及其在空间中的相对位置的情况下计算校正变换，这也是“uncalibrated”（未校准）后缀的由来。与 #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），从2D-3D点对应关系中记录标定目标坐标系和相机坐标系之间的齐次变换（例如） \( \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 至少需要2次具有非平行旋转轴的运动来确定手眼变换。因此至少需要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 - 从齐次矩阵中提取的估计 (3x1) 平移部分，该矩阵将相机坐标系中表示的点变换到夹持器坐标系（\(_{}^{g}\textrm{T}_c\)）。此函数使用各种方法执行手眼标定。一种方法是先估计旋转，然后估计平移（可分离解），已实现的方法包括：
    
    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），从2D-3D点对应关系中记录标定目标坐标系和相机坐标系之间的齐次变换（例如） \( \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 至少需要2次具有非平行旋转轴的运动来确定手眼变换。因此至少需要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 - 从齐次矩阵中提取的估计 (3x3) 旋转部分，该矩阵将机器人基座坐标系中表示的点变换到世界坐标系（\(_{}^{w}\textrm{T}_b\)）。
    
    t_base2world - 从齐次矩阵中提取的估计 (3x1) 平移部分，该矩阵将机器人基座坐标系中表示的点变换到世界坐标系（\(_{}^{w}\textrm{T}_b\)）。
    
    R_gripper2cam - 从齐次矩阵中提取的估计 (3x3) 旋转部分，该矩阵将夹持器坐标系中表示的点变换到相机坐标系（\(_{}^{c}\textrm{T}_g\)）。
    
    t_gripper2cam - 从齐次矩阵中提取的估计 (3x1) 平移部分，该矩阵将夹持器坐标系中表示的点变换到相机坐标系（\(_{}^{c}\textrm{T}_g\)）。
    
    method - 其中一种已实现的机器人-世界/手眼标定方法，详见 cv::RobotWorldHandEyeCalibrationMethod。此函数使用各种方法执行机器人-世界/手眼标定。一种方法是先估计旋转，然后估计平移（可分离解）。
    
    M. Shah, 使用克罗内克积求解机器人-世界/手眼标定问题 \cite Shah2013SolvingTR
    
    另一种方法是同时估计旋转和平移（同时解），已实现的方法包括：
    
    A. Li, L. Wang, and 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），从2D-3D点对应关系中记录标定目标坐标系（世界坐标系）和相机坐标系之间的齐次变换（例如） \( \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\)
    
    \note 至少需要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 - 从齐次矩阵中提取的估计 (3x3) 旋转部分，该矩阵将机器人基座坐标系中表示的点变换到世界坐标系（\(_{}^{w}\textrm{T}_b\)）。
    
    t_base2world - 从齐次矩阵中提取的估计 (3x1) 平移部分，该矩阵将机器人基座坐标系中表示的点变换到世界坐标系（\(_{}^{w}\textrm{T}_b\)）。
    
    R_gripper2cam - 从齐次矩阵中提取的估计 (3x3) 旋转部分，该矩阵将夹持器坐标系中表示的点变换到相机坐标系（\(_{}^{c}\textrm{T}_g\)）。
    
    t_gripper2cam - 从齐次矩阵中提取的估计 (3x1) 平移部分，该矩阵将夹持器坐标系中表示的点变换到相机坐标系（\(_{}^{c}\textrm{T}_g\)）。此函数使用各种方法执行机器人-世界/手眼标定。一种方法是先估计旋转，然后估计平移（可分离解）。
    
    M. Shah, 使用克罗内克积求解机器人-世界/手眼标定问题 \cite Shah2013SolvingTR
    
    另一种方法是同时估计旋转和平移（同时解），已实现的方法包括：
    
    A. Li, L. Wang, and 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），从2D-3D点对应关系中记录标定目标坐标系（世界坐标系）和相机坐标系之间的齐次变换（例如） \( \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\)
    
    \note 至少需要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 - 计算基础矩阵的方法。
    
    REF: FM_7POINT 用于7点算法。\(N = 7\)
    
    REF: FM_8POINT 用于8点算法。\(N \ge 8\)
    
    REF: FM_RANSAC 用于RANSAC算法。\(N \ge 8\)
    
    REF: FM_LMEDS 用于LMedS算法。\(N \ge 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 \times 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 - 计算基础矩阵的方法。
    
    REF: FM_7POINT 用于7点算法。\(N = 7\)
    
    REF: FM_8POINT 用于8点算法。\(N \ge 8\)
    
    REF: FM_RANSAC 用于RANSAC算法。\(N \ge 8\)
    
    REF: FM_LMEDS 用于LMedS算法。\(N \ge 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 \times 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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)
```
    从两幅图像中的对应点计算基本矩阵。
    参数
    
    points1 - 第一幅图像中N个（N >= 5）2D点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二幅图像中的点数组，其大小和格式与 points1 相同。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\)。请注意，此函数假定 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果此假设不适用于您的用例，请使用另一个函数重载或为两台相机使用 P = cv::NoArray() 的 #undistortPoints 来将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵是有效的。当传递这些坐标时，此参数请传递单位矩阵。
    
    method - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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)
```
    从两幅图像中的对应点计算基本矩阵。
    参数
    
    points1 - 第一幅图像中N个（N >= 5）2D点的数组。点坐标应为浮点型（单精度或双精度）。
    
    points2 - 第二幅图像中的点数组，其大小和格式与 points1 相同。
    
    cameraMatrix - 相机内参矩阵 \(\cameramatrix{A}\)。请注意，此函数假定 points1 和 points2 是来自具有相同相机内参矩阵的相机的特征点。如果此假设不适用于您的用例，请使用另一个函数重载或为两台相机使用 P = cv::NoArray() 的 #undistortPoints 来将图像点转换为归一化图像坐标，这些坐标对于单位相机内参矩阵是有效的。当传递这些坐标时，此参数请传递单位矩阵。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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,
                                   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 - 计算基础矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算基础矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算基础矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算基础矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算基础矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 相机的主点。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 是来自具有相同焦距和主点的相机的特征点。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 相同。是来自具有相同焦距和主点的相机的特征点。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。
    
    threshold - 用于RANSAC的参数。它是点到对极线的最大像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。
    
    mask - 包含N个元素的输出数组，其中异常值对应的元素设置为0，其他点设置为1。该数组仅在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,
                                   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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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)
```
    从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
    参数
    
    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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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)
```
    从两幅图像（可能来自两台不同相机）中的对应点计算基本矩阵。
    参数
    
    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/空，则假定为零畸变系数。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为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 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分解（CITE: 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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。
    
    threshold - 用于RANSAC的参数。它是点到对极线的最大像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。
    
    mask - points1 和 points2 中内点的输入/输出掩码。如果非空，则它标记给定本征矩阵 E 下 points1 和 points2 中的内点。仅这些内点将用于恢复位姿。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本征矩阵，然后通过手性检查验证可能的位姿假设。手性检查意味着三角测量得到的3D点应具有正深度。更多细节可在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和 mask。在此场景中，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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。
    
    threshold - 用于RANSAC的参数。它是点到对极线的最大像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。在给定本征矩阵 E 的情况下，points1 和 points2 中的内点。仅这些内点将用于恢复位姿。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本征矩阵，然后通过手性检查验证可能的位姿假设。手性检查意味着三角测量得到的3D点应具有正深度。更多细节可在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和 mask。在此场景中，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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    prob - 仅用于RANSAC或LMedS方法的参数。它指定了估计矩阵正确的期望置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。在给定本征矩阵 E 的情况下，points1 和 points2 中的内点。仅这些内点将用于恢复位姿。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本征矩阵，然后通过手性检查验证可能的位姿假设。手性检查意味着三角测量得到的3D点应具有正深度。更多细节可在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和 mask。在此场景中，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 - 计算本征矩阵的方法。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。在给定本征矩阵 E 的情况下，points1 和 points2 中的内点。仅这些内点将用于恢复位姿。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本征矩阵，然后通过手性检查验证可能的位姿假设。手性检查意味着三角测量得到的3D点应具有正深度。更多细节可在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和 mask。在此场景中，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 是平移向量的方向，且具有单位长度。
    
    REF: RANSAC 用于RANSAC算法。
    
    REF: LMEDS 用于LMedS算法。
    
    估计矩阵正确的置信水平（概率）。点到对极线的像素距离，超出此距离的点将被视为异常值，不用于计算最终的基础矩阵。此值可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。在给定本征矩阵 E 的情况下，points1 和 points2 中的内点。仅这些内点将用于恢复位姿。输出掩码中只有通过手性检查的内点。此函数使用 REF: decomposeEssentialMat 分解本征矩阵，然后通过手性检查验证可能的位姿假设。手性检查意味着三角测量得到的3D点应具有正深度。更多细节可在 CITE: Nister03 中找到。此函数可用于处理 REF: findEssentialMat 的输出 E 和 mask。在此场景中，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 和 mask。在此场景中，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 和 mask。在此场景中，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 \times 1\) 或 \(1 \times N\) 矩阵，或 vector<Point2f>。
    
    whichImage - 包含点的图像索引（1或2）。
    
    F - 基础矩阵，可以使用 #findFundamentalMat 或 #stereoRectify 估计。
    
    lines - 输出向量，包含另一幅图像中与点对应的对极线。每条线 \(ax + by + c=0\) 由3个数字 \((a, b, c)\) 编码。对于立体对的两幅图像中的每个点，此函数在另一幅图像中找到对应对极线的方程。根据基础矩阵定义（参见 #findFundamentalMat），第二幅图像中点 \(p^{(1)}_i\) 对应的对极线 \(l^{(2)}_i\)（当 whichImage=1 时）计算为：\(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 的投影矩阵，则返回的点在第一相机的校正坐标系中表示。SEE: 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)
```
    Filters off small noise blobs (speckles) in the disparity map
    
    参数
    
    img - 输入的16位有符号视差图像。
    
    newVal - 用于清除斑点的视差值。
    
    maxSpeckleSize - 视为斑点的最大斑点尺寸。更大的斑点不会受算法影响。
    
    maxDiff - 相邻视差像素之间的最大差异，用于将它们归入同一斑点。请注意，由于 StereoBM、StereoSGBM 和其他算法可能会返回固定点视差图（其中视差值乘以16），因此在指定此参数值时应考虑此比例因子。
    
    buf - 可选的临时缓冲区，以避免函数内部的内存分配。
  - filterSpeckles
```
public static void filterSpeckles(Mat img,
                                  double newVal,
                                  int maxSpeckleSize,
                                  double maxDiff)
```
    Filters off small noise blobs (speckles) in the disparity map
    
    参数
    
    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 - \(4 \times 4\) 透视变换矩阵，可通过 REF: stereoRectify 获得。
    
    handleMissingValues - 指示函数是否应处理缺失值（即未计算视差的点）。如果 handleMissingValues=true，则对应于异常值（参见 StereoMatcher::compute）的最小视差像素将转换为具有非常大Z值（当前设置为10000）的3D点。
    
    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}.\) SEE: 要将稀疏点集 {(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 - \(4 \times 4\) 透视变换矩阵，可通过 REF: stereoRectify 获得。
    
    handleMissingValues - 指示函数是否应处理缺失值（即未计算视差的点）。如果 handleMissingValues=true，则对应于异常值（参见 StereoMatcher::compute）的最小视差像素将转换为具有非常大Z值（当前设置为10000）的3D点。深度。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}.\) SEE: 要将稀疏点集 {(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 - \(4 \times 4\) 透视变换矩阵，可通过 REF: stereoRectify 获得。未计算视差的点）。如果 handleMissingValues=true，则对应于异常值（参见 StereoMatcher::compute）的最小视差像素将转换为具有非常大Z值（当前设置为10000）的3D点。深度。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}.\) SEE: 要将稀疏点集 {(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 - 基础矩阵。
    
    返回
    
    The computed Sampson distance.
  - 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 - 形式为 \( \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} \) 的输出3D仿射变换矩阵 \(3 \times 4\)。
    
    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 - 形式为 \( \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} \) 的输出3D仿射变换矩阵 \(3 \times 4\)。
    
    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 - 形式为 \( \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} \) 的输出3D仿射变换矩阵 \(3 \times 4\)。
    
    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 - 如果为 true，则返回的旋转将永远不是反射。这可能是非期望的，例如在优化左右手坐标系之间的变换时。
    
    返回
    
    形式为 \(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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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将禁用精炼，因此输出矩阵将是鲁棒方法的输出。
    
    返回
    
    输出2D仿射变换（4个自由度）矩阵 \(2 \times 3\)，如果无法估计变换则为空矩阵。此函数使用选定的鲁棒算法，估计具有4个自由度（仅限于平移、旋转和均匀缩放组合）的最优2D仿射变换。然后，使用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%时才能正常工作。SEE: 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 对源图像点 \(p_i\) 和目标图像点 \(p'_i\) 给出约束 \(s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\)，那么 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{Undistortion} \\\scriptsize{\textit{though equation shown is for radial undistortion, function implements 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{Rectification}\\ {[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{only performed if P is specified:} \\ 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{only performed if P is specified:} \\ 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{only performed if P is specified:} \\ 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)
```
    使用鱼眼模型扭曲 2D 点。
    
    参数
    
    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)
```
    使用鱼眼模型扭曲 2D 点。
    
    参数
    
    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)
```
    使用鱼眼模型对2D点进行去畸变。
    
    参数
    
    distorted - 对象点数组，1xN/Nx1双通道（或vector<Point2f>），其中N是视图中的点数。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 畸变系数输入向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3单通道，或向量：3x1/1x3单通道或1x1 3通道
    
    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)
```
    使用鱼眼模型对2D点进行去畸变。
    
    参数
    
    distorted - 对象点数组，1xN/Nx1双通道（或vector<Point2f>），其中N是视图中的点数。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 畸变系数输入向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3单通道，或向量：3x1/1x3单通道或1x1 3通道
    
    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)
```
    使用鱼眼模型对2D点进行去畸变。
    
    参数
    
    distorted - 对象点数组，1xN/Nx1双通道（或vector<Point2f>），其中N是视图中的点数。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 畸变系数输入向量 \(\distcoeffsfisheye\)。
    
    R - 对象空间中的校正变换：3x3单通道，或向量：3x1/1x3单通道或1x1 3通道
    
    undistorted - 图像点的输出数组，1xN/Nx1双通道，或vector<Point2f>。
  - fisheye_undistortPoints
```
public static void fisheye_undistortPoints(Mat distorted,
                                           Mat undistorted,
                                           Mat K,
                                           Mat D)
```
    使用鱼眼模型对2D点进行去畸变。
    
    参数
    
    distorted - 对象点数组，1xN/Nx1双通道（或vector<Point2f>），其中N是视图中的点数。
    
    K - 相机内参矩阵 \(\cameramatrix{K}\)。
    
    D - 畸变系数输入向量 \(\distcoeffsfisheye\)。1通道或1x1 3通道
    
    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 3通道
    
    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（双线性插值）。有关执行的变换的详细信息，请参阅前一个函数。去畸变图像的结果如下所示。
    
    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（双线性插值）。有关执行的变换的详细信息，请参阅前一个函数。去畸变图像的结果如下所示。
    
    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（双线性插值）。有关执行的变换的详细信息，请参阅前一个函数。去畸变图像的结果如下所示。
    
    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 3通道
    
    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 3通道
    
    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 3通道
    
    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 3通道
    
    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()必须等于objectPoints[i].size()（对于每个i）。
    
    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()必须等于objectPoints[i].size()（对于每个i）。
    
    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()必须等于objectPoints[i].size()（对于每个i）。
    
    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。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其当存在较大径向畸变时。长度。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)
```
    鱼眼相机模型的立体校正。
    
    参数
    
    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。如果设置了该标志，函数将使每个相机的主点在校正后的视图中具有相同的像素坐标。如果未设置该标志，函数仍可能在水平或垂直方向上（取决于对极线的方向）移动图像，以最大化有用图像区域。这里可以传入#initUndistortRectifyMap（参见OpenCV示例目录中的stereo_calib.cpp示例）。当传入(0,0)（默认）时，它被设置为原始imageSize。将其设置为更大的值可以帮助您保留原始图像中的细节，尤其当存在较大径向畸变时。长度。balance在[0, 1]范围内。
  - 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 - 畸变系数输入/输出向量 \(\distcoeffsfisheye\)，包含4个元素。
    
    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 - 畸变系数输入/输出向量 \(\distcoeffsfisheye\)，包含4个元素。
    
    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 - 畸变系数输入/输出向量 \(\distcoeffsfisheye\)，包含4个元素。
    
    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)
```
    对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
    
    参数
    
    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 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决 PnP 问题的方法：参见 REF: calib3d_solvePnP_flags
    
    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)
```
    对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
    
    参数
    
    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 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    flags - 解决PnP问题的方法：参见REF: calib3d_solvePnP_flags。该函数内部通过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)
```
    对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
    
    参数
    
    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的参数。如果为true (1)，函数将使用提供的rvec和tvec值作为旋转向量和平移向量的初始近似值，并进一步优化它们。该函数内部通过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)
```
    对于鱼眼相机模型，从三维-二维点对应关系中找到物体姿态。
    
    参数
    
    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值作为旋转向量和平移向量的初始近似值，并进一步优化它们。该函数内部通过REF: undistortPoints 去畸变点并调用REF: cv::solvePnP，因此输入非常相似。有关透视-n-点问题的更多信息，请参阅REF: calib3d_solvePnP。
    
    返回
    
    自动生成
  - fisheye_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount,
                                             float reprojectionError,
                                             double confidence,
                                             Mat inliers,
                                             int flags,
                                             TermCriteria criteria)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 输出向量，包含 objectPoints 和 imagePoints 中的内点索引。
    
    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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount,
                                             float reprojectionError,
                                             double confidence,
                                             Mat inliers,
                                             int flags)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 输出向量，包含 objectPoints 和 imagePoints 中的内点索引。
    
    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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount,
                                             float reprojectionError,
                                             double confidence,
                                             Mat inliers)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。
    
    inliers - 输出向量，包含objectPoints和imagePoints中内点的索引。此函数使用不同的方法返回将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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount,
                                             float reprojectionError,
                                             double confidence)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC 过程中使用的内点阈值。该参数值是观测点投影与计算点投影之间允许的最大距离，超过此距离则不被视为内点。
    
    confidence - 算法产生有用结果的概率。此函数使用不同的方法返回将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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount,
                                             float reprojectionError)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。
    
    reprojectionError - RANSAC过程中使用的内点阈值。参数值是观测点和计算点投影之间的最大允许距离，以将其视为内点。此函数使用不同的方法返回将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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess,
                                             int iterationsCount)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于 #SOLVEPNP_ITERATIVE 的参数。如果为 true (1)，函数将使用提供的 rvec 和 tvec 值作为旋转和平移向量的初始近似值，并进一步优化它们。
    
    iterationsCount - 迭代次数。是观测点和计算点投影之间的最大允许距离，以将其视为内点。此函数使用不同的方法返回将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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec,
                                             boolean useExtrinsicGuess)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 N 是点数。vector<Point2d> 也可以在此处传入。
    
    cameraMatrix - 输入相机内参矩阵 \(\cameramatrix{A}\)。
    
    distCoeffs - 畸变系数输入向量（4x1/1x4）。
    
    rvec - 输出旋转向量（参见 REF: Rodrigues），它与 tvec 一起将点从模型坐标系带到相机坐标系。
    
    tvec - 输出平移向量。
    
    useExtrinsicGuess - 用于#SOLVEPNP_ITERATIVE的参数。如果为true (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_solvePnPRansac
```
public static boolean fisheye_solvePnPRansac(Mat objectPoints,
                                             Mat imagePoints,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             Mat rvec,
                                             Mat tvec)
```
    使用RANSAC方案，从3D-2D点对应关系中为鱼眼相机模型找到对象姿态。
    参数
    
    objectPoints - 物体坐标空间中的物体点数组，Nx3 单通道或 1xN/Nx1 三通道，其中 N 是点数。vector<Point3d> 也可以在此处传入。
    
    imagePoints - 相应的图像点数组，Nx2 单通道或 1xN/Nx1 双通道，其中 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