opencv_calib3d (JavaCPP Presets for OpenCV 2.4.10-0.10 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_calib3d
- - org.bytedeco.javacpp.helper.opencv_calib3d
  - - org.bytedeco.javacpp.opencv_calib3d

All Implemented Interfaces:: InfoMapper

public class opencv_calib3d
extends opencv_calib3d

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_calib3d.CvLevMarq`
`static class`	`opencv_calib3d.CvPOSITObject` \ Camera Calibration, Pose Estimation and Stereo * \
`static class`	`opencv_calib3d.CvStereoBMState`
`static class`	`opencv_calib3d.StereoBM` Block Matching Stereo Correspondence Algorithm The class implements BM stereo correspondence algorithm by K.
`static class`	`opencv_calib3d.StereoSGBM` Semi-Global Block Matching Stereo Correspondence Algorithm The class implements the original SGBM stereo correspondence algorithm by H.

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_calib3d
opencv_calib3d.AbstractCvPOSITObject, opencv_calib3d.AbstractCvStereoBMState

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CALIB_CB_ADAPTIVE_THRESH` enum cv::
`static int`	`CALIB_CB_ASYMMETRIC_GRID` enum cv::
`static int`	`CALIB_CB_CLUSTERING` enum cv::
`static int`	`CALIB_CB_FAST_CHECK` enum cv::
`static int`	`CALIB_CB_FILTER_QUADS` enum cv::
`static int`	`CALIB_CB_NORMALIZE_IMAGE` enum cv::
`static int`	`CALIB_CB_SYMMETRIC_GRID` enum cv::
`static int`	`CALIB_FIX_ASPECT_RATIO` enum cv::
`static int`	`CALIB_FIX_FOCAL_LENGTH` enum cv::
`static int`	`CALIB_FIX_INTRINSIC` enum cv::
`static int`	`CALIB_FIX_K1` enum cv::
`static int`	`CALIB_FIX_K2` enum cv::
`static int`	`CALIB_FIX_K3` enum cv::
`static int`	`CALIB_FIX_K4` enum cv::
`static int`	`CALIB_FIX_K5` enum cv::
`static int`	`CALIB_FIX_K6` enum cv::
`static int`	`CALIB_FIX_PRINCIPAL_POINT` enum cv::
`static int`	`CALIB_RATIONAL_MODEL` enum cv::
`static int`	`CALIB_SAME_FOCAL_LENGTH` enum cv::
`static int`	`CALIB_USE_INTRINSIC_GUESS` enum cv::
`static int`	`CALIB_ZERO_DISPARITY` enum cv::
`static int`	`CALIB_ZERO_TANGENT_DIST` enum cv::
`static int`	`CV_CALIB_CB_ADAPTIVE_THRESH`
`static int`	`CV_CALIB_CB_FAST_CHECK`
`static int`	`CV_CALIB_CB_FILTER_QUADS`
`static int`	`CV_CALIB_CB_NORMALIZE_IMAGE`
`static int`	`CV_CALIB_FIX_ASPECT_RATIO`
`static int`	`CV_CALIB_FIX_FOCAL_LENGTH`
`static int`	`CV_CALIB_FIX_INTRINSIC`
`static int`	`CV_CALIB_FIX_K1`
`static int`	`CV_CALIB_FIX_K2`
`static int`	`CV_CALIB_FIX_K3`
`static int`	`CV_CALIB_FIX_K4`
`static int`	`CV_CALIB_FIX_K5`
`static int`	`CV_CALIB_FIX_K6`
`static int`	`CV_CALIB_FIX_PRINCIPAL_POINT`
`static int`	`CV_CALIB_RATIONAL_MODEL`
`static int`	`CV_CALIB_SAME_FOCAL_LENGTH`
`static int`	`CV_CALIB_USE_INTRINSIC_GUESS`
`static int`	`CV_CALIB_ZERO_DISPARITY`
`static int`	`CV_CALIB_ZERO_TANGENT_DIST`
`static int`	`CV_EPNP` enum
`static int`	`CV_FM_7POINT`
`static int`	`CV_FM_8POINT`
`static int`	`CV_FM_LMEDS`
`static int`	`CV_FM_LMEDS_ONLY`
`static int`	`CV_FM_RANSAC`
`static int`	`CV_FM_RANSAC_ONLY`
`static int`	`CV_ITERATIVE` enum
`static int`	`CV_LMEDS`
`static int`	`CV_P3P` enum
`static int`	`CV_RANSAC`
`static int`	`CV_STEREO_BM_BASIC`
`static int`	`CV_STEREO_BM_FISH_EYE`
`static int`	`CV_STEREO_BM_NARROW`
`static int`	`CV_STEREO_BM_NORMALIZED_RESPONSE`
`static int`	`CV_STEREO_BM_XSOBEL`
`static int`	`EPNP` enum cv::
`static int`	`FISHEYE_CALIB_CHECK_COND` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_INTRINSIC` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_K1` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_K2` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_K3` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_K4` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_FIX_SKEW` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_RECOMPUTE_EXTRINSIC` enum cv::fisheye::
`static int`	`FISHEYE_CALIB_USE_INTRINSIC_GUESS` enum cv::fisheye::
`static int`	`FM_7POINT` enum cv::
`static int`	`FM_8POINT` enum cv::
`static int`	`FM_LMEDS` enum cv::
`static int`	`FM_RANSAC` enum cv::
`static int`	`ITERATIVE` enum cv::
`static int`	`LMEDS` enum cv::
`static int`	`P3P` enum cv::
`static int`	`RANSAC` enum cv::

Constructor Summary

Constructors
Constructor and Description

opencv_calib3d()

Constructors
Constructor and Description
`opencv_calib3d()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`calibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size image_size, opencv_core.Mat K, opencv_core.Mat D, opencv_core.MatVector rvecs, opencv_core.MatVector tvecs)`
`static double`	`calibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size image_size, opencv_core.Mat K, opencv_core.Mat D, opencv_core.MatVector rvecs, opencv_core.MatVector tvecs, int flags, opencv_core.TermCriteria criteria)` performs camera calibaration
`static double`	`calibrateCamera(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size imageSize, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.MatVector rvecs, opencv_core.MatVector tvecs)`
`static double`	`calibrateCamera(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size imageSize, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.MatVector rvecs, opencv_core.MatVector tvecs, int flags, opencv_core.TermCriteria criteria)` finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
`static void`	`calibrationMatrixValues(opencv_core.Mat cameraMatrix, opencv_core.Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, opencv_core.Point2d principalPoint, double[] aspectRatio)`
`static void`	`calibrationMatrixValues(opencv_core.Mat cameraMatrix, opencv_core.Size imageSize, double apertureWidth, double apertureHeight, DoubleBuffer fovx, DoubleBuffer fovy, DoubleBuffer focalLength, opencv_core.Point2d principalPoint, DoubleBuffer aspectRatio)`
`static void`	`calibrationMatrixValues(opencv_core.Mat cameraMatrix, opencv_core.Size imageSize, double apertureWidth, double apertureHeight, DoublePointer fovx, DoublePointer fovy, DoublePointer focalLength, opencv_core.Point2d principalPoint, DoublePointer aspectRatio)` computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
`static void`	`composeRT(opencv_core.Mat rvec1, opencv_core.Mat tvec1, opencv_core.Mat rvec2, opencv_core.Mat tvec2, opencv_core.Mat rvec3, opencv_core.Mat tvec3)`
`static void`	`composeRT(opencv_core.Mat rvec1, opencv_core.Mat tvec1, opencv_core.Mat rvec2, opencv_core.Mat tvec2, opencv_core.Mat rvec3, opencv_core.Mat tvec3, opencv_core.Mat dr3dr1, opencv_core.Mat dr3dt1, opencv_core.Mat dr3dr2, opencv_core.Mat dr3dt2, opencv_core.Mat dt3dr1, opencv_core.Mat dt3dt1, opencv_core.Mat dt3dr2, opencv_core.Mat dt3dt2)` composes 2 [R\|t] transformations together.
`static void`	`computeCorrespondEpilines(opencv_core.Mat points, int whichImage, opencv_core.Mat F, opencv_core.Mat lines)` finds coordinates of epipolar lines corresponding the specified points
`static void`	`convertPointsFromHomogeneous(opencv_core.Mat src, opencv_core.Mat dst)` converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
`static void`	`convertPointsHomogeneous(opencv_core.Mat src, opencv_core.Mat dst)` for backward compatibility
`static void`	`convertPointsToHomogeneous(opencv_core.Mat src, opencv_core.Mat dst)` converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
`static void`	`correctMatches(opencv_core.Mat F, opencv_core.Mat points1, opencv_core.Mat points2, opencv_core.Mat newPoints1, opencv_core.Mat newPoints2)`
`static void`	`cvCalcMatMulDeriv(opencv_core.CvMat A, opencv_core.CvMat B, opencv_core.CvMat dABdA, opencv_core.CvMat dABdB)`
`static double`	`cvCalibrateCamera2(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat point_counts, opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs)`
`static double`	`cvCalibrateCamera2(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat point_counts, opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat rotation_vectors, opencv_core.CvMat translation_vectors, int flags, opencv_core.CvTermCriteria term_crit)`
`static void`	`cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix, opencv_core.CvSize image_size)`
`static void`	`cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix, opencv_core.CvSize image_size, double aperture_width, double aperture_height, double[] fovx, double[] fovy, double[] focal_length, double[] principal_point, double[] pixel_aspect_ratio)`
`static void`	`cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix, opencv_core.CvSize image_size, double aperture_width, double aperture_height, DoubleBuffer fovx, DoubleBuffer fovy, DoubleBuffer focal_length, DoubleBuffer principal_point, DoubleBuffer pixel_aspect_ratio)`
`static void`	`cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix, opencv_core.CvSize image_size, double aperture_width, double aperture_height, DoublePointer fovx, DoublePointer fovy, DoublePointer focal_length, opencv_core.CvPoint2D64f principal_point, DoublePointer pixel_aspect_ratio)`
`static int`	`cvCheckChessboard(opencv_core.IplImage src, opencv_core.CvSize size)`
`static void`	`cvComposeRT(opencv_core.CvMat _rvec1, opencv_core.CvMat _tvec1, opencv_core.CvMat _rvec2, opencv_core.CvMat _tvec2, opencv_core.CvMat _rvec3, opencv_core.CvMat _tvec3)`
`static void`	`cvComposeRT(opencv_core.CvMat _rvec1, opencv_core.CvMat _tvec1, opencv_core.CvMat _rvec2, opencv_core.CvMat _tvec2, opencv_core.CvMat _rvec3, opencv_core.CvMat _tvec3, opencv_core.CvMat dr3dr1, opencv_core.CvMat dr3dt1, opencv_core.CvMat dr3dr2, opencv_core.CvMat dr3dt2, opencv_core.CvMat dt3dr1, opencv_core.CvMat dt3dt1, opencv_core.CvMat dt3dr2, opencv_core.CvMat dt3dt2)`
`static void`	`cvComputeCorrespondEpilines(opencv_core.CvMat points, int which_image, opencv_core.CvMat fundamental_matrix, opencv_core.CvMat correspondent_lines)`
`static void`	`cvConvertPointsHomogeneous(opencv_core.CvMat src, opencv_core.CvMat dst)`
`static void`	`cvCorrectMatches(opencv_core.CvMat F, opencv_core.CvMat points1, opencv_core.CvMat points2, opencv_core.CvMat new_points1, opencv_core.CvMat new_points2)`
`static opencv_calib3d.CvPOSITObject`	`cvCreatePOSITObject(float[] points, int point_count)`
`static opencv_calib3d.CvPOSITObject`	`cvCreatePOSITObject(FloatBuffer points, int point_count)`
`static opencv_calib3d.CvPOSITObject`	`cvCreatePOSITObject(opencv_core.CvPoint3D32f points, int point_count)`
`static opencv_calib3d.CvStereoBMState`	`cvCreateStereoBMState()`
`static opencv_calib3d.CvStereoBMState`	`cvCreateStereoBMState(int preset, int numberOfDisparities)`
`static void`	`cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr, opencv_core.CvMat calibMatr, opencv_core.CvMat rotMatr, opencv_core.CvMat posVect)`
`static void`	`cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr, opencv_core.CvMat calibMatr, opencv_core.CvMat rotMatr, opencv_core.CvMat posVect, opencv_core.CvMat rotMatrX, opencv_core.CvMat rotMatrY, opencv_core.CvMat rotMatrZ, double[] eulerAngles)`
`static void`	`cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr, opencv_core.CvMat calibMatr, opencv_core.CvMat rotMatr, opencv_core.CvMat posVect, opencv_core.CvMat rotMatrX, opencv_core.CvMat rotMatrY, opencv_core.CvMat rotMatrZ, DoubleBuffer eulerAngles)`
`static void`	`cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr, opencv_core.CvMat calibMatr, opencv_core.CvMat rotMatr, opencv_core.CvMat posVect, opencv_core.CvMat rotMatrX, opencv_core.CvMat rotMatrY, opencv_core.CvMat rotMatrZ, opencv_core.CvPoint3D64f eulerAngles)`
`static void`	`cvDrawChessboardCorners(opencv_core.CvArr image, opencv_core.CvSize pattern_size, float[] corners, int count, int pattern_was_found)`
`static void`	`cvDrawChessboardCorners(opencv_core.CvArr image, opencv_core.CvSize pattern_size, FloatBuffer corners, int count, int pattern_was_found)`
`static void`	`cvDrawChessboardCorners(opencv_core.CvArr image, opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners, int count, int pattern_was_found)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, float[] corners)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, float[] corners, int[] corner_count, int flags)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, FloatBuffer corners)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, FloatBuffer corners, IntBuffer corner_count, int flags)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners)`
`static int`	`cvFindChessboardCorners(Pointer image, opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners, IntPointer corner_count, int flags)`
`static void`	`cvFindExtrinsicCameraParams2(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector)`
`static void`	`cvFindExtrinsicCameraParams2(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector, int use_extrinsic_guess)`
`static int`	`cvFindFundamentalMat(opencv_core.CvMat points1, opencv_core.CvMat points2, opencv_core.CvMat fundamental_matrix)`
`static int`	`cvFindFundamentalMat(opencv_core.CvMat points1, opencv_core.CvMat points2, opencv_core.CvMat fundamental_matrix, int method, double param1, double param2, opencv_core.CvMat status)`
`static int`	`cvFindHomography(opencv_core.CvMat src_points, opencv_core.CvMat dst_points, opencv_core.CvMat homography)`
`static int`	`cvFindHomography(opencv_core.CvMat src_points, opencv_core.CvMat dst_points, opencv_core.CvMat homography, int method, double ransacReprojThreshold, opencv_core.CvMat mask)`
`static void`	`cvFindStereoCorrespondenceBM(opencv_core.CvArr left, opencv_core.CvArr right, opencv_core.CvArr disparity, opencv_calib3d.CvStereoBMState state)`
`static void`	`cvGetOptimalNewCameraMatrix(opencv_core.CvMat camera_matrix, opencv_core.CvMat dist_coeffs, opencv_core.CvSize image_size, double alpha, opencv_core.CvMat new_camera_matrix)`
`static void`	`cvGetOptimalNewCameraMatrix(opencv_core.CvMat camera_matrix, opencv_core.CvMat dist_coeffs, opencv_core.CvSize image_size, double alpha, opencv_core.CvMat new_camera_matrix, opencv_core.CvSize new_imag_size, opencv_core.CvRect valid_pixel_ROI, int center_principal_point)`
`static opencv_core.CvRect`	`cvGetValidDisparityROI(opencv_core.CvRect roi1, opencv_core.CvRect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)`
`static void`	`cvInitIntrinsicParams2D(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat npoints, opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix)`
`static void`	`cvInitIntrinsicParams2D(opencv_core.CvMat object_points, opencv_core.CvMat image_points, opencv_core.CvMat npoints, opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix, double aspect_ratio)`
`static void`	`cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, float[] image_points, double focal_length, opencv_core.CvTermCriteria criteria, float[] rotation_matrix, float[] translation_vector)`
`static void`	`cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, FloatBuffer image_points, double focal_length, opencv_core.CvTermCriteria criteria, FloatBuffer rotation_matrix, FloatBuffer translation_vector)`
`static void`	`cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, opencv_core.CvPoint2D32f image_points, double focal_length, opencv_core.CvTermCriteria criteria, FloatPointer rotation_matrix, FloatPointer translation_vector)`
`static void`	`cvProjectPoints2(opencv_core.CvMat object_points, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat image_points)`
`static void`	`cvProjectPoints2(opencv_core.CvMat object_points, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat image_points, opencv_core.CvMat dpdrot, opencv_core.CvMat dpdt, opencv_core.CvMat dpdf, opencv_core.CvMat dpdc, opencv_core.CvMat dpddist, double aspect_ratio)`
`static int`	`cvRANSACUpdateNumIters(double p, double err_prob, int model_points, int max_iters)`
`static void`	`cvReleasePOSITObject(opencv_calib3d.CvPOSITObject posit_object)`
`static void`	`cvReleasePOSITObject(PointerPointer posit_object)`
`static void`	`cvReleaseStereoBMState(opencv_calib3d.CvStereoBMState state)`
`static void`	`cvReleaseStereoBMState(PointerPointer state)`
`static void`	`cvReprojectImageTo3D(opencv_core.CvArr disparityImage, opencv_core.CvArr _3dImage, opencv_core.CvMat Q)`
`static void`	`cvReprojectImageTo3D(opencv_core.CvArr disparityImage, opencv_core.CvArr _3dImage, opencv_core.CvMat Q, int handleMissingValues)`
`static int`	`cvRodrigues2(opencv_core.CvMat src, opencv_core.CvMat dst)`
`static int`	`cvRodrigues2(opencv_core.CvMat src, opencv_core.CvMat dst, opencv_core.CvMat jacobian)`
`static void`	`cvRQDecomp3x3(opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ)`
`static void`	`cvRQDecomp3x3(opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ, opencv_core.CvMat matrixQx, opencv_core.CvMat matrixQy, opencv_core.CvMat matrixQz, double[] eulerAngles)`
`static void`	`cvRQDecomp3x3(opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ, opencv_core.CvMat matrixQx, opencv_core.CvMat matrixQy, opencv_core.CvMat matrixQz, DoubleBuffer eulerAngles)`
`static void`	`cvRQDecomp3x3(opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ, opencv_core.CvMat matrixQx, opencv_core.CvMat matrixQy, opencv_core.CvMat matrixQz, opencv_core.CvPoint3D64f eulerAngles)`
`static double`	`cvStereoCalibrate(opencv_core.CvMat object_points, opencv_core.CvMat image_points1, opencv_core.CvMat image_points2, opencv_core.CvMat npoints, opencv_core.CvMat camera_matrix1, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs2, opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T)`
`static double`	`cvStereoCalibrate(opencv_core.CvMat object_points, opencv_core.CvMat image_points1, opencv_core.CvMat image_points2, opencv_core.CvMat npoints, opencv_core.CvMat camera_matrix1, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs2, opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T, opencv_core.CvMat E, opencv_core.CvMat F, opencv_core.CvTermCriteria term_crit, int flags)`
`static void`	`cvStereoRectify(opencv_core.CvMat camera_matrix1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat dist_coeffs2, opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T, opencv_core.CvMat R1, opencv_core.CvMat R2, opencv_core.CvMat P1, opencv_core.CvMat P2)`
`static void`	`cvStereoRectify(opencv_core.CvMat camera_matrix1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat dist_coeffs2, opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T, opencv_core.CvMat R1, opencv_core.CvMat R2, opencv_core.CvMat P1, opencv_core.CvMat P2, opencv_core.CvMat Q, int flags, double alpha, opencv_core.CvSize new_image_size, opencv_core.CvRect valid_pix_ROI1, opencv_core.CvRect valid_pix_ROI2)`
`static int`	`cvStereoRectifyUncalibrated(opencv_core.CvMat points1, opencv_core.CvMat points2, opencv_core.CvMat F, opencv_core.CvSize img_size, opencv_core.CvMat H1, opencv_core.CvMat H2)`
`static int`	`cvStereoRectifyUncalibrated(opencv_core.CvMat points1, opencv_core.CvMat points2, opencv_core.CvMat F, opencv_core.CvSize img_size, opencv_core.CvMat H1, opencv_core.CvMat H2, double threshold)`
`static void`	`cvTriangulatePoints(opencv_core.CvMat projMatr1, opencv_core.CvMat projMatr2, opencv_core.CvMat projPoints1, opencv_core.CvMat projPoints2, opencv_core.CvMat points4D)`
`static void`	`cvValidateDisparity(opencv_core.CvArr disparity, opencv_core.CvArr cost, int minDisparity, int numberOfDisparities)`
`static void`	`cvValidateDisparity(opencv_core.CvArr disparity, opencv_core.CvArr cost, int minDisparity, int numberOfDisparities, int disp12MaxDiff)`
`static void`	`decomposeProjectionMatrix(opencv_core.Mat projMatrix, opencv_core.Mat cameraMatrix, opencv_core.Mat rotMatrix, opencv_core.Mat transVect)`
`static void`	`decomposeProjectionMatrix(opencv_core.Mat projMatrix, opencv_core.Mat cameraMatrix, opencv_core.Mat rotMatrix, opencv_core.Mat transVect, opencv_core.Mat rotMatrixX, opencv_core.Mat rotMatrixY, opencv_core.Mat rotMatrixZ, opencv_core.Mat eulerAngles)` Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
`static void`	`distortPoints(opencv_core.Mat undistorted, opencv_core.Mat distorted, opencv_core.Mat K, opencv_core.Mat D)`
`static void`	`distortPoints(opencv_core.Mat undistorted, opencv_core.Mat distorted, opencv_core.Mat K, opencv_core.Mat D, double alpha)` distorts 2D points using fisheye model
`static void`	`drawChessboardCorners(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat corners, boolean patternWasFound)` draws the checkerboard pattern (found or partly found) in the image
`static int`	`estimateAffine3D(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat out, opencv_core.Mat inliers)`
`static int`	`estimateAffine3D(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat out, opencv_core.Mat inliers, double ransacThreshold, double confidence)`
`static void`	`estimateNewCameraMatrixForUndistortRectify(opencv_core.Mat K, opencv_core.Mat D, opencv_core.Size image_size, opencv_core.Mat R, opencv_core.Mat P)`
`static void`	`estimateNewCameraMatrixForUndistortRectify(opencv_core.Mat K, opencv_core.Mat D, opencv_core.Size image_size, opencv_core.Mat R, opencv_core.Mat P, double balance, opencv_core.Size new_size, double fov_scale)` estimates new camera matrix for undistortion or rectification
`static void`	`filterSpeckles(opencv_core.Mat img, double newVal, int maxSpeckleSize, double maxDiff)`
`static void`	`filterSpeckles(opencv_core.Mat img, double newVal, int maxSpeckleSize, double maxDiff, opencv_core.Mat buf)` filters off speckles (small regions of incorrectly computed disparity)
`static boolean`	`find4QuadCornerSubpix(opencv_core.Mat img, opencv_core.Mat corners, opencv_core.Size region_size)` finds subpixel-accurate positions of the chessboard corners
`static boolean`	`findChessboardCorners(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat corners)`
`static boolean`	`findChessboardCorners(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat corners, int flags)` finds checkerboard pattern of the specified size in the image
`static boolean`	`findCirclesGrid(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat centers)`
`static boolean`	`findCirclesGrid(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat centers, int flags, opencv_features2d.FeatureDetector blobDetector)` finds circles' grid pattern of the specified size in the image
`static boolean`	`findCirclesGridDefault(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat centers)`
`static boolean`	`findCirclesGridDefault(opencv_core.Mat image, opencv_core.Size patternSize, opencv_core.Mat centers, int flags)` the deprecated function.
`static opencv_core.Mat`	`findFundamentalMat(opencv_core.Mat points1, opencv_core.Mat points2)`
`static opencv_core.Mat`	`findFundamentalMat(opencv_core.Mat points1, opencv_core.Mat points2, int method, double param1, double param2, opencv_core.Mat mask)` finds fundamental matrix from a set of corresponding 2D points
`static opencv_core.Mat`	`findFundamentalMat(opencv_core.Mat points1, opencv_core.Mat points2, opencv_core.Mat mask)`
`static opencv_core.Mat`	`findFundamentalMat(opencv_core.Mat points1, opencv_core.Mat points2, opencv_core.Mat mask, int method, double param1, double param2)` variant of findFundamentalMat for backward compatibility
`static opencv_core.Mat`	`findHomography(opencv_core.Mat srcPoints, opencv_core.Mat dstPoints)`
`static opencv_core.Mat`	`findHomography(opencv_core.Mat srcPoints, opencv_core.Mat dstPoints, int method, double ransacReprojThreshold, opencv_core.Mat mask)` computes the best-fit perspective transformation mapping srcPoints to dstPoints.
`static opencv_core.Mat`	`findHomography(opencv_core.Mat srcPoints, opencv_core.Mat dstPoints, opencv_core.Mat mask)`
`static opencv_core.Mat`	`findHomography(opencv_core.Mat srcPoints, opencv_core.Mat dstPoints, opencv_core.Mat mask, int method, double ransacReprojThreshold)` variant of findHomography for backward compatibility
`static opencv_core.Mat`	`getOptimalNewCameraMatrix(opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Size imageSize, double alpha)`
`static opencv_core.Mat`	`getOptimalNewCameraMatrix(opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Size imageSize, double alpha, opencv_core.Size newImgSize, opencv_core.Rect validPixROI, boolean centerPrincipalPoint)` returns the optimal new camera matrix
`static opencv_core.Rect`	`getValidDisparityROI(opencv_core.Rect roi1, opencv_core.Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)` computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
`static opencv_core.Mat`	`initCameraMatrix2D(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size imageSize)`
`static opencv_core.Mat`	`initCameraMatrix2D(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints, opencv_core.Size imageSize, double aspectRatio)` initializes camera matrix from a few 3D points and the corresponding projections.
`static void`	`initUndistortRectifyMap(opencv_core.Mat K, opencv_core.Mat D, opencv_core.Mat R, opencv_core.Mat P, opencv_core.Size size, int m1type, opencv_core.Mat map1, opencv_core.Mat map2)` computing undistortion and rectification maps for image transform by cv::remap() If D is empty zero distortion is used, if R or P is empty identity matrixes are used
`static void`	`matMulDeriv(opencv_core.Mat A, opencv_core.Mat B, opencv_core.Mat dABdA, opencv_core.Mat dABdB)` computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
`static void`	`projectPoints(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat affine, opencv_core.Mat K, opencv_core.Mat D)`
`static void`	`projectPoints(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat affine, opencv_core.Mat K, opencv_core.Mat D, double alpha, opencv_core.Mat jacobian)` projects 3D points using fisheye model
`static void`	`projectPoints(opencv_core.Mat objectPoints, opencv_core.Mat rvec, opencv_core.Mat tvec, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat imagePoints)`
`static void`	`projectPoints(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat rvec, opencv_core.Mat tvec, opencv_core.Mat K, opencv_core.Mat D, double alpha, opencv_core.Mat jacobian)` projects points using fisheye model
`static void`	`projectPoints(opencv_core.Mat objectPoints, opencv_core.Mat rvec, opencv_core.Mat tvec, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat imagePoints, opencv_core.Mat jacobian, double aspectRatio)` projects points from the model coordinate space to the image coordinates.
`static float`	rectify3Collinear(opencv_core.Mat cameraMatrix1, opencv_core.Mat distCoeffs1, opencv_core.Mat cameraMatrix2, opencv_core.Mat distCoeffs2, opencv_core.Mat cameraMatrix3, opencv_core.Mat distCoeffs3, opencv_core.MatVector imgpt1, opencv_core.MatVector imgpt3, opencv_core.Size imageSize, opencv_core.Mat R12, opencv_core.Mat T12, opencv_core.Mat R13, opencv_core.Mat T13, opencv_core.Mat R1, opencv_core.Mat R2, opencv_core.Mat R3, opencv_core.Mat P1, opencv_core.Mat P2, opencv_core.Mat P3, opencv_core.Mat Q, double alpha, opencv_core.Size newImgSize, opencv_core.Rect roi1, opencv_core.Rect roi2, int flags) computes the rectification transformations for 3-head camera, where all the heads are on the same line.
`static void`	`reprojectImageTo3D(opencv_core.Mat disparity, opencv_core.Mat _3dImage, opencv_core.Mat Q)`
`static void`	`reprojectImageTo3D(opencv_core.Mat disparity, opencv_core.Mat _3dImage, opencv_core.Mat Q, boolean handleMissingValues, int ddepth)` reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
`static void`	`Rodrigues(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`Rodrigues(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat jacobian)` converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
`static opencv_core.Point3d`	`RQDecomp3x3(opencv_core.Mat src, opencv_core.Mat mtxR, opencv_core.Mat mtxQ)`
`static opencv_core.Point3d`	`RQDecomp3x3(opencv_core.Mat src, opencv_core.Mat mtxR, opencv_core.Mat mtxQ, opencv_core.Mat Qx, opencv_core.Mat Qy, opencv_core.Mat Qz)` Computes RQ decomposition of 3x3 matrix
`static boolean`	`solvePnP(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat rvec, opencv_core.Mat tvec)`
`static boolean`	`solvePnP(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat rvec, opencv_core.Mat tvec, boolean useExtrinsicGuess, int flags)`
`static void`	`solvePnPRansac(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat rvec, opencv_core.Mat tvec)`
`static void`	`solvePnPRansac(opencv_core.Mat objectPoints, opencv_core.Mat imagePoints, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat rvec, opencv_core.Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, int minInliersCount, opencv_core.Mat inliers, int flags)` computes the camera pose from a few 3D points and the corresponding projections.
`static double`	`stereoCalibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints1, opencv_core.MatVector imagePoints2, opencv_core.Mat K1, opencv_core.Mat D1, opencv_core.Mat K2, opencv_core.Mat D2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T)`
`static double`	`stereoCalibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints1, opencv_core.MatVector imagePoints2, opencv_core.Mat K1, opencv_core.Mat D1, opencv_core.Mat K2, opencv_core.Mat D2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T, int flags, opencv_core.TermCriteria criteria)` performs stereo calibaration
`static double`	`stereoCalibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints1, opencv_core.MatVector imagePoints2, opencv_core.Mat cameraMatrix1, opencv_core.Mat distCoeffs1, opencv_core.Mat cameraMatrix2, opencv_core.Mat distCoeffs2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T, opencv_core.Mat E, opencv_core.Mat F)`
`static double`	`stereoCalibrate(opencv_core.MatVector objectPoints, opencv_core.MatVector imagePoints1, opencv_core.MatVector imagePoints2, opencv_core.Mat cameraMatrix1, opencv_core.Mat distCoeffs1, opencv_core.Mat cameraMatrix2, opencv_core.Mat distCoeffs2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T, opencv_core.Mat E, opencv_core.Mat F, opencv_core.TermCriteria criteria, int flags)` finds intrinsic and extrinsic parameters of a stereo camera
`static void`	`stereoRectify(opencv_core.Mat cameraMatrix1, opencv_core.Mat distCoeffs1, opencv_core.Mat cameraMatrix2, opencv_core.Mat distCoeffs2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T, opencv_core.Mat R1, opencv_core.Mat R2, opencv_core.Mat P1, opencv_core.Mat P2, opencv_core.Mat Q)`
`static void`	`stereoRectify(opencv_core.Mat K1, opencv_core.Mat D1, opencv_core.Mat K2, opencv_core.Mat D2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat tvec, opencv_core.Mat R1, opencv_core.Mat R2, opencv_core.Mat P1, opencv_core.Mat P2, opencv_core.Mat Q, int flags)`
`static void`	`stereoRectify(opencv_core.Mat cameraMatrix1, opencv_core.Mat distCoeffs1, opencv_core.Mat cameraMatrix2, opencv_core.Mat distCoeffs2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat T, opencv_core.Mat R1, opencv_core.Mat R2, opencv_core.Mat P1, opencv_core.Mat P2, opencv_core.Mat Q, int flags, double alpha, opencv_core.Size newImageSize, opencv_core.Rect validPixROI1, opencv_core.Rect validPixROI2)` computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
`static void`	`stereoRectify(opencv_core.Mat K1, opencv_core.Mat D1, opencv_core.Mat K2, opencv_core.Mat D2, opencv_core.Size imageSize, opencv_core.Mat R, opencv_core.Mat tvec, opencv_core.Mat R1, opencv_core.Mat R2, opencv_core.Mat P1, opencv_core.Mat P2, opencv_core.Mat Q, int flags, opencv_core.Size newImageSize, double balance, double fov_scale)` stereo rectification estimation
`static boolean`	`stereoRectifyUncalibrated(opencv_core.Mat points1, opencv_core.Mat points2, opencv_core.Mat F, opencv_core.Size imgSize, opencv_core.Mat H1, opencv_core.Mat H2)`
`static boolean`	`stereoRectifyUncalibrated(opencv_core.Mat points1, opencv_core.Mat points2, opencv_core.Mat F, opencv_core.Size imgSize, opencv_core.Mat H1, opencv_core.Mat H2, double threshold)` computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
`static void`	`triangulatePoints(opencv_core.Mat projMatr1, opencv_core.Mat projMatr2, opencv_core.Mat projPoints1, opencv_core.Mat projPoints2, opencv_core.Mat points4D)`
`static void`	`undistortImage(opencv_core.Mat distorted, opencv_core.Mat undistorted, opencv_core.Mat K, opencv_core.Mat D)`
`static void`	`undistortImage(opencv_core.Mat distorted, opencv_core.Mat undistorted, opencv_core.Mat K, opencv_core.Mat D, opencv_core.Mat Knew, opencv_core.Size new_size)` undistorts image, optionally changes resolution and camera matrix.
`static void`	`undistortPoints(opencv_core.Mat distorted, opencv_core.Mat undistorted, opencv_core.Mat K, opencv_core.Mat D)`
`static void`	`undistortPoints(opencv_core.Mat distorted, opencv_core.Mat undistorted, opencv_core.Mat K, opencv_core.Mat D, opencv_core.Mat R, opencv_core.Mat P)` undistorts 2D points using fisheye model
`static void`	`validateDisparity(opencv_core.Mat disparity, opencv_core.Mat cost, int minDisparity, int numberOfDisparities)`
`static void`	`validateDisparity(opencv_core.Mat disparity, opencv_core.Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)` validates disparity using the left-right check.

Methods inherited from class org.bytedeco.javacpp.presets.opencv_calib3d
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CV_FM_7POINT
```
public static final int CV_FM_7POINT
```
  See Also:
  
  Constant Field Values
- CV_FM_8POINT
```
public static final int CV_FM_8POINT
```
  See Also:
  
  Constant Field Values
- CV_LMEDS
```
public static final int CV_LMEDS
```
  See Also:
  
  Constant Field Values
- CV_RANSAC
```
public static final int CV_RANSAC
```
  See Also:
  
  Constant Field Values
- CV_FM_LMEDS_ONLY
```
public static final int CV_FM_LMEDS_ONLY
```
  See Also:
  
  Constant Field Values
- CV_FM_RANSAC_ONLY
```
public static final int CV_FM_RANSAC_ONLY
```
  See Also:
  
  Constant Field Values
- CV_FM_LMEDS
```
public static final int CV_FM_LMEDS
```
  See Also:
  
  Constant Field Values
- CV_FM_RANSAC
```
public static final int CV_FM_RANSAC
```
  See Also:
  
  Constant Field Values
- CV_ITERATIVE
```
public static final int CV_ITERATIVE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_EPNP
```
public static final int CV_EPNP
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_P3P
```
public static final int CV_P3P
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_CALIB_CB_ADAPTIVE_THRESH
```
public static final int CV_CALIB_CB_ADAPTIVE_THRESH
```
  See Also:
  
  Constant Field Values
- CV_CALIB_CB_NORMALIZE_IMAGE
```
public static final int CV_CALIB_CB_NORMALIZE_IMAGE
```
  See Also:
  
  Constant Field Values
- CV_CALIB_CB_FILTER_QUADS
```
public static final int CV_CALIB_CB_FILTER_QUADS
```
  See Also:
  
  Constant Field Values
- CV_CALIB_CB_FAST_CHECK
```
public static final int CV_CALIB_CB_FAST_CHECK
```
  See Also:
  
  Constant Field Values
- CV_CALIB_USE_INTRINSIC_GUESS
```
public static final int CV_CALIB_USE_INTRINSIC_GUESS
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_ASPECT_RATIO
```
public static final int CV_CALIB_FIX_ASPECT_RATIO
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_PRINCIPAL_POINT
```
public static final int CV_CALIB_FIX_PRINCIPAL_POINT
```
  See Also:
  
  Constant Field Values
- CV_CALIB_ZERO_TANGENT_DIST
```
public static final int CV_CALIB_ZERO_TANGENT_DIST
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_FOCAL_LENGTH
```
public static final int CV_CALIB_FIX_FOCAL_LENGTH
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K1
```
public static final int CV_CALIB_FIX_K1
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K2
```
public static final int CV_CALIB_FIX_K2
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K3
```
public static final int CV_CALIB_FIX_K3
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K4
```
public static final int CV_CALIB_FIX_K4
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K5
```
public static final int CV_CALIB_FIX_K5
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_K6
```
public static final int CV_CALIB_FIX_K6
```
  See Also:
  
  Constant Field Values
- CV_CALIB_RATIONAL_MODEL
```
public static final int CV_CALIB_RATIONAL_MODEL
```
  See Also:
  
  Constant Field Values
- CV_CALIB_FIX_INTRINSIC
```
public static final int CV_CALIB_FIX_INTRINSIC
```
  See Also:
  
  Constant Field Values
- CV_CALIB_SAME_FOCAL_LENGTH
```
public static final int CV_CALIB_SAME_FOCAL_LENGTH
```
  See Also:
  
  Constant Field Values
- CV_CALIB_ZERO_DISPARITY
```
public static final int CV_CALIB_ZERO_DISPARITY
```
  See Also:
  
  Constant Field Values
- CV_STEREO_BM_NORMALIZED_RESPONSE
```
public static final int CV_STEREO_BM_NORMALIZED_RESPONSE
```
  See Also:
  
  Constant Field Values
- CV_STEREO_BM_XSOBEL
```
public static final int CV_STEREO_BM_XSOBEL
```
  See Also:
  
  Constant Field Values
- CV_STEREO_BM_BASIC
```
public static final int CV_STEREO_BM_BASIC
```
  See Also:
  
  Constant Field Values
- CV_STEREO_BM_FISH_EYE
```
public static final int CV_STEREO_BM_FISH_EYE
```
  See Also:
  
  Constant Field Values
- CV_STEREO_BM_NARROW
```
public static final int CV_STEREO_BM_NARROW
```
  See Also:
  
  Constant Field Values
- LMEDS
```
public static final int LMEDS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- RANSAC
```
public static final int RANSAC
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- ITERATIVE
```
public static final int ITERATIVE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- EPNP
```
public static final int EPNP
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- P3P
```
public static final int P3P
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_ADAPTIVE_THRESH
```
public static final int CALIB_CB_ADAPTIVE_THRESH
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_NORMALIZE_IMAGE
```
public static final int CALIB_CB_NORMALIZE_IMAGE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_FILTER_QUADS
```
public static final int CALIB_CB_FILTER_QUADS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_FAST_CHECK
```
public static final int CALIB_CB_FAST_CHECK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_SYMMETRIC_GRID
```
public static final int CALIB_CB_SYMMETRIC_GRID
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_ASYMMETRIC_GRID
```
public static final int CALIB_CB_ASYMMETRIC_GRID
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_CB_CLUSTERING
```
public static final int CALIB_CB_CLUSTERING
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_USE_INTRINSIC_GUESS
```
public static final int CALIB_USE_INTRINSIC_GUESS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_ASPECT_RATIO
```
public static final int CALIB_FIX_ASPECT_RATIO
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_PRINCIPAL_POINT
```
public static final int CALIB_FIX_PRINCIPAL_POINT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_ZERO_TANGENT_DIST
```
public static final int CALIB_ZERO_TANGENT_DIST
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_FOCAL_LENGTH
```
public static final int CALIB_FIX_FOCAL_LENGTH
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K1
```
public static final int CALIB_FIX_K1
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K2
```
public static final int CALIB_FIX_K2
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K3
```
public static final int CALIB_FIX_K3
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K4
```
public static final int CALIB_FIX_K4
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K5
```
public static final int CALIB_FIX_K5
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_K6
```
public static final int CALIB_FIX_K6
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_RATIONAL_MODEL
```
public static final int CALIB_RATIONAL_MODEL
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_FIX_INTRINSIC
```
public static final int CALIB_FIX_INTRINSIC
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_SAME_FOCAL_LENGTH
```
public static final int CALIB_SAME_FOCAL_LENGTH
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CALIB_ZERO_DISPARITY
```
public static final int CALIB_ZERO_DISPARITY
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FM_7POINT
```
public static final int FM_7POINT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FM_8POINT
```
public static final int FM_8POINT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FM_LMEDS
```
public static final int FM_LMEDS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FM_RANSAC
```
public static final int FM_RANSAC
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_USE_INTRINSIC_GUESS
```
public static final int FISHEYE_CALIB_USE_INTRINSIC_GUESS
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_RECOMPUTE_EXTRINSIC
```
public static final int FISHEYE_CALIB_RECOMPUTE_EXTRINSIC
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_CHECK_COND
```
public static final int FISHEYE_CALIB_CHECK_COND
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_SKEW
```
public static final int FISHEYE_CALIB_FIX_SKEW
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_K1
```
public static final int FISHEYE_CALIB_FIX_K1
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_K2
```
public static final int FISHEYE_CALIB_FIX_K2
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_K3
```
public static final int FISHEYE_CALIB_FIX_K3
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_K4
```
public static final int FISHEYE_CALIB_FIX_K4
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values
- FISHEYE_CALIB_FIX_INTRINSIC
```
public static final int FISHEYE_CALIB_FIX_INTRINSIC
```
  enum cv::fisheye::
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_calib3d
```
public opencv_calib3d()
```

Method Detail

cvCreatePOSITObject

public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(opencv_core.CvPoint3D32f points,
                                                               int point_count)

cvCreatePOSITObject

public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(FloatBuffer points,
                                                               int point_count)

cvCreatePOSITObject

public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(float[] points,
                                                               int point_count)

cvPOSIT

public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object,
                           opencv_core.CvPoint2D32f image_points,
                           double focal_length,
                           opencv_core.CvTermCriteria criteria,
                           FloatPointer rotation_matrix,
                           FloatPointer translation_vector)

cvPOSIT

public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object,
                           FloatBuffer image_points,
                           double focal_length,
                           opencv_core.CvTermCriteria criteria,
                           FloatBuffer rotation_matrix,
                           FloatBuffer translation_vector)

cvPOSIT

public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object,
                           float[] image_points,
                           double focal_length,
                           opencv_core.CvTermCriteria criteria,
                           float[] rotation_matrix,
                           float[] translation_vector)

cvReleasePOSITObject

public static void cvReleasePOSITObject(PointerPointer posit_object)

cvReleasePOSITObject

public static void cvReleasePOSITObject(opencv_calib3d.CvPOSITObject posit_object)

cvRANSACUpdateNumIters

public static int cvRANSACUpdateNumIters(double p,
                                         double err_prob,
                                         int model_points,
                                         int max_iters)

cvConvertPointsHomogeneous

public static void cvConvertPointsHomogeneous(opencv_core.CvMat src,
                                              opencv_core.CvMat dst)

cvFindFundamentalMat

public static int cvFindFundamentalMat(opencv_core.CvMat points1,
                                       opencv_core.CvMat points2,
                                       opencv_core.CvMat fundamental_matrix,
                                       int method,
                                       double param1,
                                       double param2,
                                       opencv_core.CvMat status)

cvFindFundamentalMat

public static int cvFindFundamentalMat(opencv_core.CvMat points1,
                                       opencv_core.CvMat points2,
                                       opencv_core.CvMat fundamental_matrix)

cvComputeCorrespondEpilines

public static void cvComputeCorrespondEpilines(opencv_core.CvMat points,
                                               int which_image,
                                               opencv_core.CvMat fundamental_matrix,
                                               opencv_core.CvMat correspondent_lines)

cvTriangulatePoints

public static void cvTriangulatePoints(opencv_core.CvMat projMatr1,
                                       opencv_core.CvMat projMatr2,
                                       opencv_core.CvMat projPoints1,
                                       opencv_core.CvMat projPoints2,
                                       opencv_core.CvMat points4D)

cvCorrectMatches

public static void cvCorrectMatches(opencv_core.CvMat F,
                                    opencv_core.CvMat points1,
                                    opencv_core.CvMat points2,
                                    opencv_core.CvMat new_points1,
                                    opencv_core.CvMat new_points2)

cvGetOptimalNewCameraMatrix

public static void cvGetOptimalNewCameraMatrix(opencv_core.CvMat camera_matrix,
                                               opencv_core.CvMat dist_coeffs,
                                               opencv_core.CvSize image_size,
                                               double alpha,
                                               opencv_core.CvMat new_camera_matrix,
                                               opencv_core.CvSize new_imag_size,
                                               opencv_core.CvRect valid_pixel_ROI,
                                               int center_principal_point)

cvGetOptimalNewCameraMatrix

public static void cvGetOptimalNewCameraMatrix(opencv_core.CvMat camera_matrix,
                                               opencv_core.CvMat dist_coeffs,
                                               opencv_core.CvSize image_size,
                                               double alpha,
                                               opencv_core.CvMat new_camera_matrix)

cvRodrigues2

public static int cvRodrigues2(opencv_core.CvMat src,
                               opencv_core.CvMat dst,
                               opencv_core.CvMat jacobian)

cvRodrigues2

public static int cvRodrigues2(opencv_core.CvMat src,
                               opencv_core.CvMat dst)

cvFindHomography

public static int cvFindHomography(opencv_core.CvMat src_points,
                                   opencv_core.CvMat dst_points,
                                   opencv_core.CvMat homography,
                                   int method,
                                   double ransacReprojThreshold,
                                   opencv_core.CvMat mask)

cvFindHomography

public static int cvFindHomography(opencv_core.CvMat src_points,
                                   opencv_core.CvMat dst_points,
                                   opencv_core.CvMat homography)

cvRQDecomp3x3

public static void cvRQDecomp3x3(opencv_core.CvMat matrixM,
                                 opencv_core.CvMat matrixR,
                                 opencv_core.CvMat matrixQ,
                                 opencv_core.CvMat matrixQx,
                                 opencv_core.CvMat matrixQy,
                                 opencv_core.CvMat matrixQz,
                                 opencv_core.CvPoint3D64f eulerAngles)

cvRQDecomp3x3

public static void cvRQDecomp3x3(opencv_core.CvMat matrixM,
                                 opencv_core.CvMat matrixR,
                                 opencv_core.CvMat matrixQ)

cvRQDecomp3x3

public static void cvRQDecomp3x3(opencv_core.CvMat matrixM,
                                 opencv_core.CvMat matrixR,
                                 opencv_core.CvMat matrixQ,
                                 opencv_core.CvMat matrixQx,
                                 opencv_core.CvMat matrixQy,
                                 opencv_core.CvMat matrixQz,
                                 DoubleBuffer eulerAngles)

cvRQDecomp3x3

public static void cvRQDecomp3x3(opencv_core.CvMat matrixM,
                                 opencv_core.CvMat matrixR,
                                 opencv_core.CvMat matrixQ,
                                 opencv_core.CvMat matrixQx,
                                 opencv_core.CvMat matrixQy,
                                 opencv_core.CvMat matrixQz,
                                 double[] eulerAngles)

cvDecomposeProjectionMatrix

public static void cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr,
                                               opencv_core.CvMat calibMatr,
                                               opencv_core.CvMat rotMatr,
                                               opencv_core.CvMat posVect,
                                               opencv_core.CvMat rotMatrX,
                                               opencv_core.CvMat rotMatrY,
                                               opencv_core.CvMat rotMatrZ,
                                               opencv_core.CvPoint3D64f eulerAngles)

cvDecomposeProjectionMatrix

public static void cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr,
                                               opencv_core.CvMat calibMatr,
                                               opencv_core.CvMat rotMatr,
                                               opencv_core.CvMat posVect)

cvDecomposeProjectionMatrix

public static void cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr,
                                               opencv_core.CvMat calibMatr,
                                               opencv_core.CvMat rotMatr,
                                               opencv_core.CvMat posVect,
                                               opencv_core.CvMat rotMatrX,
                                               opencv_core.CvMat rotMatrY,
                                               opencv_core.CvMat rotMatrZ,
                                               DoubleBuffer eulerAngles)

cvDecomposeProjectionMatrix

public static void cvDecomposeProjectionMatrix(opencv_core.CvMat projMatr,
                                               opencv_core.CvMat calibMatr,
                                               opencv_core.CvMat rotMatr,
                                               opencv_core.CvMat posVect,
                                               opencv_core.CvMat rotMatrX,
                                               opencv_core.CvMat rotMatrY,
                                               opencv_core.CvMat rotMatrZ,
                                               double[] eulerAngles)

cvCalcMatMulDeriv

public static void cvCalcMatMulDeriv(opencv_core.CvMat A,
                                     opencv_core.CvMat B,
                                     opencv_core.CvMat dABdA,
                                     opencv_core.CvMat dABdB)

cvComposeRT

public static void cvComposeRT(opencv_core.CvMat _rvec1,
                               opencv_core.CvMat _tvec1,
                               opencv_core.CvMat _rvec2,
                               opencv_core.CvMat _tvec2,
                               opencv_core.CvMat _rvec3,
                               opencv_core.CvMat _tvec3,
                               opencv_core.CvMat dr3dr1,
                               opencv_core.CvMat dr3dt1,
                               opencv_core.CvMat dr3dr2,
                               opencv_core.CvMat dr3dt2,
                               opencv_core.CvMat dt3dr1,
                               opencv_core.CvMat dt3dt1,
                               opencv_core.CvMat dt3dr2,
                               opencv_core.CvMat dt3dt2)

cvComposeRT

public static void cvComposeRT(opencv_core.CvMat _rvec1,
                               opencv_core.CvMat _tvec1,
                               opencv_core.CvMat _rvec2,
                               opencv_core.CvMat _tvec2,
                               opencv_core.CvMat _rvec3,
                               opencv_core.CvMat _tvec3)

cvProjectPoints2

public static void cvProjectPoints2(opencv_core.CvMat object_points,
                                    opencv_core.CvMat rotation_vector,
                                    opencv_core.CvMat translation_vector,
                                    opencv_core.CvMat camera_matrix,
                                    opencv_core.CvMat distortion_coeffs,
                                    opencv_core.CvMat image_points,
                                    opencv_core.CvMat dpdrot,
                                    opencv_core.CvMat dpdt,
                                    opencv_core.CvMat dpdf,
                                    opencv_core.CvMat dpdc,
                                    opencv_core.CvMat dpddist,
                                    double aspect_ratio)

cvProjectPoints2

public static void cvProjectPoints2(opencv_core.CvMat object_points,
                                    opencv_core.CvMat rotation_vector,
                                    opencv_core.CvMat translation_vector,
                                    opencv_core.CvMat camera_matrix,
                                    opencv_core.CvMat distortion_coeffs,
                                    opencv_core.CvMat image_points)

cvFindExtrinsicCameraParams2

public static void cvFindExtrinsicCameraParams2(opencv_core.CvMat object_points,
                                                opencv_core.CvMat image_points,
                                                opencv_core.CvMat camera_matrix,
                                                opencv_core.CvMat distortion_coeffs,
                                                opencv_core.CvMat rotation_vector,
                                                opencv_core.CvMat translation_vector,
                                                int use_extrinsic_guess)

cvFindExtrinsicCameraParams2

public static void cvFindExtrinsicCameraParams2(opencv_core.CvMat object_points,
                                                opencv_core.CvMat image_points,
                                                opencv_core.CvMat camera_matrix,
                                                opencv_core.CvMat distortion_coeffs,
                                                opencv_core.CvMat rotation_vector,
                                                opencv_core.CvMat translation_vector)

cvInitIntrinsicParams2D

public static void cvInitIntrinsicParams2D(opencv_core.CvMat object_points,
                                           opencv_core.CvMat image_points,
                                           opencv_core.CvMat npoints,
                                           opencv_core.CvSize image_size,
                                           opencv_core.CvMat camera_matrix,
                                           double aspect_ratio)

cvInitIntrinsicParams2D

public static void cvInitIntrinsicParams2D(opencv_core.CvMat object_points,
                                           opencv_core.CvMat image_points,
                                           opencv_core.CvMat npoints,
                                           opencv_core.CvSize image_size,
                                           opencv_core.CvMat camera_matrix)

cvCheckChessboard

public static int cvCheckChessboard(opencv_core.IplImage src,
                                    opencv_core.CvSize size)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          opencv_core.CvPoint2D32f corners,
                                          IntPointer corner_count,
                                          int flags)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          opencv_core.CvPoint2D32f corners)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          FloatBuffer corners,
                                          IntBuffer corner_count,
                                          int flags)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          FloatBuffer corners)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          float[] corners,
                                          int[] corner_count,
                                          int flags)

cvFindChessboardCorners

public static int cvFindChessboardCorners(Pointer image,
                                          opencv_core.CvSize pattern_size,
                                          float[] corners)

cvDrawChessboardCorners

public static void cvDrawChessboardCorners(opencv_core.CvArr image,
                                           opencv_core.CvSize pattern_size,
                                           opencv_core.CvPoint2D32f corners,
                                           int count,
                                           int pattern_was_found)

cvDrawChessboardCorners

public static void cvDrawChessboardCorners(opencv_core.CvArr image,
                                           opencv_core.CvSize pattern_size,
                                           FloatBuffer corners,
                                           int count,
                                           int pattern_was_found)

cvDrawChessboardCorners

public static void cvDrawChessboardCorners(opencv_core.CvArr image,
                                           opencv_core.CvSize pattern_size,
                                           float[] corners,
                                           int count,
                                           int pattern_was_found)

cvCalibrateCamera2

public static double cvCalibrateCamera2(opencv_core.CvMat object_points,
                                        opencv_core.CvMat image_points,
                                        opencv_core.CvMat point_counts,
                                        opencv_core.CvSize image_size,
                                        opencv_core.CvMat camera_matrix,
                                        opencv_core.CvMat distortion_coeffs,
                                        opencv_core.CvMat rotation_vectors,
                                        opencv_core.CvMat translation_vectors,
                                        int flags,
                                        opencv_core.CvTermCriteria term_crit)

cvCalibrateCamera2

public static double cvCalibrateCamera2(opencv_core.CvMat object_points,
                                        opencv_core.CvMat image_points,
                                        opencv_core.CvMat point_counts,
                                        opencv_core.CvSize image_size,
                                        opencv_core.CvMat camera_matrix,
                                        opencv_core.CvMat distortion_coeffs)

cvCalibrationMatrixValues

public static void cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix,
                                             opencv_core.CvSize image_size,
                                             double aperture_width,
                                             double aperture_height,
                                             DoublePointer fovx,
                                             DoublePointer fovy,
                                             DoublePointer focal_length,
                                             opencv_core.CvPoint2D64f principal_point,
                                             DoublePointer pixel_aspect_ratio)

cvCalibrationMatrixValues

public static void cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix,
                                             opencv_core.CvSize image_size)

cvCalibrationMatrixValues

public static void cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix,
                                             opencv_core.CvSize image_size,
                                             double aperture_width,
                                             double aperture_height,
                                             DoubleBuffer fovx,
                                             DoubleBuffer fovy,
                                             DoubleBuffer focal_length,
                                             DoubleBuffer principal_point,
                                             DoubleBuffer pixel_aspect_ratio)

cvCalibrationMatrixValues

public static void cvCalibrationMatrixValues(opencv_core.CvMat camera_matrix,
                                             opencv_core.CvSize image_size,
                                             double aperture_width,
                                             double aperture_height,
                                             double[] fovx,
                                             double[] fovy,
                                             double[] focal_length,
                                             double[] principal_point,
                                             double[] pixel_aspect_ratio)

cvStereoCalibrate

public static double cvStereoCalibrate(opencv_core.CvMat object_points,
                                       opencv_core.CvMat image_points1,
                                       opencv_core.CvMat image_points2,
                                       opencv_core.CvMat npoints,
                                       opencv_core.CvMat camera_matrix1,
                                       opencv_core.CvMat dist_coeffs1,
                                       opencv_core.CvMat camera_matrix2,
                                       opencv_core.CvMat dist_coeffs2,
                                       opencv_core.CvSize image_size,
                                       opencv_core.CvMat R,
                                       opencv_core.CvMat T,
                                       opencv_core.CvMat E,
                                       opencv_core.CvMat F,
                                       opencv_core.CvTermCriteria term_crit,
                                       int flags)

cvStereoCalibrate

public static double cvStereoCalibrate(opencv_core.CvMat object_points,
                                       opencv_core.CvMat image_points1,
                                       opencv_core.CvMat image_points2,
                                       opencv_core.CvMat npoints,
                                       opencv_core.CvMat camera_matrix1,
                                       opencv_core.CvMat dist_coeffs1,
                                       opencv_core.CvMat camera_matrix2,
                                       opencv_core.CvMat dist_coeffs2,
                                       opencv_core.CvSize image_size,
                                       opencv_core.CvMat R,
                                       opencv_core.CvMat T)

cvStereoRectify

public static void cvStereoRectify(opencv_core.CvMat camera_matrix1,
                                   opencv_core.CvMat camera_matrix2,
                                   opencv_core.CvMat dist_coeffs1,
                                   opencv_core.CvMat dist_coeffs2,
                                   opencv_core.CvSize image_size,
                                   opencv_core.CvMat R,
                                   opencv_core.CvMat T,
                                   opencv_core.CvMat R1,
                                   opencv_core.CvMat R2,
                                   opencv_core.CvMat P1,
                                   opencv_core.CvMat P2,
                                   opencv_core.CvMat Q,
                                   int flags,
                                   double alpha,
                                   opencv_core.CvSize new_image_size,
                                   opencv_core.CvRect valid_pix_ROI1,
                                   opencv_core.CvRect valid_pix_ROI2)

cvStereoRectify

public static void cvStereoRectify(opencv_core.CvMat camera_matrix1,
                                   opencv_core.CvMat camera_matrix2,
                                   opencv_core.CvMat dist_coeffs1,
                                   opencv_core.CvMat dist_coeffs2,
                                   opencv_core.CvSize image_size,
                                   opencv_core.CvMat R,
                                   opencv_core.CvMat T,
                                   opencv_core.CvMat R1,
                                   opencv_core.CvMat R2,
                                   opencv_core.CvMat P1,
                                   opencv_core.CvMat P2)

cvStereoRectifyUncalibrated

public static int cvStereoRectifyUncalibrated(opencv_core.CvMat points1,
                                              opencv_core.CvMat points2,
                                              opencv_core.CvMat F,
                                              opencv_core.CvSize img_size,
                                              opencv_core.CvMat H1,
                                              opencv_core.CvMat H2,
                                              double threshold)

cvStereoRectifyUncalibrated

public static int cvStereoRectifyUncalibrated(opencv_core.CvMat points1,
                                              opencv_core.CvMat points2,
                                              opencv_core.CvMat F,
                                              opencv_core.CvSize img_size,
                                              opencv_core.CvMat H1,
                                              opencv_core.CvMat H2)

cvCreateStereoBMState

public static opencv_calib3d.CvStereoBMState cvCreateStereoBMState(int preset,
                                                                   int numberOfDisparities)

cvCreateStereoBMState

public static opencv_calib3d.CvStereoBMState cvCreateStereoBMState()

cvReleaseStereoBMState

public static void cvReleaseStereoBMState(PointerPointer state)

cvReleaseStereoBMState

public static void cvReleaseStereoBMState(opencv_calib3d.CvStereoBMState state)

cvFindStereoCorrespondenceBM

public static void cvFindStereoCorrespondenceBM(opencv_core.CvArr left,
                                                opencv_core.CvArr right,
                                                opencv_core.CvArr disparity,
                                                opencv_calib3d.CvStereoBMState state)

cvGetValidDisparityROI

public static opencv_core.CvRect cvGetValidDisparityROI(opencv_core.CvRect roi1,
                                                        opencv_core.CvRect roi2,
                                                        int minDisparity,
                                                        int numberOfDisparities,
                                                        int SADWindowSize)

cvValidateDisparity

public static void cvValidateDisparity(opencv_core.CvArr disparity,
                                       opencv_core.CvArr cost,
                                       int minDisparity,
                                       int numberOfDisparities,
                                       int disp12MaxDiff)

cvValidateDisparity

public static void cvValidateDisparity(opencv_core.CvArr disparity,
                                       opencv_core.CvArr cost,
                                       int minDisparity,
                                       int numberOfDisparities)

cvReprojectImageTo3D

public static void cvReprojectImageTo3D(opencv_core.CvArr disparityImage,
                                        opencv_core.CvArr _3dImage,
                                        opencv_core.CvMat Q,
                                        int handleMissingValues)

cvReprojectImageTo3D

public static void cvReprojectImageTo3D(opencv_core.CvArr disparityImage,
                                        opencv_core.CvArr _3dImage,
                                        opencv_core.CvMat Q)

Rodrigues

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

converts rotation vector to rotation matrix or vice versa using Rodrigues transformation

Rodrigues

public static void Rodrigues(opencv_core.Mat src,
                             opencv_core.Mat dst)

findHomography

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

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

findHomography

public static opencv_core.Mat findHomography(opencv_core.Mat srcPoints,
                                             opencv_core.Mat dstPoints)

findHomography

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

variant of findHomography for backward compatibility

findHomography

public static opencv_core.Mat findHomography(opencv_core.Mat srcPoints,
                                             opencv_core.Mat dstPoints,
                                             opencv_core.Mat mask)

RQDecomp3x3

public static opencv_core.Point3d RQDecomp3x3(opencv_core.Mat src,
                                              opencv_core.Mat mtxR,
                                              opencv_core.Mat mtxQ,
                                              opencv_core.Mat Qx,
                                              opencv_core.Mat Qy,
                                              opencv_core.Mat Qz)

Computes RQ decomposition of 3x3 matrix

RQDecomp3x3

public static opencv_core.Point3d RQDecomp3x3(opencv_core.Mat src,
                                              opencv_core.Mat mtxR,
                                              opencv_core.Mat mtxQ)

decomposeProjectionMatrix

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

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

decomposeProjectionMatrix

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

matMulDeriv

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

computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients

composeRT

public static void composeRT(opencv_core.Mat rvec1,
                             opencv_core.Mat tvec1,
                             opencv_core.Mat rvec2,
                             opencv_core.Mat tvec2,
                             opencv_core.Mat rvec3,
                             opencv_core.Mat tvec3,
                             opencv_core.Mat dr3dr1,
                             opencv_core.Mat dr3dt1,
                             opencv_core.Mat dr3dr2,
                             opencv_core.Mat dr3dt2,
                             opencv_core.Mat dt3dr1,
                             opencv_core.Mat dt3dt1,
                             opencv_core.Mat dt3dr2,
                             opencv_core.Mat dt3dt2)

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

composeRT

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

projectPoints

public static void projectPoints(opencv_core.Mat objectPoints,
                                 opencv_core.Mat rvec,
                                 opencv_core.Mat tvec,
                                 opencv_core.Mat cameraMatrix,
                                 opencv_core.Mat distCoeffs,
                                 opencv_core.Mat imagePoints,
                                 opencv_core.Mat jacobian,
                                 double aspectRatio)

projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters

projectPoints

public static void projectPoints(opencv_core.Mat objectPoints,
                                 opencv_core.Mat rvec,
                                 opencv_core.Mat tvec,
                                 opencv_core.Mat cameraMatrix,
                                 opencv_core.Mat distCoeffs,
                                 opencv_core.Mat imagePoints)

solvePnP

public static boolean solvePnP(opencv_core.Mat objectPoints,
                               opencv_core.Mat imagePoints,
                               opencv_core.Mat cameraMatrix,
                               opencv_core.Mat distCoeffs,
                               opencv_core.Mat rvec,
                               opencv_core.Mat tvec,
                               boolean useExtrinsicGuess,
                               int flags)

solvePnP

public static boolean solvePnP(opencv_core.Mat objectPoints,
                               opencv_core.Mat imagePoints,
                               opencv_core.Mat cameraMatrix,
                               opencv_core.Mat distCoeffs,
                               opencv_core.Mat rvec,
                               opencv_core.Mat tvec)

solvePnPRansac

public static void solvePnPRansac(opencv_core.Mat objectPoints,
                                  opencv_core.Mat imagePoints,
                                  opencv_core.Mat cameraMatrix,
                                  opencv_core.Mat distCoeffs,
                                  opencv_core.Mat rvec,
                                  opencv_core.Mat tvec,
                                  boolean useExtrinsicGuess,
                                  int iterationsCount,
                                  float reprojectionError,
                                  int minInliersCount,
                                  opencv_core.Mat inliers,
                                  int flags)

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.

solvePnPRansac

public static void solvePnPRansac(opencv_core.Mat objectPoints,
                                  opencv_core.Mat imagePoints,
                                  opencv_core.Mat cameraMatrix,
                                  opencv_core.Mat distCoeffs,
                                  opencv_core.Mat rvec,
                                  opencv_core.Mat tvec)

initCameraMatrix2D

public static opencv_core.Mat initCameraMatrix2D(opencv_core.MatVector objectPoints,
                                                 opencv_core.MatVector imagePoints,
                                                 opencv_core.Size imageSize,
                                                 double aspectRatio)

initializes camera matrix from a few 3D points and the corresponding projections.

initCameraMatrix2D

public static opencv_core.Mat initCameraMatrix2D(opencv_core.MatVector objectPoints,
                                                 opencv_core.MatVector imagePoints,
                                                 opencv_core.Size imageSize)

findChessboardCorners

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

finds checkerboard pattern of the specified size in the image

findChessboardCorners

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

find4QuadCornerSubpix

public static boolean find4QuadCornerSubpix(opencv_core.Mat img,
                                            opencv_core.Mat corners,
                                            opencv_core.Size region_size)

finds subpixel-accurate positions of the chessboard corners

drawChessboardCorners

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

draws the checkerboard pattern (found or partly found) in the image

findCirclesGrid

public static boolean findCirclesGrid(opencv_core.Mat image,
                                      opencv_core.Size patternSize,
                                      opencv_core.Mat centers,
                                      int flags,
                                      opencv_features2d.FeatureDetector blobDetector)

finds circles' grid pattern of the specified size in the image

findCirclesGrid

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

findCirclesGridDefault

public static boolean findCirclesGridDefault(opencv_core.Mat image,
                                             opencv_core.Size patternSize,
                                             opencv_core.Mat centers,
                                             int flags)

the deprecated function. Use findCirclesGrid() instead of it.

findCirclesGridDefault

public static boolean findCirclesGridDefault(opencv_core.Mat image,
                                             opencv_core.Size patternSize,
                                             opencv_core.Mat centers)

calibrateCamera

public static double calibrateCamera(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat cameraMatrix,
                                     opencv_core.Mat distCoeffs,
                                     opencv_core.MatVector rvecs,
                                     opencv_core.MatVector tvecs,
                                     int flags,
                                     opencv_core.TermCriteria criteria)

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

calibrateCamera

public static double calibrateCamera(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat cameraMatrix,
                                     opencv_core.Mat distCoeffs,
                                     opencv_core.MatVector rvecs,
                                     opencv_core.MatVector tvecs)

calibrationMatrixValues

public static void calibrationMatrixValues(opencv_core.Mat cameraMatrix,
                                           opencv_core.Size imageSize,
                                           double apertureWidth,
                                           double apertureHeight,
                                           DoublePointer fovx,
                                           DoublePointer fovy,
                                           DoublePointer focalLength,
                                           opencv_core.Point2d principalPoint,
                                           DoublePointer aspectRatio)

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

calibrationMatrixValues

public static void calibrationMatrixValues(opencv_core.Mat cameraMatrix,
                                           opencv_core.Size imageSize,
                                           double apertureWidth,
                                           double apertureHeight,
                                           DoubleBuffer fovx,
                                           DoubleBuffer fovy,
                                           DoubleBuffer focalLength,
                                           opencv_core.Point2d principalPoint,
                                           DoubleBuffer aspectRatio)

calibrationMatrixValues

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

stereoCalibrate

public static double stereoCalibrate(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints1,
                                     opencv_core.MatVector imagePoints2,
                                     opencv_core.Mat cameraMatrix1,
                                     opencv_core.Mat distCoeffs1,
                                     opencv_core.Mat cameraMatrix2,
                                     opencv_core.Mat distCoeffs2,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat R,
                                     opencv_core.Mat T,
                                     opencv_core.Mat E,
                                     opencv_core.Mat F,
                                     opencv_core.TermCriteria criteria,
                                     int flags)

finds intrinsic and extrinsic parameters of a stereo camera

stereoCalibrate

public static double stereoCalibrate(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints1,
                                     opencv_core.MatVector imagePoints2,
                                     opencv_core.Mat cameraMatrix1,
                                     opencv_core.Mat distCoeffs1,
                                     opencv_core.Mat cameraMatrix2,
                                     opencv_core.Mat distCoeffs2,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat R,
                                     opencv_core.Mat T,
                                     opencv_core.Mat E,
                                     opencv_core.Mat F)

stereoRectify

public static void stereoRectify(opencv_core.Mat cameraMatrix1,
                                 opencv_core.Mat distCoeffs1,
                                 opencv_core.Mat cameraMatrix2,
                                 opencv_core.Mat distCoeffs2,
                                 opencv_core.Size imageSize,
                                 opencv_core.Mat R,
                                 opencv_core.Mat T,
                                 opencv_core.Mat R1,
                                 opencv_core.Mat R2,
                                 opencv_core.Mat P1,
                                 opencv_core.Mat P2,
                                 opencv_core.Mat Q,
                                 int flags,
                                 double alpha,
                                 opencv_core.Size newImageSize,
                                 opencv_core.Rect validPixROI1,
                                 opencv_core.Rect validPixROI2)

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

stereoRectify

public static void stereoRectify(opencv_core.Mat cameraMatrix1,
                                 opencv_core.Mat distCoeffs1,
                                 opencv_core.Mat cameraMatrix2,
                                 opencv_core.Mat distCoeffs2,
                                 opencv_core.Size imageSize,
                                 opencv_core.Mat R,
                                 opencv_core.Mat T,
                                 opencv_core.Mat R1,
                                 opencv_core.Mat R2,
                                 opencv_core.Mat P1,
                                 opencv_core.Mat P2,
                                 opencv_core.Mat Q)

stereoRectifyUncalibrated

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

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)

stereoRectifyUncalibrated

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

rectify3Collinear

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

computes the rectification transformations for 3-head camera, where all the heads are on the same line.

getOptimalNewCameraMatrix

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

returns the optimal new camera matrix

getOptimalNewCameraMatrix

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

convertPointsToHomogeneous

public static void convertPointsToHomogeneous(opencv_core.Mat src,
                                              opencv_core.Mat dst)

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

convertPointsFromHomogeneous

public static void convertPointsFromHomogeneous(opencv_core.Mat src,
                                                opencv_core.Mat dst)

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

convertPointsHomogeneous

public static void convertPointsHomogeneous(opencv_core.Mat src,
                                            opencv_core.Mat dst)

for backward compatibility

findFundamentalMat

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

finds fundamental matrix from a set of corresponding 2D points

findFundamentalMat

public static opencv_core.Mat findFundamentalMat(opencv_core.Mat points1,
                                                 opencv_core.Mat points2)

findFundamentalMat

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

variant of findFundamentalMat for backward compatibility

findFundamentalMat

public static opencv_core.Mat findFundamentalMat(opencv_core.Mat points1,
                                                 opencv_core.Mat points2,
                                                 opencv_core.Mat mask)

computeCorrespondEpilines

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

finds coordinates of epipolar lines corresponding the specified points

triangulatePoints

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

correctMatches

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

filterSpeckles

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

filters off speckles (small regions of incorrectly computed disparity)

filterSpeckles

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

getValidDisparityROI

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

computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())

validateDisparity

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

validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm

validateDisparity

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

reprojectImageTo3D

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

reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify

reprojectImageTo3D

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

estimateAffine3D

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

estimateAffine3D

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

projectPoints

public static void projectPoints(opencv_core.Mat objectPoints,
                                 opencv_core.Mat imagePoints,
                                 opencv_core.Mat affine,
                                 opencv_core.Mat K,
                                 opencv_core.Mat D,
                                 double alpha,
                                 opencv_core.Mat jacobian)

projects 3D points using fisheye model

projectPoints

public static void projectPoints(opencv_core.Mat objectPoints,
                                 opencv_core.Mat imagePoints,
                                 opencv_core.Mat affine,
                                 opencv_core.Mat K,
                                 opencv_core.Mat D)

projectPoints

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

projects points using fisheye model

distortPoints

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

distorts 2D points using fisheye model

distortPoints

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

undistortPoints

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

undistorts 2D points using fisheye model

undistortPoints

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

initUndistortRectifyMap

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

computing undistortion and rectification maps for image transform by cv::remap() If D is empty zero distortion is used, if R or P is empty identity matrixes are used

undistortImage

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

undistorts image, optionally changes resolution and camera matrix. If Knew zero identity matrix is used

undistortImage

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

estimateNewCameraMatrixForUndistortRectify

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

estimates new camera matrix for undistortion or rectification

estimateNewCameraMatrixForUndistortRectify

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

calibrate

public static double calibrate(opencv_core.MatVector objectPoints,
                               opencv_core.MatVector imagePoints,
                               opencv_core.Size image_size,
                               opencv_core.Mat K,
                               opencv_core.Mat D,
                               opencv_core.MatVector rvecs,
                               opencv_core.MatVector tvecs,
                               int flags,
                               opencv_core.TermCriteria criteria)

performs camera calibaration

calibrate

public static double calibrate(opencv_core.MatVector objectPoints,
                               opencv_core.MatVector imagePoints,
                               opencv_core.Size image_size,
                               opencv_core.Mat K,
                               opencv_core.Mat D,
                               opencv_core.MatVector rvecs,
                               opencv_core.MatVector tvecs)

stereoRectify

public static void stereoRectify(opencv_core.Mat K1,
                                 opencv_core.Mat D1,
                                 opencv_core.Mat K2,
                                 opencv_core.Mat D2,
                                 opencv_core.Size imageSize,
                                 opencv_core.Mat R,
                                 opencv_core.Mat tvec,
                                 opencv_core.Mat R1,
                                 opencv_core.Mat R2,
                                 opencv_core.Mat P1,
                                 opencv_core.Mat P2,
                                 opencv_core.Mat Q,
                                 int flags,
                                 opencv_core.Size newImageSize,
                                 double balance,
                                 double fov_scale)

stereo rectification estimation

stereoRectify

public static void stereoRectify(opencv_core.Mat K1,
                                 opencv_core.Mat D1,
                                 opencv_core.Mat K2,
                                 opencv_core.Mat D2,
                                 opencv_core.Size imageSize,
                                 opencv_core.Mat R,
                                 opencv_core.Mat tvec,
                                 opencv_core.Mat R1,
                                 opencv_core.Mat R2,
                                 opencv_core.Mat P1,
                                 opencv_core.Mat P2,
                                 opencv_core.Mat Q,
                                 int flags)

stereoCalibrate

public static double stereoCalibrate(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints1,
                                     opencv_core.MatVector imagePoints2,
                                     opencv_core.Mat K1,
                                     opencv_core.Mat D1,
                                     opencv_core.Mat K2,
                                     opencv_core.Mat D2,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat R,
                                     opencv_core.Mat T,
                                     int flags,
                                     opencv_core.TermCriteria criteria)

performs stereo calibaration

stereoCalibrate

public static double stereoCalibrate(opencv_core.MatVector objectPoints,
                                     opencv_core.MatVector imagePoints1,
                                     opencv_core.MatVector imagePoints2,
                                     opencv_core.Mat K1,
                                     opencv_core.Mat D1,
                                     opencv_core.Mat K2,
                                     opencv_core.Mat D2,
                                     opencv_core.Size imageSize,
                                     opencv_core.Mat R,
                                     opencv_core.Mat T)

Class opencv_calib3d

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_calib3d

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.presets.opencv_calib3d

Methods inherited from class java.lang.Object

Field Detail

CV_FM_7POINT

CV_FM_8POINT

CV_LMEDS

CV_RANSAC

CV_FM_LMEDS_ONLY

CV_FM_RANSAC_ONLY

CV_FM_LMEDS

CV_FM_RANSAC

CV_ITERATIVE

CV_EPNP

CV_P3P

CV_CALIB_CB_ADAPTIVE_THRESH

CV_CALIB_CB_NORMALIZE_IMAGE

CV_CALIB_CB_FILTER_QUADS

CV_CALIB_CB_FAST_CHECK

CV_CALIB_USE_INTRINSIC_GUESS

CV_CALIB_FIX_ASPECT_RATIO

CV_CALIB_FIX_PRINCIPAL_POINT

CV_CALIB_ZERO_TANGENT_DIST

CV_CALIB_FIX_FOCAL_LENGTH

CV_CALIB_FIX_K1

CV_CALIB_FIX_K2

CV_CALIB_FIX_K3

CV_CALIB_FIX_K4

CV_CALIB_FIX_K5

CV_CALIB_FIX_K6

CV_CALIB_RATIONAL_MODEL

CV_CALIB_FIX_INTRINSIC

CV_CALIB_SAME_FOCAL_LENGTH

CV_CALIB_ZERO_DISPARITY

CV_STEREO_BM_NORMALIZED_RESPONSE

CV_STEREO_BM_XSOBEL

CV_STEREO_BM_BASIC

CV_STEREO_BM_FISH_EYE

CV_STEREO_BM_NARROW

LMEDS

RANSAC

ITERATIVE

EPNP

P3P

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_USE_INTRINSIC_GUESS

CALIB_FIX_ASPECT_RATIO

CALIB_FIX_PRINCIPAL_POINT

CALIB_ZERO_TANGENT_DIST

CALIB_FIX_FOCAL_LENGTH

CALIB_FIX_K1

CALIB_FIX_K2

CALIB_FIX_K3

CALIB_FIX_K4

CALIB_FIX_K5

CALIB_FIX_K6

CALIB_RATIONAL_MODEL

CALIB_FIX_INTRINSIC

CALIB_SAME_FOCAL_LENGTH

CALIB_ZERO_DISPARITY

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