Calib3d (JavaCPP Presets for OpenCV 3.4.3-1.4.3 API)

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

```
public class Calib3d
extends 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()

Constructors
Constructor and Description
`Calib3d()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs)`
`static double`	`calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, int flags)`
`static double`	`calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraExtended(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraExtended(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags)`
`static double`	`calibrateCameraExtended(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, 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, List<Mat> rotations, List<Mat> translations, 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(List<Mat> rotations, List<Mat> normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`
`static void`	`filterHomographyDecompByVisibleRefpoints(List<Mat> rotations, 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(List<Mat> objectPoints, List<Mat> imagePoints, Size image_size, Mat K, Mat D, List<Mat> rvecs, List<Mat> tvecs)`
`static double`	`fisheye_calibrate(List<Mat> objectPoints, List<Mat> imagePoints, Size image_size, Mat K, Mat D, List<Mat> rvecs, List<Mat> tvecs, int flags)`
`static double`	`fisheye_calibrate(List<Mat> objectPoints, List<Mat> imagePoints, Size image_size, Mat K, Mat D, List<Mat> rvecs, 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(List<Mat> objectPoints, List<Mat> imagePoints1, List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T)`
`static double`	`fisheye_stereoCalibrate(List<Mat> objectPoints, List<Mat> imagePoints1, List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags)`
`static double`	`fisheye_stereoCalibrate(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<MatOfPoint3f> objectPoints, List<MatOfPoint2f> imagePoints, Size imageSize)`
`static Mat`	`initCameraMatrix2D(List<MatOfPoint3f> objectPoints, 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, List<Mat> imgpt1, 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, List<Mat> rvecs, 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(List<Mat> objectPoints, List<Mat> imagePoints1, List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)`
`static double`	`stereoCalibrate(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<Mat> objectPoints, List<Mat> imagePoints1, 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(List<MatOfPoint3f> objectPoints,
                                     List<MatOfPoint2f> imagePoints,
                                     Size imageSize,
                                     double aspectRatio)

initCameraMatrix2D

public static Mat initCameraMatrix2D(List<MatOfPoint3f> objectPoints,
                                     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(List<Mat> objectPoints,
                                             List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             List<Mat> rvecs,
                                             List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors,
                                             int flags,
                                             TermCriteria criteria)

calibrateCameraExtended

public static double calibrateCameraExtended(List<Mat> objectPoints,
                                             List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             List<Mat> rvecs,
                                             List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors,
                                             int flags)

calibrateCameraExtended

public static double calibrateCameraExtended(List<Mat> objectPoints,
                                             List<Mat> imagePoints,
                                             Size imageSize,
                                             Mat cameraMatrix,
                                             Mat distCoeffs,
                                             List<Mat> rvecs,
                                             List<Mat> tvecs,
                                             Mat stdDeviationsIntrinsics,
                                             Mat stdDeviationsExtrinsics,
                                             Mat perViewErrors)

calibrateCamera

public static double calibrateCamera(List<Mat> objectPoints,
                                     List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     List<Mat> rvecs,
                                     List<Mat> tvecs,
                                     int flags,
                                     TermCriteria criteria)

calibrateCamera

public static double calibrateCamera(List<Mat> objectPoints,
                                     List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     List<Mat> rvecs,
                                     List<Mat> tvecs,
                                     int flags)

calibrateCamera

public static double calibrateCamera(List<Mat> objectPoints,
                                     List<Mat> imagePoints,
                                     Size imageSize,
                                     Mat cameraMatrix,
                                     Mat distCoeffs,
                                     List<Mat> rvecs,
                                     List<Mat> tvecs)

sampsonDistance

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

stereoCalibrateExtended

public static double stereoCalibrateExtended(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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(List<Mat> objectPoints,
                                     List<Mat> imagePoints1,
                                     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(List<Mat> objectPoints,
                                     List<Mat> imagePoints1,
                                     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(List<Mat> objectPoints,
                                     List<Mat> imagePoints1,
                                     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(List<Mat> objectPoints,
                                       List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       List<Mat> rvecs,
                                       List<Mat> tvecs,
                                       int flags,
                                       TermCriteria criteria)

fisheye_calibrate

public static double fisheye_calibrate(List<Mat> objectPoints,
                                       List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       List<Mat> rvecs,
                                       List<Mat> tvecs,
                                       int flags)

fisheye_calibrate

public static double fisheye_calibrate(List<Mat> objectPoints,
                                       List<Mat> imagePoints,
                                       Size image_size,
                                       Mat K,
                                       Mat D,
                                       List<Mat> rvecs,
                                       List<Mat> tvecs)

fisheye_stereoCalibrate

public static double fisheye_stereoCalibrate(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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(List<Mat> objectPoints,
                                             List<Mat> imagePoints1,
                                             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,
                                      List<Mat> imgpt1,
                                      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,
                                         List<Mat> rotations,
                                         List<Mat> translations,
                                         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,
                           List<Mat> rvecs,
                           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(List<Mat> rotations,
                                                            List<Mat> normals,
                                                            Mat beforePoints,
                                                            Mat afterPoints,
                                                            Mat possibleSolutions,
                                                            Mat pointsMask)

filterHomographyDecompByVisibleRefpoints

public static void filterHomographyDecompByVisibleRefpoints(List<Mat> rotations,
                                                            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)

Class Calib3d

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CALIB_USE_INTRINSIC_GUESS

CALIB_RECOMPUTE_EXTRINSIC

CALIB_CHECK_COND

CALIB_FIX_SKEW

CALIB_FIX_K1

CALIB_FIX_K2

CALIB_FIX_K3

CALIB_FIX_K4

CALIB_FIX_INTRINSIC

CV_ITERATIVE

CV_EPNP

CV_P3P

CV_DLS

LMEDS

RANSAC

RHO

SOLVEPNP_ITERATIVE

SOLVEPNP_EPNP

SOLVEPNP_P3P

SOLVEPNP_DLS

SOLVEPNP_UPNP

SOLVEPNP_AP3P

SOLVEPNP_MAX_COUNT

CALIB_CB_ADAPTIVE_THRESH

CALIB_CB_NORMALIZE_IMAGE

CALIB_CB_FILTER_QUADS

CALIB_CB_FAST_CHECK

CALIB_CB_SYMMETRIC_GRID

CALIB_CB_ASYMMETRIC_GRID

CALIB_CB_CLUSTERING

CALIB_FIX_ASPECT_RATIO

CALIB_FIX_PRINCIPAL_POINT

CALIB_ZERO_TANGENT_DIST

CALIB_FIX_FOCAL_LENGTH

CALIB_FIX_K5

CALIB_FIX_K6

CALIB_RATIONAL_MODEL

CALIB_THIN_PRISM_MODEL

CALIB_FIX_S1_S2_S3_S4

CALIB_TILTED_MODEL

CALIB_FIX_TAUX_TAUY

CALIB_USE_QR

CALIB_FIX_TANGENT_DIST

CALIB_SAME_FOCAL_LENGTH

CALIB_ZERO_DISPARITY

CALIB_USE_LU

CALIB_USE_EXTRINSIC_GUESS

FM_7POINT

FM_8POINT

FM_LMEDS

FM_RANSAC

fisheye_CALIB_USE_INTRINSIC_GUESS

fisheye_CALIB_RECOMPUTE_EXTRINSIC

fisheye_CALIB_CHECK_COND

fisheye_CALIB_FIX_SKEW

fisheye_CALIB_FIX_K1

fisheye_CALIB_FIX_K2

fisheye_CALIB_FIX_K3

fisheye_CALIB_FIX_K4

fisheye_CALIB_FIX_INTRINSIC

fisheye_CALIB_FIX_PRINCIPAL_POINT

Constructor Detail

Calib3d

Method Detail

estimateAffine2D

estimateAffine2D

estimateAffine2D

estimateAffine2D

estimateAffine2D

estimateAffine2D

estimateAffine2D

estimateAffinePartial2D

estimateAffinePartial2D

estimateAffinePartial2D