org.opencv.calib3d

## Class Calib3d

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

-     public class Calib3d
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `CALIB_CB_ADAPTIVE_THRESH`
    `static int` | `CALIB_CB_ASYMMETRIC_GRID`
    `static int` | `CALIB_CB_CLUSTERING`
    `static int` | `CALIB_CB_FAST_CHECK`
    `static int` | `CALIB_CB_FILTER_QUADS`
    `static int` | `CALIB_CB_NORMALIZE_IMAGE`
    `static int` | `CALIB_CB_SYMMETRIC_GRID`
    `static int` | `CALIB_CHECK_COND`
    `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_SKEW`
    `static int` | `CALIB_FIX_TANGENT_DIST`
    `static int` | `CALIB_FIX_TAUX_TAUY`
    `static int` | `CALIB_RATIONAL_MODEL`
    `static int` | `CALIB_RECOMPUTE_EXTRINSIC`
    `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` | `CV_DLS`
    `static int` | `CV_EPNP`
    `static int` | `CV_ITERATIVE`
    `static int` | `CV_P3P`
    `static int` | `fisheye_CALIB_CHECK_COND`
    `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` | `FM_7POINT`
    `static int` | `FM_8POINT`
    `static int` | `FM_LMEDS`
    `static int` | `FM_RANSAC`
    `static int` | `LMEDS`
    `static int` | `RANSAC`
    `static int` | `RHO`
    `static int` | `SOLVEPNP_AP3P`
    `static int` | `SOLVEPNP_DLS`
    `static int` | `SOLVEPNP_EPNP`
    `static int` | `SOLVEPNP_ITERATIVE`
    `static int` | `SOLVEPNP_MAX_COUNT`
    `static int` | `SOLVEPNP_P3P`
    `static int` | `SOLVEPNP_UPNP`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Calib3d()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static double` | `calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`
    `static double` | `calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
    `static double` | `calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`
    `static double` | `calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
    `static double` | `calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags)`
    `static double` | `calibrateCameraExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
    `static void` | `calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio)`
    `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 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 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)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)`
    `static Mat` | `estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`
    `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)`
    `static void` | `filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf)`
    `static boolean` | `findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners)`
    `static boolean` | `findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags)`
    `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, 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, Mat mask)`
    `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, Mat mask)`
    `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 double` | `fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`
    `static double` | `fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
    `static double` | `fisheye_calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`
    `static void` | `fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)`
    `static void` | `fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)`
    `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)`
    `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 double` | `fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T)`
    `static double` | `fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags)`
    `static double` | `fisheye_stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags, TermCriteria criteria)`
    `static 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)`
    `static void` | `fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R)`
    `static void` | `fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P)`
    `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)`
    `static Rect` | `getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)`
    `static Mat` | `initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize)`
    `static Mat` | `initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize, double aspectRatio)`
    `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 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)`
    `static void` | `reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)`
    `static void` | `reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues)`
    `static void` | `reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)`
    `static void` | `Rodrigues(Mat src, Mat dst)`
    `static void` | `Rodrigues(Mat src, Mat dst, Mat jacobian)`
    `static double[]` | `RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)`
    `static double[]` | `RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx)`
    `static double[]` | `RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy)`
    `static double[]` | `RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)`
    `static double` | `sampsonDistance(Mat pt1, Mat pt2, Mat F)`
    `static int` | `solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
    `static boolean` | `solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`
    `static boolean` | `solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
    `static boolean` | `solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)`
    `static boolean` | `solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)`
    `static boolean` | `solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
    `static boolean` | `solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount)`
    `static boolean` | `solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError)`
    `static boolean` | `solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence)`
    `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)`
    `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)`
    `static double` | `stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)`
    `static double` | `stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags)`
    `static double` | `stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria)`
    `static double` | `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, Mat perViewErrors)`
    `static double` | `stereoCalibrateExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags)`
    `static double` | `stereoCalibrateExtended(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, 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` | `validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities)`
    `static void` | `validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### CALIB_USE_INTRINSIC_GUESS

          public static final int CALIB_USE_INTRINSIC_GUESS

      See Also:
        Constant Field Values

    - #### CALIB_RECOMPUTE_EXTRINSIC

          public static final int CALIB_RECOMPUTE_EXTRINSIC

      See Also:
        Constant Field Values

    - #### CALIB_CHECK_COND

          public static final int CALIB_CHECK_COND

      See Also:
        Constant Field Values

    - #### CALIB_FIX_SKEW

          public static final int CALIB_FIX_SKEW

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K1

          public static final int CALIB_FIX_K1

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K2

          public static final int CALIB_FIX_K2

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K3

          public static final int CALIB_FIX_K3

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K4

          public static final int CALIB_FIX_K4

      See Also:
        Constant Field Values

    - #### CALIB_FIX_INTRINSIC

          public static final int CALIB_FIX_INTRINSIC

      See Also:
        Constant Field Values

    - #### CV_ITERATIVE

          public static final int CV_ITERATIVE

      See Also:
        Constant Field Values

    - #### CV_EPNP

          public static final int CV_EPNP

      See Also:
        Constant Field Values

    - #### CV_P3P

          public static final int CV_P3P

      See Also:
        Constant Field Values

    - #### CV_DLS

          public static final int CV_DLS

      See Also:
        Constant Field Values

    - #### LMEDS

          public static final int LMEDS

      See Also:
        Constant Field Values

    - #### RANSAC

          public static final int RANSAC

      See Also:
        Constant Field Values

    - #### RHO

          public static final int RHO

      See Also:
        Constant Field Values

    - #### SOLVEPNP_ITERATIVE

          public static final int SOLVEPNP_ITERATIVE

      See Also:
        Constant Field Values

    - #### SOLVEPNP_EPNP

          public static final int SOLVEPNP_EPNP

      See Also:
        Constant Field Values

    - #### SOLVEPNP_P3P

          public static final int SOLVEPNP_P3P

      See Also:
        Constant Field Values

    - #### SOLVEPNP_DLS

          public static final int SOLVEPNP_DLS

      See Also:
        Constant Field Values

    - #### SOLVEPNP_UPNP

          public static final int SOLVEPNP_UPNP

      See Also:
        Constant Field Values

    - #### SOLVEPNP_AP3P

          public static final int SOLVEPNP_AP3P

      See Also:
        Constant Field Values

    - #### SOLVEPNP_MAX_COUNT

          public static final int SOLVEPNP_MAX_COUNT

      See Also:
        Constant Field Values

    - #### CALIB_CB_ADAPTIVE_THRESH

          public static final int CALIB_CB_ADAPTIVE_THRESH

      See Also:
        Constant Field Values

    - #### CALIB_CB_NORMALIZE_IMAGE

          public static final int CALIB_CB_NORMALIZE_IMAGE

      See Also:
        Constant Field Values

    - #### CALIB_CB_FILTER_QUADS

          public static final int CALIB_CB_FILTER_QUADS

      See Also:
        Constant Field Values

    - #### CALIB_CB_FAST_CHECK

          public static final int CALIB_CB_FAST_CHECK

      See Also:
        Constant Field Values

    - #### CALIB_CB_SYMMETRIC_GRID

          public static final int CALIB_CB_SYMMETRIC_GRID

      See Also:
        Constant Field Values

    - #### CALIB_CB_ASYMMETRIC_GRID

          public static final int CALIB_CB_ASYMMETRIC_GRID

      See Also:
        Constant Field Values

    - #### CALIB_CB_CLUSTERING

          public static final int CALIB_CB_CLUSTERING

      See Also:
        Constant Field Values

    - #### CALIB_FIX_ASPECT_RATIO

          public static final int CALIB_FIX_ASPECT_RATIO

      See Also:
        Constant Field Values

    - #### CALIB_FIX_PRINCIPAL_POINT

          public static final int CALIB_FIX_PRINCIPAL_POINT

      See Also:
        Constant Field Values

    - #### CALIB_ZERO_TANGENT_DIST

          public static final int CALIB_ZERO_TANGENT_DIST

      See Also:
        Constant Field Values

    - #### CALIB_FIX_FOCAL_LENGTH

          public static final int CALIB_FIX_FOCAL_LENGTH

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K5

          public static final int CALIB_FIX_K5

      See Also:
        Constant Field Values

    - #### CALIB_FIX_K6

          public static final int CALIB_FIX_K6

      See Also:
        Constant Field Values

    - #### CALIB_RATIONAL_MODEL

          public static final int CALIB_RATIONAL_MODEL

      See Also:
        Constant Field Values

    - #### CALIB_THIN_PRISM_MODEL

          public static final int CALIB_THIN_PRISM_MODEL

      See Also:
        Constant Field Values

    - #### CALIB_FIX_S1_S2_S3_S4

          public static final int CALIB_FIX_S1_S2_S3_S4

      See Also:
        Constant Field Values

    - #### CALIB_TILTED_MODEL

          public static final int CALIB_TILTED_MODEL

      See Also:
        Constant Field Values

    - #### CALIB_FIX_TAUX_TAUY

          public static final int CALIB_FIX_TAUX_TAUY

      See Also:
        Constant Field Values

    - #### CALIB_USE_QR

          public static final int CALIB_USE_QR

      See Also:
        Constant Field Values

    - #### CALIB_FIX_TANGENT_DIST

          public static final int CALIB_FIX_TANGENT_DIST

      See Also:
        Constant Field Values

    - #### CALIB_SAME_FOCAL_LENGTH

          public static final int CALIB_SAME_FOCAL_LENGTH

      See Also:
        Constant Field Values

    - #### CALIB_ZERO_DISPARITY

          public static final int CALIB_ZERO_DISPARITY

      See Also:
        Constant Field Values

    - #### CALIB_USE_LU

          public static final int CALIB_USE_LU

      See Also:
        Constant Field Values

    - #### CALIB_USE_EXTRINSIC_GUESS

          public static final int CALIB_USE_EXTRINSIC_GUESS

      See Also:
        Constant Field Values

    - #### FM_7POINT

          public static final int FM_7POINT

      See Also:
        Constant Field Values

    - #### FM_8POINT

          public static final int FM_8POINT

      See Also:
        Constant Field Values

    - #### FM_LMEDS

          public static final int FM_LMEDS

      See Also:
        Constant Field Values

    - #### FM_RANSAC

          public static final int FM_RANSAC

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_USE_INTRINSIC_GUESS

          public static final int fisheye_CALIB_USE_INTRINSIC_GUESS

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_RECOMPUTE_EXTRINSIC

          public static final int fisheye_CALIB_RECOMPUTE_EXTRINSIC

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_CHECK_COND

          public static final int fisheye_CALIB_CHECK_COND

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_SKEW

          public static final int fisheye_CALIB_FIX_SKEW

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_K1

          public static final int fisheye_CALIB_FIX_K1

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_K2

          public static final int fisheye_CALIB_FIX_K2

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_K3

          public static final int fisheye_CALIB_FIX_K3

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_K4

          public static final int fisheye_CALIB_FIX_K4

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_INTRINSIC

          public static final int fisheye_CALIB_FIX_INTRINSIC

      See Also:
        Constant Field Values

    - #### fisheye_CALIB_FIX_PRINCIPAL_POINT

          public static final int fisheye_CALIB_FIX_PRINCIPAL_POINT

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Calib3d

          public Calib3d()

  - ### Method Detail

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers,
                                             int method,
                                             double ransacReprojThreshold,
                                             long maxIters,
                                             double confidence,
                                             long refineIters)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers,
                                             int method,
                                             double ransacReprojThreshold,
                                             long maxIters,
                                             double confidence)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers,
                                             int method,
                                             double ransacReprojThreshold,
                                             long maxIters)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers,
                                             int method,
                                             double ransacReprojThreshold)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers,
                                             int method)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to,
                                             Mat inliers)

    - #### estimateAffine2D

          public static Mat estimateAffine2D(Mat from,
                                             Mat to)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers,
                                                    int method,
                                                    double ransacReprojThreshold,
                                                    long maxIters,
                                                    double confidence,
                                                    long refineIters)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers,
                                                    int method,
                                                    double ransacReprojThreshold,
                                                    long maxIters,
                                                    double confidence)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers,
                                                    int method,
                                                    double ransacReprojThreshold,
                                                    long maxIters)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers,
                                                    int method,
                                                    double ransacReprojThreshold)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers,
                                                    int method)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to,
                                                    Mat inliers)

    - #### estimateAffinePartial2D

          public static Mat estimateAffinePartial2D(Mat from,
                                                    Mat to)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             Mat cameraMatrix,
                                             int method,
                                             double prob,
                                             double threshold,
                                             Mat mask)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             Mat cameraMatrix,
                                             int method,
                                             double prob,
                                             double threshold)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             Mat cameraMatrix,
                                             int method,
                                             double prob)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             Mat cameraMatrix,
                                             int method)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             Mat cameraMatrix)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal,
                                             Point pp,
                                             int method,
                                             double prob,
                                             double threshold,
                                             Mat mask)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal,
                                             Point pp,
                                             int method,
                                             double prob,
                                             double threshold)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal,
                                             Point pp,
                                             int method,
                                             double prob)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal,
                                             Point pp,
                                             int method)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal,
                                             Point pp)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2,
                                             double focal)

    - #### findEssentialMat

          public static Mat findEssentialMat(Mat points1,
                                             Mat points2)

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

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints,
                                           int method,
                                           double ransacReprojThreshold,
                                           Mat mask,
                                           int maxIters,
                                           double confidence)

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints,
                                           int method,
                                           double ransacReprojThreshold,
                                           Mat mask,
                                           int maxIters)

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints,
                                           int method,
                                           double ransacReprojThreshold,
                                           Mat mask)

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints,
                                           int method,
                                           double ransacReprojThreshold)

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints,
                                           int method)

    - #### findHomography

          public static Mat findHomography(MatOfPoint2f srcPoints,
                                           MatOfPoint2f dstPoints)

    - #### getOptimalNewCameraMatrix

          public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                                      Mat distCoeffs,
                                                      Size imageSize,
                                                      double alpha,
                                                      Size newImgSize,
                                                      Rect validPixROI,
                                                      boolean centerPrincipalPoint)

    - #### getOptimalNewCameraMatrix

          public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                                      Mat distCoeffs,
                                                      Size imageSize,
                                                      double alpha,
                                                      Size newImgSize,
                                                      Rect validPixROI)

    - #### getOptimalNewCameraMatrix

          public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                                      Mat distCoeffs,
                                                      Size imageSize,
                                                      double alpha,
                                                      Size newImgSize)

    - #### getOptimalNewCameraMatrix

          public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix,
                                                      Mat distCoeffs,
                                                      Size imageSize,
                                                      double alpha)

    - #### initCameraMatrix2D

          public static Mat initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints,
                                               java.util.List<MatOfPoint2f> imagePoints,
                                               Size imageSize,
                                               double aspectRatio)

    - #### initCameraMatrix2D

          public static Mat initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints,
                                               java.util.List<MatOfPoint2f> imagePoints,
                                               Size imageSize)

    - #### getValidDisparityROI

          public static Rect getValidDisparityROI(Rect roi1,
                                                  Rect roi2,
                                                  int minDisparity,
                                                  int numberOfDisparities,
                                                  int SADWindowSize)

    - #### RQDecomp3x3

          public static double[] RQDecomp3x3(Mat src,
                                             Mat mtxR,
                                             Mat mtxQ,
                                             Mat Qx,
                                             Mat Qy,
                                             Mat Qz)

    - #### RQDecomp3x3

          public static double[] RQDecomp3x3(Mat src,
                                             Mat mtxR,
                                             Mat mtxQ,
                                             Mat Qx,
                                             Mat Qy)

    - #### RQDecomp3x3

          public static double[] RQDecomp3x3(Mat src,
                                             Mat mtxR,
                                             Mat mtxQ,
                                             Mat Qx)

    - #### RQDecomp3x3

          public static double[] RQDecomp3x3(Mat src,
                                             Mat mtxR,
                                             Mat mtxQ)

    - #### findChessboardCorners

          public static boolean findChessboardCorners(Mat image,
                                                      Size patternSize,
                                                      MatOfPoint2f corners,
                                                      int flags)

    - #### findChessboardCorners

          public static boolean findChessboardCorners(Mat image,
                                                      Size patternSize,
                                                      MatOfPoint2f corners)

    - #### findCirclesGrid

          public static boolean findCirclesGrid(Mat image,
                                                Size patternSize,
                                                Mat centers,
                                                int flags)

    - #### findCirclesGrid

          public static boolean findCirclesGrid(Mat image,
                                                Size patternSize,
                                                Mat centers)

    - #### solvePnP

          public static boolean solvePnP(MatOfPoint3f objectPoints,
                                         MatOfPoint2f imagePoints,
                                         Mat cameraMatrix,
                                         MatOfDouble distCoeffs,
                                         Mat rvec,
                                         Mat tvec,
                                         boolean useExtrinsicGuess,
                                         int flags)

    - #### solvePnP

          public static boolean solvePnP(MatOfPoint3f objectPoints,
                                         MatOfPoint2f imagePoints,
                                         Mat cameraMatrix,
                                         MatOfDouble distCoeffs,
                                         Mat rvec,
                                         Mat tvec,
                                         boolean useExtrinsicGuess)

    - #### solvePnP

          public static boolean solvePnP(MatOfPoint3f objectPoints,
                                         MatOfPoint2f imagePoints,
                                         Mat cameraMatrix,
                                         MatOfDouble distCoeffs,
                                         Mat rvec,
                                         Mat tvec)

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

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

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

    - #### solvePnPRansac

          public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                               MatOfPoint2f imagePoints,
                                               Mat cameraMatrix,
                                               MatOfDouble distCoeffs,
                                               Mat rvec,
                                               Mat tvec,
                                               boolean useExtrinsicGuess,
                                               int iterationsCount,
                                               float reprojectionError)

    - #### solvePnPRansac

          public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                               MatOfPoint2f imagePoints,
                                               Mat cameraMatrix,
                                               MatOfDouble distCoeffs,
                                               Mat rvec,
                                               Mat tvec,
                                               boolean useExtrinsicGuess,
                                               int iterationsCount)

    - #### solvePnPRansac

          public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                               MatOfPoint2f imagePoints,
                                               Mat cameraMatrix,
                                               MatOfDouble distCoeffs,
                                               Mat rvec,
                                               Mat tvec,
                                               boolean useExtrinsicGuess)

    - #### solvePnPRansac

          public static boolean solvePnPRansac(MatOfPoint3f objectPoints,
                                               MatOfPoint2f imagePoints,
                                               Mat cameraMatrix,
                                               MatOfDouble distCoeffs,
                                               Mat rvec,
                                               Mat tvec)

    - #### stereoRectifyUncalibrated

          public static boolean stereoRectifyUncalibrated(Mat points1,
                                                          Mat points2,
                                                          Mat F,
                                                          Size imgSize,
                                                          Mat H1,
                                                          Mat H2,
                                                          double threshold)

    - #### stereoRectifyUncalibrated

          public static boolean stereoRectifyUncalibrated(Mat points1,
                                                          Mat points2,
                                                          Mat F,
                                                          Size imgSize,
                                                          Mat H1,
                                                          Mat H2)

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

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

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

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

    - #### sampsonDistance

          public static double sampsonDistance(Mat pt1,
                                               Mat pt2,
                                               Mat F)

    - #### 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,
                                                       Mat perViewErrors,
                                                       int flags,
                                                       TermCriteria criteria)

    - #### 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,
                                                       Mat perViewErrors,
                                                       int flags)

    - #### 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,
                                                       Mat perViewErrors)

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

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

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

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

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

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

    - #### decomposeHomographyMat

          public static int decomposeHomographyMat(Mat H,
                                                   Mat K,
                                                   java.util.List<Mat> rotations,
                                                   java.util.List<Mat> translations,
                                                   java.util.List<Mat> normals)

    - #### estimateAffine3D

          public static int estimateAffine3D(Mat src,
                                             Mat dst,
                                             Mat out,
                                             Mat inliers,
                                             double ransacThreshold,
                                             double confidence)

    - #### estimateAffine3D

          public static int estimateAffine3D(Mat src,
                                             Mat dst,
                                             Mat out,
                                             Mat inliers,
                                             double ransacThreshold)

    - #### estimateAffine3D

          public static int estimateAffine3D(Mat src,
                                             Mat dst,
                                             Mat out,
                                             Mat inliers)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat R,
                                        Mat t,
                                        double focal,
                                        Point pp,
                                        Mat mask)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat R,
                                        Mat t,
                                        double focal,
                                        Point pp)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat R,
                                        Mat t,
                                        double focal)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat R,
                                        Mat t)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat cameraMatrix,
                                        Mat R,
                                        Mat t,
                                        Mat mask)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat cameraMatrix,
                                        Mat R,
                                        Mat t)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat cameraMatrix,
                                        Mat R,
                                        Mat t,
                                        double distanceThresh,
                                        Mat mask,
                                        Mat triangulatedPoints)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat cameraMatrix,
                                        Mat R,
                                        Mat t,
                                        double distanceThresh,
                                        Mat mask)

    - #### recoverPose

          public static int recoverPose(Mat E,
                                        Mat points1,
                                        Mat points2,
                                        Mat cameraMatrix,
                                        Mat R,
                                        Mat t,
                                        double distanceThresh)

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

    - #### Rodrigues

          public static void Rodrigues(Mat src,
                                       Mat dst,
                                       Mat jacobian)

    - #### Rodrigues

          public static void Rodrigues(Mat src,
                                       Mat dst)

    - #### calibrationMatrixValues

          public static void calibrationMatrixValues(Mat cameraMatrix,
                                                     Size imageSize,
                                                     double apertureWidth,
                                                     double apertureHeight,
                                                     double[] fovx,
                                                     double[] fovy,
                                                     double[] focalLength,
                                                     Point principalPoint,
                                                     double[] aspectRatio)

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

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

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

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

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

    - #### composeRT

          public static void composeRT(Mat rvec1,
                                       Mat tvec1,
                                       Mat rvec2,
                                       Mat tvec2,
                                       Mat rvec3,
                                       Mat tvec3,
                                       Mat dr3dr1,
                                       Mat dr3dt1,
                                       Mat dr3dr2)

    - #### composeRT

          public static void composeRT(Mat rvec1,
                                       Mat tvec1,
                                       Mat rvec2,
                                       Mat tvec2,
                                       Mat rvec3,
                                       Mat tvec3,
                                       Mat dr3dr1,
                                       Mat dr3dt1)

    - #### composeRT

          public static void composeRT(Mat rvec1,
                                       Mat tvec1,
                                       Mat rvec2,
                                       Mat tvec2,
                                       Mat rvec3,
                                       Mat tvec3,
                                       Mat dr3dr1)

    - #### composeRT

          public static void composeRT(Mat rvec1,
                                       Mat tvec1,
                                       Mat rvec2,
                                       Mat tvec2,
                                       Mat rvec3,
                                       Mat tvec3)

    - #### computeCorrespondEpilines

          public static void computeCorrespondEpilines(Mat points,
                                                       int whichImage,
                                                       Mat F,
                                                       Mat lines)

    - #### convertPointsFromHomogeneous

          public static void convertPointsFromHomogeneous(Mat src,
                                                          Mat dst)

    - #### convertPointsToHomogeneous

          public static void convertPointsToHomogeneous(Mat src,
                                                        Mat dst)

    - #### correctMatches

          public static void correctMatches(Mat F,
                                            Mat points1,
                                            Mat points2,
                                            Mat newPoints1,
                                            Mat newPoints2)

    - #### decomposeEssentialMat

          public static void decomposeEssentialMat(Mat E,
                                                   Mat R1,
                                                   Mat R2,
                                                   Mat t)

    - #### decomposeProjectionMatrix

          public static void decomposeProjectionMatrix(Mat projMatrix,
                                                       Mat cameraMatrix,
                                                       Mat rotMatrix,
                                                       Mat transVect,
                                                       Mat rotMatrixX,
                                                       Mat rotMatrixY,
                                                       Mat rotMatrixZ,
                                                       Mat eulerAngles)

    - #### decomposeProjectionMatrix

          public static void decomposeProjectionMatrix(Mat projMatrix,
                                                       Mat cameraMatrix,
                                                       Mat rotMatrix,
                                                       Mat transVect,
                                                       Mat rotMatrixX,
                                                       Mat rotMatrixY,
                                                       Mat rotMatrixZ)

    - #### decomposeProjectionMatrix

          public static void decomposeProjectionMatrix(Mat projMatrix,
                                                       Mat cameraMatrix,
                                                       Mat rotMatrix,
                                                       Mat transVect,
                                                       Mat rotMatrixX,
                                                       Mat rotMatrixY)

    - #### decomposeProjectionMatrix

          public static void decomposeProjectionMatrix(Mat projMatrix,
                                                       Mat cameraMatrix,
                                                       Mat rotMatrix,
                                                       Mat transVect,
                                                       Mat rotMatrixX)

    - #### decomposeProjectionMatrix

          public static void decomposeProjectionMatrix(Mat projMatrix,
                                                       Mat cameraMatrix,
                                                       Mat rotMatrix,
                                                       Mat transVect)

    - #### drawChessboardCorners

          public static void drawChessboardCorners(Mat image,
                                                   Size patternSize,
                                                   MatOfPoint2f corners,
                                                   boolean patternWasFound)

    - #### filterHomographyDecompByVisibleRefpoints

          public static void filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations,
                                                                      java.util.List<Mat> normals,
                                                                      Mat beforePoints,
                                                                      Mat afterPoints,
                                                                      Mat possibleSolutions,
                                                                      Mat pointsMask)

    - #### filterHomographyDecompByVisibleRefpoints

          public static void filterHomographyDecompByVisibleRefpoints(java.util.List<Mat> rotations,
                                                                      java.util.List<Mat> normals,
                                                                      Mat beforePoints,
                                                                      Mat afterPoints,
                                                                      Mat possibleSolutions)

    - #### filterSpeckles

          public static void filterSpeckles(Mat img,
                                            double newVal,
                                            int maxSpeckleSize,
                                            double maxDiff,
                                            Mat buf)

    - #### filterSpeckles

          public static void filterSpeckles(Mat img,
                                            double newVal,
                                            int maxSpeckleSize,
                                            double maxDiff)

    - #### matMulDeriv

          public static void matMulDeriv(Mat A,
                                         Mat B,
                                         Mat dABdA,
                                         Mat dABdB)

    - #### projectPoints

          public static void projectPoints(MatOfPoint3f objectPoints,
                                           Mat rvec,
                                           Mat tvec,
                                           Mat cameraMatrix,
                                           MatOfDouble distCoeffs,
                                           MatOfPoint2f imagePoints,
                                           Mat jacobian,
                                           double aspectRatio)

    - #### projectPoints

          public static void projectPoints(MatOfPoint3f objectPoints,
                                           Mat rvec,
                                           Mat tvec,
                                           Mat cameraMatrix,
                                           MatOfDouble distCoeffs,
                                           MatOfPoint2f imagePoints,
                                           Mat jacobian)

    - #### projectPoints

          public static void projectPoints(MatOfPoint3f objectPoints,
                                           Mat rvec,
                                           Mat tvec,
                                           Mat cameraMatrix,
                                           MatOfDouble distCoeffs,
                                           MatOfPoint2f imagePoints)

    - #### reprojectImageTo3D

          public static void reprojectImageTo3D(Mat disparity,
                                                Mat _3dImage,
                                                Mat Q,
                                                boolean handleMissingValues,
                                                int ddepth)

    - #### reprojectImageTo3D

          public static void reprojectImageTo3D(Mat disparity,
                                                Mat _3dImage,
                                                Mat Q,
                                                boolean handleMissingValues)

    - #### reprojectImageTo3D

          public static void reprojectImageTo3D(Mat disparity,
                                                Mat _3dImage,
                                                Mat Q)

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

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

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

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

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

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

    - #### triangulatePoints

          public static void triangulatePoints(Mat projMatr1,
                                               Mat projMatr2,
                                               Mat projPoints1,
                                               Mat projPoints2,
                                               Mat points4D)

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

    - #### fisheye_distortPoints

          public static void fisheye_distortPoints(Mat undistorted,
                                                   Mat distorted,
                                                   Mat K,
                                                   Mat D,
                                                   double alpha)

    - #### fisheye_distortPoints

          public static void fisheye_distortPoints(Mat undistorted,
                                                   Mat distorted,
                                                   Mat K,
                                                   Mat D)

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

    - #### fisheye_estimateNewCameraMatrixForUndistortRectify

          public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                                Mat D,
                                                                                Size image_size,
                                                                                Mat R,
                                                                                Mat P,
                                                                                double balance,
                                                                                Size new_size)

    - #### fisheye_estimateNewCameraMatrixForUndistortRectify

          public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                                Mat D,
                                                                                Size image_size,
                                                                                Mat R,
                                                                                Mat P,
                                                                                double balance)

    - #### fisheye_estimateNewCameraMatrixForUndistortRectify

          public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K,
                                                                                Mat D,
                                                                                Size image_size,
                                                                                Mat R,
                                                                                Mat P)

    - #### fisheye_initUndistortRectifyMap

          public static void fisheye_initUndistortRectifyMap(Mat K,
                                                             Mat D,
                                                             Mat R,
                                                             Mat P,
                                                             Size size,
                                                             int m1type,
                                                             Mat map1,
                                                             Mat map2)

    - #### 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_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)

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

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

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

    - #### fisheye_undistortImage

          public static void fisheye_undistortImage(Mat distorted,
                                                    Mat undistorted,
                                                    Mat K,
                                                    Mat D,
                                                    Mat Knew,
                                                    Size new_size)

    - #### fisheye_undistortImage

          public static void fisheye_undistortImage(Mat distorted,
                                                    Mat undistorted,
                                                    Mat K,
                                                    Mat D,
                                                    Mat Knew)

    - #### fisheye_undistortImage

          public static void fisheye_undistortImage(Mat distorted,
                                                    Mat undistorted,
                                                    Mat K,
                                                    Mat D)

    - #### fisheye_undistortPoints

          public static void fisheye_undistortPoints(Mat distorted,
                                                     Mat undistorted,
                                                     Mat K,
                                                     Mat D,
                                                     Mat R,
                                                     Mat P)

    - #### fisheye_undistortPoints

          public static void fisheye_undistortPoints(Mat distorted,
                                                     Mat undistorted,
                                                     Mat K,
                                                     Mat D,
                                                     Mat R)

    - #### fisheye_undistortPoints

          public static void fisheye_undistortPoints(Mat distorted,
                                                     Mat undistorted,
                                                     Mat K,
                                                     Mat D)

Generated on Wed Aug 29 2018 10:29:57 UTC / OpenCV 3.4.3