Calib3d

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

public class Calib3d
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CALIB_CB_ADAPTIVE_THRESH`
`static int`	`CALIB_CB_ASYMMETRIC_GRID`
`static int`	`CALIB_CB_CLUSTERING`
`static int`	`CALIB_CB_FAST_CHECK`
`static int`	`CALIB_CB_FILTER_QUADS`
`static int`	`CALIB_CB_NORMALIZE_IMAGE`
`static int`	`CALIB_CB_SYMMETRIC_GRID`
`static int`	`CALIB_CHECK_COND`
`static int`	`CALIB_FIX_ASPECT_RATIO`
`static int`	`CALIB_FIX_FOCAL_LENGTH`
`static int`	`CALIB_FIX_INTRINSIC`
`static int`	`CALIB_FIX_K1`
`static int`	`CALIB_FIX_K2`
`static int`	`CALIB_FIX_K3`
`static int`	`CALIB_FIX_K4`
`static int`	`CALIB_FIX_K5`
`static int`	`CALIB_FIX_K6`
`static int`	`CALIB_FIX_PRINCIPAL_POINT`
`static int`	`CALIB_FIX_S1_S2_S3_S4`
`static int`	`CALIB_FIX_SKEW`
`static int`	`CALIB_FIX_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_INTRINSIC_GUESS`
`static int`	`CALIB_USE_LU`
`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`	`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_DLS`
`static int`	`SOLVEPNP_EPNP`
`static int`	`SOLVEPNP_ITERATIVE`
`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`	`calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`
`static double`	`calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
`static double`	`calibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size image_size, Mat K, Mat D, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs)`
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags)`
`static double`	`calibrateCamera(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, java.util.List<Mat> rvecs, java.util.List<Mat> tvecs, int flags, TermCriteria criteria)`
`static 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, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2)`
`static void`	`computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines)`
`static void`	`convertPointsFromHomogeneous(Mat src, Mat dst)`
`static void`	`convertPointsToHomogeneous(Mat src, Mat dst)`
`static void`	`correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2)`
`static void`	`decomposeEssentialMat(Mat E, Mat R1, Mat R2, Mat t)`
`static int`	`decomposeHomographyMat(Mat H, Mat K, java.util.List<Mat> rotations, java.util.List<Mat> translations, java.util.List<Mat> normals)`
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect)`
`static void`	`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles)`
`static void`	`distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)`
`static void`	`distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)`
`static void`	`drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound)`
`static int`	`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers)`
`static int`	`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)`
`static void`	`estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P)`
`static void`	`estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale)`
`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, 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, 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, double param1, double param2)`
`static Mat`	`findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double param1, double param2, Mat mask)`
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints)`
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold)`
`static Mat`	`findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)`
`static Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)`
`static Mat`	`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)`
`static Rect`	`getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)`
`static Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize)`
`static Mat`	`initCameraMatrix2D(java.util.List<MatOfPoint3f> objectPoints, java.util.List<MatOfPoint2f> imagePoints, Size imageSize, double aspectRatio)`
`static void`	`initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat map1, Mat map2)`
`static void`	`matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB)`
`static void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints)`
`static void`	`projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio)`
`static void`	`projectPoints(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat rvec, Mat tvec, Mat K, Mat D)`
`static void`	`projectPoints(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian)`
`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, 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, Mat mask)`
`static float`	`rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, java.util.List<Mat> imgpt1, java.util.List<Mat> imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)`
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)`
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues)`
`static void`	`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)`
`static void`	`Rodrigues(Mat src, Mat dst)`
`static void`	`Rodrigues(Mat src, Mat dst, Mat jacobian)`
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)`
`static double[]`	`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)`
`static double`	`sampsonDistance(Mat pt1, Mat pt2, Mat F)`
`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, 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, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags, TermCriteria criteria)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags)`
`static double`	`stereoCalibrate(java.util.List<Mat> objectPoints, java.util.List<Mat> imagePoints1, java.util.List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria)`
`static 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 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`	`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 void`	`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 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`	`undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D)`
`static void`	`undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size)`
`static void`	`undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D)`
`static void`	`undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P)`
`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
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CALIB_CB_ADAPTIVE_THRESH
```
public static final int CALIB_CB_ADAPTIVE_THRESH
```
  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_CB_FAST_CHECK
```
public static final int CALIB_CB_FAST_CHECK
```
  See Also:
  
  Constant Field Values
- CALIB_CB_FILTER_QUADS
```
public static final int CALIB_CB_FILTER_QUADS
```
  See Also:
  
  Constant Field Values
- CALIB_CB_NORMALIZE_IMAGE
```
public static final int CALIB_CB_NORMALIZE_IMAGE
```
  See Also:
  
  Constant Field Values
- CALIB_CB_SYMMETRIC_GRID
```
public static final int CALIB_CB_SYMMETRIC_GRID
```
  See Also:
  
  Constant Field Values
- CALIB_CHECK_COND
```
public static final int CALIB_CHECK_COND
```
  See Also:
  
  Constant Field Values
- CALIB_FIX_ASPECT_RATIO
```
public static final int CALIB_FIX_ASPECT_RATIO
```
  See Also:
  
  Constant Field Values
- CALIB_FIX_FOCAL_LENGTH
```
public static final int CALIB_FIX_FOCAL_LENGTH
```
  See Also:
  
  Constant Field Values
- CALIB_FIX_INTRINSIC
```
public static final int CALIB_FIX_INTRINSIC
```
  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_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_FIX_PRINCIPAL_POINT
```
public static final int CALIB_FIX_PRINCIPAL_POINT
```
  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_FIX_SKEW
```
public static final int CALIB_FIX_SKEW
```
  See Also:
  
  Constant Field Values
- CALIB_FIX_TAUX_TAUY
```
public static final int CALIB_FIX_TAUX_TAUY
```
  See Also:
  
  Constant Field Values
- CALIB_RATIONAL_MODEL
```
public static final int CALIB_RATIONAL_MODEL
```
  See Also:
  
  Constant Field Values
- CALIB_RECOMPUTE_EXTRINSIC
```
public static final int CALIB_RECOMPUTE_EXTRINSIC
```
  See Also:
  
  Constant Field Values
- CALIB_SAME_FOCAL_LENGTH
```
public static final int CALIB_SAME_FOCAL_LENGTH
```
  See Also:
  
  Constant Field Values
- CALIB_THIN_PRISM_MODEL
```
public static final int CALIB_THIN_PRISM_MODEL
```
  See Also:
  
  Constant Field Values
- CALIB_TILTED_MODEL
```
public static final int CALIB_TILTED_MODEL
```
  See Also:
  
  Constant Field Values
- CALIB_USE_INTRINSIC_GUESS
```
public static final int CALIB_USE_INTRINSIC_GUESS
```
  See Also:
  
  Constant Field Values
- CALIB_USE_LU
```
public static final int CALIB_USE_LU
```
  See Also:
  
  Constant Field Values
- CALIB_ZERO_DISPARITY
```
public static final int CALIB_ZERO_DISPARITY
```
  See Also:
  
  Constant Field Values
- CALIB_ZERO_TANGENT_DIST
```
public static final int CALIB_ZERO_TANGENT_DIST
```
  See Also:
  
  Constant Field Values
- CV_DLS
```
public static final int CV_DLS
```
  See Also:
  
  Constant Field Values
- CV_EPNP
```
public static final int CV_EPNP
```
  See Also:
  
  Constant Field Values
- CV_ITERATIVE
```
public static final int CV_ITERATIVE
```
  See Also:
  
  Constant Field Values
- CV_P3P
```
public static final int CV_P3P
```
  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
- 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_DLS
```
public static final int SOLVEPNP_DLS
```
  See Also:
  
  Constant Field Values
- SOLVEPNP_EPNP
```
public static final int SOLVEPNP_EPNP
```
  See Also:
  
  Constant Field Values
- SOLVEPNP_ITERATIVE
```
public static final int SOLVEPNP_ITERATIVE
```
  See Also:
  
  Constant Field Values
- SOLVEPNP_P3P
```
public static final int SOLVEPNP_P3P
```
  See Also:
  
  Constant Field Values
- SOLVEPNP_UPNP
```
public static final int SOLVEPNP_UPNP
```
  See Also:
  
  Constant Field Values

Constructor Detail
- Calib3d
```
public Calib3d()
```

Method Detail

calibrate

public static double calibrate(java.util.List<Mat> objectPoints,
                               java.util.List<Mat> imagePoints,
                               Size image_size,
                               Mat K,
                               Mat D,
                               java.util.List<Mat> rvecs,
                               java.util.List<Mat> tvecs)

calibrate

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

calibrate

public static double calibrate(java.util.List<Mat> objectPoints,
                               java.util.List<Mat> imagePoints,
                               Size image_size,
                               Mat K,
                               Mat D,
                               java.util.List<Mat> rvecs,
                               java.util.List<Mat> tvecs,
                               int flags,
                               TermCriteria criteria)

calibrateCamera

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

calibrateCamera

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

calibrateCamera

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

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)

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)

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)

decomposeHomographyMat

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

decomposeProjectionMatrix

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

decomposeProjectionMatrix

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

distortPoints

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

distortPoints

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

drawChessboardCorners

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

estimateAffine3D

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

estimateAffine3D

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

estimateNewCameraMatrixForUndistortRectify

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

estimateNewCameraMatrixForUndistortRectify

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

filterSpeckles

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

filterSpeckles

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

findChessboardCorners

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

findChessboardCorners

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

findCirclesGrid

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

findCirclesGrid

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

findEssentialMat

public static Mat findEssentialMat(Mat points1,
                                   Mat points2)

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,
                                   double threshold,
                                   Mat mask)

findEssentialMat

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

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,
                                   double threshold,
                                   Mat mask)

findFundamentalMat

public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2)

findFundamentalMat

public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double param1,
                                     double param2)

findFundamentalMat

public static Mat findFundamentalMat(MatOfPoint2f points1,
                                     MatOfPoint2f points2,
                                     int method,
                                     double param1,
                                     double param2,
                                     Mat mask)

findHomography

public static Mat findHomography(MatOfPoint2f srcPoints,
                                 MatOfPoint2f dstPoints)

findHomography

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

findHomography

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

getOptimalNewCameraMatrix

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

getOptimalNewCameraMatrix

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

getValidDisparityROI

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

initCameraMatrix2D

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

initCameraMatrix2D

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

initUndistortRectifyMap

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

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)

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,
                                 MatOfPoint2f imagePoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat K,
                                 Mat D)

projectPoints

public static void projectPoints(MatOfPoint3f objectPoints,
                                 MatOfPoint2f imagePoints,
                                 Mat rvec,
                                 Mat tvec,
                                 Mat K,
                                 Mat D,
                                 double alpha,
                                 Mat jacobian)

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 R,
                              Mat t,
                              double focal,
                              Point pp)

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 cameraMatrix,
                              Mat R,
                              Mat t)

recoverPose

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

rectify3Collinear

public static float rectify3Collinear(Mat cameraMatrix1,
                                      Mat distCoeffs1,
                                      Mat cameraMatrix2,
                                      Mat distCoeffs2,
                                      Mat cameraMatrix3,
                                      Mat distCoeffs3,
                                      java.util.List<Mat> imgpt1,
                                      java.util.List<Mat> imgpt3,
                                      Size imageSize,
                                      Mat R12,
                                      Mat T12,
                                      Mat R13,
                                      Mat T13,
                                      Mat R1,
                                      Mat R2,
                                      Mat R3,
                                      Mat P1,
                                      Mat P2,
                                      Mat P3,
                                      Mat Q,
                                      double alpha,
                                      Size newImgSize,
                                      Rect roi1,
                                      Rect roi2,
                                      int flags)

reprojectImageTo3D

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

reprojectImageTo3D

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

reprojectImageTo3D

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

Rodrigues

public static void Rodrigues(Mat src,
                             Mat dst)

Rodrigues

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

RQDecomp3x3

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

RQDecomp3x3

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

sampsonDistance

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

solvePnP

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

solvePnP

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

solvePnPRansac

public static boolean solvePnPRansac(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)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat K1,
                                     Mat D1,
                                     Mat K2,
                                     Mat D2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat K1,
                                     Mat D1,
                                     Mat K2,
                                     Mat D2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     int flags)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat K1,
                                     Mat D1,
                                     Mat K2,
                                     Mat D2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     int flags,
                                     TermCriteria criteria)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     int flags)

stereoCalibrate

public static double stereoCalibrate(java.util.List<Mat> objectPoints,
                                     java.util.List<Mat> imagePoints1,
                                     java.util.List<Mat> imagePoints2,
                                     Mat cameraMatrix1,
                                     Mat distCoeffs1,
                                     Mat cameraMatrix2,
                                     Mat distCoeffs2,
                                     Size imageSize,
                                     Mat R,
                                     Mat T,
                                     Mat E,
                                     Mat F,
                                     int flags,
                                     TermCriteria criteria)

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)

stereoRectify

public static void 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)

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

stereoRectifyUncalibrated

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

stereoRectifyUncalibrated

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

triangulatePoints

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

undistortImage

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

undistortImage

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

undistortPoints

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

undistortPoints

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

validateDisparity

public static void validateDisparity(Mat disparity,
                                     Mat cost,
                                     int minDisparity,
                                     int numberOfDisparities)

validateDisparity

public static void validateDisparity(Mat disparity,
                                     Mat cost,
                                     int minDisparity,
                                     int numberOfDisparities,
                                     int disp12MaxDisp)

Class Calib3d

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CALIB_CB_ADAPTIVE_THRESH

CALIB_CB_ASYMMETRIC_GRID

CALIB_CB_CLUSTERING

CALIB_CB_FAST_CHECK

CALIB_CB_FILTER_QUADS

CALIB_CB_NORMALIZE_IMAGE

CALIB_CB_SYMMETRIC_GRID

CALIB_CHECK_COND

CALIB_FIX_ASPECT_RATIO

CALIB_FIX_FOCAL_LENGTH

CALIB_FIX_INTRINSIC

CALIB_FIX_K1

CALIB_FIX_K2

CALIB_FIX_K3

CALIB_FIX_K4

CALIB_FIX_K5

CALIB_FIX_K6

CALIB_FIX_PRINCIPAL_POINT

CALIB_FIX_S1_S2_S3_S4

CALIB_FIX_SKEW

CALIB_FIX_TAUX_TAUY

CALIB_RATIONAL_MODEL

CALIB_RECOMPUTE_EXTRINSIC

CALIB_SAME_FOCAL_LENGTH

CALIB_THIN_PRISM_MODEL

CALIB_TILTED_MODEL

CALIB_USE_INTRINSIC_GUESS

CALIB_USE_LU

CALIB_ZERO_DISPARITY

CALIB_ZERO_TANGENT_DIST

CV_DLS

CV_EPNP

CV_ITERATIVE

CV_P3P

FM_7POINT

FM_8POINT

FM_LMEDS

FM_RANSAC

LMEDS

RANSAC

RHO

SOLVEPNP_DLS

SOLVEPNP_EPNP

SOLVEPNP_ITERATIVE

SOLVEPNP_P3P

SOLVEPNP_UPNP

Constructor Detail

Calib3d

Method Detail

calibrate

calibrate

calibrate

calibrateCamera

calibrateCamera

calibrateCamera

calibrationMatrixValues

composeRT

composeRT

computeCorrespondEpilines

convertPointsFromHomogeneous

convertPointsToHomogeneous

correctMatches

decomposeEssentialMat

decomposeHomographyMat

decomposeProjectionMatrix

decomposeProjectionMatrix

distortPoints

distortPoints

drawChessboardCorners

estimateAffine3D

estimateAffine3D

estimateNewCameraMatrixForUndistortRectify

estimateNewCameraMatrixForUndistortRectify

filterSpeckles