public class opencv_calib3d extends opencv_calib3d
| Modifier and Type | Class and Description |
|---|---|
static class |
opencv_calib3d.CvLevMarq
\} calib3d_c
|
static class |
opencv_calib3d.CvPOSITObject
\
Camera Calibration, Pose Estimation and Stereo *
\
|
static class |
opencv_calib3d.CvStereoBMState |
static class |
opencv_calib3d.StereoBM
\brief Class for computing stereo correspondence using the block matching algorithm, introduced and
contributed to OpenCV by K.
|
static class |
opencv_calib3d.StereoMatcher
\brief The base class for stereo correspondence algorithms.
|
static class |
opencv_calib3d.StereoSGBM
\brief The class implements the modified H.
|
opencv_calib3d.AbstractCvPOSITObject, opencv_calib3d.AbstractCvStereoBMState| 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_FIX_S1_S2_S3_S4
enum cv::
|
static int |
CALIB_FIX_TAUX_TAUY
enum cv::
|
static int |
CALIB_RATIONAL_MODEL
enum cv::
|
static int |
CALIB_SAME_FOCAL_LENGTH
enum cv::
|
static int |
CALIB_THIN_PRISM_MODEL
enum cv::
|
static int |
CALIB_TILTED_MODEL
enum cv::
|
static int |
CALIB_USE_INTRINSIC_GUESS
enum cv::
|
static int |
CALIB_USE_LU
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_FIX_S1_S2_S3_S4 |
static int |
CV_CALIB_FIX_TAUX_TAUY |
static int |
CV_CALIB_RATIONAL_MODEL |
static int |
CV_CALIB_SAME_FOCAL_LENGTH |
static int |
CV_CALIB_THIN_PRISM_MODEL |
static int |
CV_CALIB_TILTED_MODEL |
static int |
CV_CALIB_USE_INTRINSIC_GUESS |
static int |
CV_CALIB_ZERO_DISPARITY |
static int |
CV_CALIB_ZERO_TANGENT_DIST |
static int |
CV_DLS
enum
|
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 |
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 |
LMEDS
enum cv::
|
static int |
RANSAC
enum cv::
|
static int |
RHO
enum cv::
|
static int |
SOLVEPNP_DLS
enum cv::
|
static int |
SOLVEPNP_EPNP
enum cv::
|
static int |
SOLVEPNP_ITERATIVE
enum cv::
|
static int |
SOLVEPNP_P3P
enum cv::
|
static int |
SOLVEPNP_UPNP
enum cv::
|
| Constructor and Description |
|---|
opencv_calib3d() |
| 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)
\brief 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)
\brief Finds the camera intrinsic and extrinsic parameters from several views of a 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)
\brief Computes useful camera characteristics from the camera matrix.
|
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)
\brief Combines two rotation-and-shift transformations.
|
static void |
computeCorrespondEpilines(opencv_core.Mat points,
int whichImage,
opencv_core.Mat F,
opencv_core.Mat lines)
\brief For points in an image of a stereo pair, computes the corresponding epilines in the other image.
|
static void |
convertPointsFromHomogeneous(opencv_core.Mat src,
opencv_core.Mat dst)
\brief Converts points from homogeneous to Euclidean space.
|
static void |
convertPointsHomogeneous(opencv_core.Mat src,
opencv_core.Mat dst)
\brief Converts points to/from homogeneous coordinates.
|
static void |
convertPointsToHomogeneous(opencv_core.Mat src,
opencv_core.Mat dst)
\brief Converts points from Euclidean to homogeneous space.
|
static void |
correctMatches(opencv_core.Mat F,
opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat newPoints1,
opencv_core.Mat newPoints2)
\brief Refines coordinates of corresponding points.
|
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,
int maxIters,
double confidence) |
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,
int flags,
opencv_core.CvTermCriteria term_crit) |
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 |
decomposeEssentialMat(opencv_core.Mat E,
opencv_core.Mat R1,
opencv_core.Mat R2,
opencv_core.Mat t)
\brief Decompose an essential matrix to possible rotations and translation.
|
static int |
decomposeHomographyMat(opencv_core.Mat H,
opencv_core.Mat K,
opencv_core.MatVector rotations,
opencv_core.MatVector translations,
opencv_core.MatVector normals)
\brief Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
|
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)
\brief Decomposes a projection matrix into a rotation matrix and a camera matrix.
|
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)
\brief Distorts 2D points using fisheye model.
|
static void |
drawChessboardCorners(opencv_core.Mat image,
opencv_core.Size patternSize,
opencv_core.Mat corners,
boolean patternWasFound)
\brief Renders the detected chessboard corners.
|
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)
\brief Computes an optimal affine transformation between two 3D point sets.
|
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)
\brief 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)
\brief Filters off small noise blobs (speckles) in the disparity map
|
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)
\brief Finds the positions of internal corners of the chessboard.
|
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.Feature2D blobDetector)
\brief Finds centers in the grid of circles.
|
static opencv_core.Mat |
findEssentialMat(opencv_core.Mat points1,
opencv_core.Mat points2) |
static opencv_core.Mat |
findEssentialMat(opencv_core.Mat points1,
opencv_core.Mat points2,
double focal,
opencv_core.Point2d pp,
int method,
double prob,
double threshold,
opencv_core.Mat mask)
\overload
|
static opencv_core.Mat |
findEssentialMat(opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat cameraMatrix) |
static opencv_core.Mat |
findEssentialMat(opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat cameraMatrix,
int method,
double prob,
double threshold,
opencv_core.Mat mask)
\brief Calculates an essential matrix from the corresponding points in two images.
|
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)
\brief Calculates a fundamental matrix from the corresponding points in two images.
|
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)
\overload
|
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,
int maxIters,
double confidence)
\brief Finds a perspective transformation between two planes.
|
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)
\overload
|
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)
\brief Returns the new camera matrix based on the free scaling parameter.
|
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)
\brief Finds an initial camera matrix from 3D-2D point correspondences.
|
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)
\brief Computes undistortion and rectification maps for image transform by cv::remap().
|
static void |
matMulDeriv(opencv_core.Mat A,
opencv_core.Mat B,
opencv_core.Mat dABdA,
opencv_core.Mat dABdB)
\brief Computes partial derivatives of the matrix product for each multiplied matrix.
|
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)
\brief 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) |
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)
\overload
|
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)
\brief Projects 3D points to an image plane.
|
static int |
recoverPose(opencv_core.Mat E,
opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat R,
opencv_core.Mat t) |
static int |
recoverPose(opencv_core.Mat E,
opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat R,
opencv_core.Mat t,
double focal,
opencv_core.Point2d pp,
opencv_core.Mat mask)
\overload
|
static int |
recoverPose(opencv_core.Mat E,
opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat cameraMatrix,
opencv_core.Mat R,
opencv_core.Mat t) |
static int |
recoverPose(opencv_core.Mat E,
opencv_core.Mat points1,
opencv_core.Mat points2,
opencv_core.Mat cameraMatrix,
opencv_core.Mat R,
opencv_core.Mat t,
opencv_core.Mat mask)
\brief Recover relative camera rotation and translation from an estimated essential matrix and the
corresponding points in two images, using cheirality check.
|
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)
\brief Reprojects a disparity image to 3D space.
|
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)
\brief Converts a rotation matrix to a rotation vector or vice versa.
|
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)
\brief Computes an RQ decomposition of 3x3 matrices.
|
static double |
sampsonDistance(opencv_core.Mat pt1,
opencv_core.Mat pt2,
opencv_core.Mat F)
\brief Calculates the Sampson Distance between two points.
|
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)
\brief Finds an object pose from 3D-2D point correspondences.
|
static boolean |
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 boolean |
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,
double confidence,
opencv_core.Mat inliers,
int flags)
\brief Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
|
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)
\brief Performs stereo calibration
|
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,
int flags,
opencv_core.TermCriteria criteria)
\brief Calibrates the 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)
\brief Computes rectification transforms for each head of a calibrated stereo camera.
|
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)
\brief Stereo rectification for fisheye camera model
|
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)
\brief Computes a rectification transform for an uncalibrated stereo camera.
|
static void |
triangulatePoints(opencv_core.Mat projMatr1,
opencv_core.Mat projMatr2,
opencv_core.Mat projPoints1,
opencv_core.Mat projPoints2,
opencv_core.Mat points4D)
\brief Reconstructs points by triangulation.
|
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)
\brief Transforms an image to compensate for fisheye lens distortion.
|
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)
\brief 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.
|
mappublic static final int CV_FM_7POINT
public static final int CV_FM_8POINT
public static final int CV_LMEDS
public static final int CV_RANSAC
public static final int CV_FM_LMEDS_ONLY
public static final int CV_FM_RANSAC_ONLY
public static final int CV_FM_LMEDS
public static final int CV_FM_RANSAC
public static final int CV_ITERATIVE
public static final int CV_EPNP
public static final int CV_P3P
public static final int CV_DLS
public static final int CV_CALIB_CB_ADAPTIVE_THRESH
public static final int CV_CALIB_CB_NORMALIZE_IMAGE
public static final int CV_CALIB_CB_FILTER_QUADS
public static final int CV_CALIB_CB_FAST_CHECK
public static final int CV_CALIB_USE_INTRINSIC_GUESS
public static final int CV_CALIB_FIX_ASPECT_RATIO
public static final int CV_CALIB_FIX_PRINCIPAL_POINT
public static final int CV_CALIB_ZERO_TANGENT_DIST
public static final int CV_CALIB_FIX_FOCAL_LENGTH
public static final int CV_CALIB_FIX_K1
public static final int CV_CALIB_FIX_K2
public static final int CV_CALIB_FIX_K3
public static final int CV_CALIB_FIX_K4
public static final int CV_CALIB_FIX_K5
public static final int CV_CALIB_FIX_K6
public static final int CV_CALIB_RATIONAL_MODEL
public static final int CV_CALIB_THIN_PRISM_MODEL
public static final int CV_CALIB_FIX_S1_S2_S3_S4
public static final int CV_CALIB_TILTED_MODEL
public static final int CV_CALIB_FIX_TAUX_TAUY
public static final int CV_CALIB_FIX_INTRINSIC
public static final int CV_CALIB_SAME_FOCAL_LENGTH
public static final int CV_CALIB_ZERO_DISPARITY
public static final int CV_STEREO_BM_NORMALIZED_RESPONSE
public static final int CV_STEREO_BM_XSOBEL
public static final int CV_STEREO_BM_BASIC
public static final int CV_STEREO_BM_FISH_EYE
public static final int CV_STEREO_BM_NARROW
public static final int LMEDS
public static final int RANSAC
public static final int RHO
public static final int SOLVEPNP_ITERATIVE
public static final int SOLVEPNP_EPNP
public static final int SOLVEPNP_P3P
public static final int SOLVEPNP_DLS
public static final int SOLVEPNP_UPNP
public static final int CALIB_CB_ADAPTIVE_THRESH
public static final int CALIB_CB_NORMALIZE_IMAGE
public static final int CALIB_CB_FILTER_QUADS
public static final int CALIB_CB_FAST_CHECK
public static final int CALIB_CB_SYMMETRIC_GRID
public static final int CALIB_CB_ASYMMETRIC_GRID
public static final int CALIB_CB_CLUSTERING
public static final int CALIB_USE_INTRINSIC_GUESS
public static final int CALIB_FIX_ASPECT_RATIO
public static final int CALIB_FIX_PRINCIPAL_POINT
public static final int CALIB_ZERO_TANGENT_DIST
public static final int CALIB_FIX_FOCAL_LENGTH
public static final int CALIB_FIX_K1
public static final int CALIB_FIX_K2
public static final int CALIB_FIX_K3
public static final int CALIB_FIX_K4
public static final int CALIB_FIX_K5
public static final int CALIB_FIX_K6
public static final int CALIB_RATIONAL_MODEL
public static final int CALIB_THIN_PRISM_MODEL
public static final int CALIB_FIX_S1_S2_S3_S4
public static final int CALIB_TILTED_MODEL
public static final int CALIB_FIX_TAUX_TAUY
public static final int CALIB_FIX_INTRINSIC
public static final int CALIB_SAME_FOCAL_LENGTH
public static final int CALIB_ZERO_DISPARITY
public static final int CALIB_USE_LU
public static final int FM_7POINT
public static final int FM_8POINT
public static final int FM_LMEDS
public static final int FM_RANSAC
public static final int FISHEYE_CALIB_USE_INTRINSIC_GUESS
public static final int FISHEYE_CALIB_RECOMPUTE_EXTRINSIC
public static final int FISHEYE_CALIB_CHECK_COND
public static final int FISHEYE_CALIB_FIX_SKEW
public static final int FISHEYE_CALIB_FIX_K1
public static final int FISHEYE_CALIB_FIX_K2
public static final int FISHEYE_CALIB_FIX_K3
public static final int FISHEYE_CALIB_FIX_K4
public static final int FISHEYE_CALIB_FIX_INTRINSIC
public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(opencv_core.CvPoint3D32f points, int point_count)
public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(@Cast(value="CvPoint3D32f*") FloatBuffer points, int point_count)
public static opencv_calib3d.CvPOSITObject cvCreatePOSITObject(@Cast(value="CvPoint3D32f*") float[] points, int point_count)
public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, opencv_core.CvPoint2D32f image_points, double focal_length, @ByVal opencv_core.CvTermCriteria criteria, FloatPointer rotation_matrix, FloatPointer translation_vector)
public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, @Cast(value="CvPoint2D32f*") FloatBuffer image_points, double focal_length, @ByVal opencv_core.CvTermCriteria criteria, FloatBuffer rotation_matrix, FloatBuffer translation_vector)
public static void cvPOSIT(opencv_calib3d.CvPOSITObject posit_object, @Cast(value="CvPoint2D32f*") float[] image_points, double focal_length, @ByVal opencv_core.CvTermCriteria criteria, float[] rotation_matrix, float[] translation_vector)
public static void cvReleasePOSITObject(@Cast(value="CvPOSITObject**") PointerPointer posit_object)
public static void cvReleasePOSITObject(@ByPtrPtr opencv_calib3d.CvPOSITObject posit_object)
public static int cvRANSACUpdateNumIters(double p,
double err_prob,
int model_points,
int max_iters)
public static void cvConvertPointsHomogeneous(@Const opencv_core.CvMat src, opencv_core.CvMat dst)
public static int cvFindFundamentalMat(@Const opencv_core.CvMat points1, @Const opencv_core.CvMat points2, opencv_core.CvMat fundamental_matrix, int method, double param1, double param2, opencv_core.CvMat status)
public static int cvFindFundamentalMat(@Const opencv_core.CvMat points1, @Const opencv_core.CvMat points2, opencv_core.CvMat fundamental_matrix)
public static void cvComputeCorrespondEpilines(@Const opencv_core.CvMat points, int which_image, @Const opencv_core.CvMat fundamental_matrix, opencv_core.CvMat correspondent_lines)
public static void cvTriangulatePoints(opencv_core.CvMat projMatr1, opencv_core.CvMat projMatr2, opencv_core.CvMat projPoints1, opencv_core.CvMat projPoints2, opencv_core.CvMat points4D)
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)
public static void cvGetOptimalNewCameraMatrix(@Const opencv_core.CvMat camera_matrix, @Const opencv_core.CvMat dist_coeffs, @ByVal opencv_core.CvSize image_size, double alpha, opencv_core.CvMat new_camera_matrix, @ByVal(nullValue="cvSize(0,0)") opencv_core.CvSize new_imag_size, opencv_core.CvRect valid_pixel_ROI, int center_principal_point)
public static void cvGetOptimalNewCameraMatrix(@Const opencv_core.CvMat camera_matrix, @Const opencv_core.CvMat dist_coeffs, @ByVal opencv_core.CvSize image_size, double alpha, opencv_core.CvMat new_camera_matrix)
public static int cvRodrigues2(@Const opencv_core.CvMat src, opencv_core.CvMat dst, opencv_core.CvMat jacobian)
public static int cvRodrigues2(@Const opencv_core.CvMat src, opencv_core.CvMat dst)
public static int cvFindHomography(@Const opencv_core.CvMat src_points, @Const opencv_core.CvMat dst_points, opencv_core.CvMat homography, int method, double ransacReprojThreshold, opencv_core.CvMat mask, int maxIters, double confidence)
public static int cvFindHomography(@Const opencv_core.CvMat src_points, @Const opencv_core.CvMat dst_points, opencv_core.CvMat homography)
public static void cvRQDecomp3x3(@Const 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)
public static void cvRQDecomp3x3(@Const opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ)
public static void cvRQDecomp3x3(@Const opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ, opencv_core.CvMat matrixQx, opencv_core.CvMat matrixQy, opencv_core.CvMat matrixQz, @Cast(value="CvPoint3D64f*") DoubleBuffer eulerAngles)
public static void cvRQDecomp3x3(@Const opencv_core.CvMat matrixM, opencv_core.CvMat matrixR, opencv_core.CvMat matrixQ, opencv_core.CvMat matrixQx, opencv_core.CvMat matrixQy, opencv_core.CvMat matrixQz, @Cast(value="CvPoint3D64f*") double[] eulerAngles)
public static void cvDecomposeProjectionMatrix(@Const 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)
public static void cvDecomposeProjectionMatrix(@Const opencv_core.CvMat projMatr, opencv_core.CvMat calibMatr, opencv_core.CvMat rotMatr, opencv_core.CvMat posVect)
public static void cvDecomposeProjectionMatrix(@Const 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, @Cast(value="CvPoint3D64f*") DoubleBuffer eulerAngles)
public static void cvDecomposeProjectionMatrix(@Const 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, @Cast(value="CvPoint3D64f*") double[] eulerAngles)
public static void cvCalcMatMulDeriv(@Const opencv_core.CvMat A, @Const opencv_core.CvMat B, opencv_core.CvMat dABdA, opencv_core.CvMat dABdB)
public static void cvComposeRT(@Const opencv_core.CvMat _rvec1, @Const opencv_core.CvMat _tvec1, @Const opencv_core.CvMat _rvec2, @Const 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)
public static void cvComposeRT(@Const opencv_core.CvMat _rvec1, @Const opencv_core.CvMat _tvec1, @Const opencv_core.CvMat _rvec2, @Const opencv_core.CvMat _tvec2, opencv_core.CvMat _rvec3, opencv_core.CvMat _tvec3)
public static void cvProjectPoints2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat rotation_vector, @Const opencv_core.CvMat translation_vector, @Const opencv_core.CvMat camera_matrix, @Const 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)
public static void cvProjectPoints2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat rotation_vector, @Const opencv_core.CvMat translation_vector, @Const opencv_core.CvMat camera_matrix, @Const opencv_core.CvMat distortion_coeffs, opencv_core.CvMat image_points)
public static void cvFindExtrinsicCameraParams2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat camera_matrix, @Const opencv_core.CvMat distortion_coeffs, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector, int use_extrinsic_guess)
public static void cvFindExtrinsicCameraParams2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat camera_matrix, @Const opencv_core.CvMat distortion_coeffs, opencv_core.CvMat rotation_vector, opencv_core.CvMat translation_vector)
public static void cvInitIntrinsicParams2D(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat npoints, @ByVal opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix, double aspect_ratio)
public static void cvInitIntrinsicParams2D(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat npoints, @ByVal opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix)
public static int cvCheckChessboard(opencv_core.IplImage src, @ByVal opencv_core.CvSize size)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners, IntPointer corner_count, int flags)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") FloatBuffer corners, IntBuffer corner_count, int flags)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") FloatBuffer corners)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") float[] corners, int[] corner_count, int flags)
public static int cvFindChessboardCorners(@Const Pointer image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") float[] corners)
public static void cvDrawChessboardCorners(opencv_core.CvArr image, @ByVal opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners, int count, int pattern_was_found)
public static void cvDrawChessboardCorners(opencv_core.CvArr image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") FloatBuffer corners, int count, int pattern_was_found)
public static void cvDrawChessboardCorners(opencv_core.CvArr image, @ByVal opencv_core.CvSize pattern_size, @Cast(value="CvPoint2D32f*") float[] corners, int count, int pattern_was_found)
public static double cvCalibrateCamera2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat point_counts, @ByVal 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, @ByVal(nullValue="cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON)") opencv_core.CvTermCriteria term_crit)
public static double cvCalibrateCamera2(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points, @Const opencv_core.CvMat point_counts, @ByVal opencv_core.CvSize image_size, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs)
public static void cvCalibrationMatrixValues(@Const opencv_core.CvMat camera_matrix, @ByVal 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)
public static void cvCalibrationMatrixValues(@Const opencv_core.CvMat camera_matrix, @ByVal opencv_core.CvSize image_size)
public static void cvCalibrationMatrixValues(@Const opencv_core.CvMat camera_matrix, @ByVal opencv_core.CvSize image_size, double aperture_width, double aperture_height, DoubleBuffer fovx, DoubleBuffer fovy, DoubleBuffer focal_length, @Cast(value="CvPoint2D64f*") DoubleBuffer principal_point, DoubleBuffer pixel_aspect_ratio)
public static void cvCalibrationMatrixValues(@Const opencv_core.CvMat camera_matrix, @ByVal opencv_core.CvSize image_size, double aperture_width, double aperture_height, double[] fovx, double[] fovy, double[] focal_length, @Cast(value="CvPoint2D64f*") double[] principal_point, double[] pixel_aspect_ratio)
public static double cvStereoCalibrate(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points1, @Const opencv_core.CvMat image_points2, @Const opencv_core.CvMat npoints, opencv_core.CvMat camera_matrix1, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs2, @ByVal opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T, opencv_core.CvMat E, opencv_core.CvMat F, int flags, @ByVal(nullValue="cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6)") opencv_core.CvTermCriteria term_crit)
public static double cvStereoCalibrate(@Const opencv_core.CvMat object_points, @Const opencv_core.CvMat image_points1, @Const opencv_core.CvMat image_points2, @Const opencv_core.CvMat npoints, opencv_core.CvMat camera_matrix1, opencv_core.CvMat dist_coeffs1, opencv_core.CvMat camera_matrix2, opencv_core.CvMat dist_coeffs2, @ByVal opencv_core.CvSize image_size, opencv_core.CvMat R, opencv_core.CvMat T)
public static void cvStereoRectify(@Const opencv_core.CvMat camera_matrix1, @Const opencv_core.CvMat camera_matrix2, @Const opencv_core.CvMat dist_coeffs1, @Const opencv_core.CvMat dist_coeffs2, @ByVal opencv_core.CvSize image_size, @Const opencv_core.CvMat R, @Const 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, @ByVal(nullValue="cvSize(0,0)") opencv_core.CvSize new_image_size, opencv_core.CvRect valid_pix_ROI1, opencv_core.CvRect valid_pix_ROI2)
public static void cvStereoRectify(@Const opencv_core.CvMat camera_matrix1, @Const opencv_core.CvMat camera_matrix2, @Const opencv_core.CvMat dist_coeffs1, @Const opencv_core.CvMat dist_coeffs2, @ByVal opencv_core.CvSize image_size, @Const opencv_core.CvMat R, @Const opencv_core.CvMat T, opencv_core.CvMat R1, opencv_core.CvMat R2, opencv_core.CvMat P1, opencv_core.CvMat P2)
public static int cvStereoRectifyUncalibrated(@Const opencv_core.CvMat points1, @Const opencv_core.CvMat points2, @Const opencv_core.CvMat F, @ByVal opencv_core.CvSize img_size, opencv_core.CvMat H1, opencv_core.CvMat H2, double threshold)
public static int cvStereoRectifyUncalibrated(@Const opencv_core.CvMat points1, @Const opencv_core.CvMat points2, @Const opencv_core.CvMat F, @ByVal opencv_core.CvSize img_size, opencv_core.CvMat H1, opencv_core.CvMat H2)
public static opencv_calib3d.CvStereoBMState cvCreateStereoBMState(int preset, int numberOfDisparities)
public static opencv_calib3d.CvStereoBMState cvCreateStereoBMState()
public static void cvReleaseStereoBMState(@Cast(value="CvStereoBMState**") PointerPointer state)
public static void cvReleaseStereoBMState(@ByPtrPtr opencv_calib3d.CvStereoBMState state)
public static void cvFindStereoCorrespondenceBM(@Const opencv_core.CvArr left, @Const opencv_core.CvArr right, opencv_core.CvArr disparity, opencv_calib3d.CvStereoBMState state)
@ByVal public static opencv_core.CvRect cvGetValidDisparityROI(@ByVal opencv_core.CvRect roi1, @ByVal opencv_core.CvRect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
public static void cvValidateDisparity(opencv_core.CvArr disparity, @Const opencv_core.CvArr cost, int minDisparity, int numberOfDisparities, int disp12MaxDiff)
public static void cvValidateDisparity(opencv_core.CvArr disparity, @Const opencv_core.CvArr cost, int minDisparity, int numberOfDisparities)
public static void cvReprojectImageTo3D(@Const opencv_core.CvArr disparityImage, opencv_core.CvArr _3dImage, @Const opencv_core.CvMat Q, int handleMissingValues)
public static void cvReprojectImageTo3D(@Const opencv_core.CvArr disparityImage, opencv_core.CvArr _3dImage, @Const opencv_core.CvMat Q)
@Namespace(value="cv") public static void Rodrigues(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst, @ByVal(nullValue="cv::noArray()") opencv_core.Mat jacobian)
src - Input rotation vector (3x1 or 1x3) or rotation matrix (3x3).dst - Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively.jacobian - Optional output Jacobian matrix, 3x9 or 9x3, which is a matrix of partial
derivatives of the output array components with respect to the input array components.
\f[\begin{array}{l} \theta \leftarrow norm(r) \\ r \leftarrow r/ \theta \\ R = \cos{\theta} I + (1- \cos{\theta} ) r r^T + \sin{\theta} \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}\f]
Inverse transformation can be also done easily, since
\f[\sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}\f]
A rotation vector is a convenient and most compact representation of a rotation matrix (since any rotation matrix has just 3 degrees of freedom). The representation is used in the global 3D geometry optimization procedures like calibrateCamera, stereoCalibrate, or solvePnP .
@Namespace(value="cv") public static void Rodrigues(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findHomography(@ByVal opencv_core.Mat srcPoints, @ByVal opencv_core.Mat dstPoints, int method, double ransacReprojThreshold, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask, int maxIters, double confidence)
srcPoints - Coordinates of the points in the original plane, a matrix of the type CV_32FC2
or vector\dstPoints - Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
a vector\method - Method used to computed a homography matrix. The following methods are possible:
- **0** - a regular method using all the points
- **RANSAC** - RANSAC-based robust method
- **LMEDS** - Least-Median robust method
- **RHO** - PROSAC-based robust methodransacReprojThreshold - Maximum allowed reprojection error to treat a point pair as an inlier
(used in the RANSAC and RHO methods only). That is, if
\f[\| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \| > \texttt{ransacReprojThreshold}\f]
then the point \f$i\f$ is considered an outlier. If srcPoints and dstPoints are measured in pixels,
it usually makes sense to set this parameter somewhere in the range of 1 to 10.mask - Optional output mask set by a robust method ( RANSAC or LMEDS ). Note that the input
mask values are ignored.maxIters - The maximum number of RANSAC iterations, 2000 is the maximum it can be.confidence - Confidence level, between 0 and 1.
The functions find and return the perspective transformation \f$H\f$ between the source and the destination planes:
\f[s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}\f]
so that the back-projection error
\f[\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2\f]
is minimized. If the parameter method is set to the default value 0, the function uses all the point pairs to compute an initial homography estimate with a simple least-squares scheme.
However, if not all of the point pairs ( \f$srcPoints_i\f$, \f$dstPoints_i\f$ ) fit the rigid perspective transformation (that is, there are some outliers), this initial estimate will be poor. In this case, you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different random subsets of the corresponding point pairs (of four pairs each), estimate the homography matrix using this subset and a simple least-square algorithm, and then compute the quality/goodness of the computed homography (which is the number of inliers for RANSAC or the median re-projection error for LMeDs). The best subset is then used to produce the initial estimate of the homography matrix and the mask of inliers/outliers.
Regardless of the method, robust or not, the computed homography matrix is refined further (using inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the re-projection error even more.
The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to distinguish inliers from outliers. The method LMeDS does not need any threshold but it works correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the noise is rather small, use the default method (method=0).
The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is determined up to a scale. Thus, it is normalized so that \f$h_{33}=1\f$. Note that whenever an H matrix cannot be estimated, an empty one will be returned.
\sa getAffineTransform, getPerspectiveTransform, estimateRigidTransform, warpPerspective, perspectiveTransform
\note - A example on calculating a homography for image matching can be found at opencv_source_code/samples/cpp/video_homography.cpp
@Namespace(value="cv") @ByVal public static opencv_core.Mat findHomography(@ByVal opencv_core.Mat srcPoints, @ByVal opencv_core.Mat dstPoints)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findHomography(@ByVal opencv_core.Mat srcPoints, @ByVal opencv_core.Mat dstPoints, @ByVal opencv_core.Mat mask, int method, double ransacReprojThreshold)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findHomography(@ByVal opencv_core.Mat srcPoints, @ByVal opencv_core.Mat dstPoints, @ByVal opencv_core.Mat mask)
@Namespace(value="cv") @ByVal public static opencv_core.Point3d RQDecomp3x3(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat mtxR, @ByVal opencv_core.Mat mtxQ, @ByVal(nullValue="cv::noArray()") opencv_core.Mat Qx, @ByVal(nullValue="cv::noArray()") opencv_core.Mat Qy, @ByVal(nullValue="cv::noArray()") opencv_core.Mat Qz)
src - 3x3 input matrix.mtxR - Output 3x3 upper-triangular matrix.mtxQ - Output 3x3 orthogonal matrix.Qx - Optional output 3x3 rotation matrix around x-axis.Qy - Optional output 3x3 rotation matrix around y-axis.Qz - Optional output 3x3 rotation matrix around z-axis.
The function computes a RQ decomposition using the given rotations. This function is used in decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera and a rotation matrix.
It optionally returns three rotation matrices, one for each axis, and the three Euler angles in degrees (as the return value) that could be used in OpenGL. Note, there is always more than one sequence of rotations about the three principle axes that results in the same orientation of an object, eg. see \cite Slabaugh . Returned tree rotation matrices and corresponding three Euler angules are only one of the possible solutions.
@Namespace(value="cv") @ByVal public static opencv_core.Point3d RQDecomp3x3(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat mtxR, @ByVal opencv_core.Mat mtxQ)
@Namespace(value="cv") public static void decomposeProjectionMatrix(@ByVal opencv_core.Mat projMatrix, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat rotMatrix, @ByVal opencv_core.Mat transVect, @ByVal(nullValue="cv::noArray()") opencv_core.Mat rotMatrixX, @ByVal(nullValue="cv::noArray()") opencv_core.Mat rotMatrixY, @ByVal(nullValue="cv::noArray()") opencv_core.Mat rotMatrixZ, @ByVal(nullValue="cv::noArray()") opencv_core.Mat eulerAngles)
projMatrix - 3x4 input projection matrix P.cameraMatrix - Output 3x3 camera matrix K.rotMatrix - Output 3x3 external rotation matrix R.transVect - Output 4x1 translation vector T.rotMatrixX - Optional 3x3 rotation matrix around x-axis.rotMatrixY - Optional 3x3 rotation matrix around y-axis.rotMatrixZ - Optional 3x3 rotation matrix around z-axis.eulerAngles - Optional three-element vector containing three Euler angles of rotation in
degrees.
The function computes a decomposition of a projection matrix into a calibration and a rotation matrix and the position of a camera.
It optionally returns three rotation matrices, one for each axis, and three Euler angles that could be used in OpenGL. Note, there is always more than one sequence of rotations about the three principle axes that results in the same orientation of an object, eg. see \cite Slabaugh . Returned tree rotation matrices and corresponding three Euler angules are only one of the possible solutions.
The function is based on RQDecomp3x3 .
@Namespace(value="cv") public static void decomposeProjectionMatrix(@ByVal opencv_core.Mat projMatrix, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat rotMatrix, @ByVal opencv_core.Mat transVect)
@Namespace(value="cv") public static void matMulDeriv(@ByVal opencv_core.Mat A, @ByVal opencv_core.Mat B, @ByVal opencv_core.Mat dABdA, @ByVal opencv_core.Mat dABdB)
A - First multiplied matrix.B - Second multiplied matrix.dABdA - First output derivative matrix d(A\*B)/dA of size
\f$\texttt{A.rows*B.cols} \times {A.rows*A.cols}\f$ .dABdB - Second output derivative matrix d(A\*B)/dB of size
\f$\texttt{A.rows*B.cols} \times {B.rows*B.cols}\f$ .
The function computes partial derivatives of the elements of the matrix product \f$A*B\f$ with regard to the elements of each of the two input matrices. The function is used to compute the Jacobian matrices in stereoCalibrate but can also be used in any other similar optimization function.
@Namespace(value="cv") public static void composeRT(@ByVal opencv_core.Mat rvec1, @ByVal opencv_core.Mat tvec1, @ByVal opencv_core.Mat rvec2, @ByVal opencv_core.Mat tvec2, @ByVal opencv_core.Mat rvec3, @ByVal opencv_core.Mat tvec3, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dr3dr1, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dr3dt1, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dr3dr2, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dr3dt2, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dt3dr1, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dt3dt1, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dt3dr2, @ByVal(nullValue="cv::noArray()") opencv_core.Mat dt3dt2)
rvec1 - First rotation vector.tvec1 - First translation vector.rvec2 - Second rotation vector.tvec2 - Second translation vector.rvec3 - Output rotation vector of the superposition.tvec3 - Output translation vector of the superposition.dr3dr1 - dr3dt1 - dr3dr2 - dr3dt2 - dt3dr1 - dt3dt1 - dt3dr2 - dt3dt2 - Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and
tvec2, respectively.
The functions compute:
\f[\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,\f]
where \f$\mathrm{rodrigues}\f$ denotes a rotation vector to a rotation matrix transformation, and \f$\mathrm{rodrigues}^{-1}\f$ denotes the inverse transformation. See Rodrigues for details.
Also, the functions can compute the derivatives of the output vectors with regards to the input vectors (see matMulDeriv ). The functions are used inside stereoCalibrate but can also be used in your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a function that contains a matrix multiplication.
@Namespace(value="cv") public static void composeRT(@ByVal opencv_core.Mat rvec1, @ByVal opencv_core.Mat tvec1, @ByVal opencv_core.Mat rvec2, @ByVal opencv_core.Mat tvec2, @ByVal opencv_core.Mat rvec3, @ByVal opencv_core.Mat tvec3)
@Namespace(value="cv") public static void projectPoints(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat imagePoints, @ByVal(nullValue="cv::noArray()") opencv_core.Mat jacobian, double aspectRatio)
objectPoints - Array of object points, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel (or
vector\rvec - Rotation vector. See Rodrigues for details.tvec - Translation vector.cameraMatrix - Camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$ .distCoeffs - Input vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements. If the vector is empty, the zero distortion coefficients are assumed.imagePoints - Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or
vector\jacobian - Optional output 2Nx(10+\aspectRatio - Optional "fixed aspect ratio" parameter. If the parameter is not 0, the
function assumes that the aspect ratio (*fx/fy*) is fixed and correspondingly adjusts the jacobian
matrix.
The function computes projections of 3D points to the image plane given intrinsic and extrinsic camera parameters. Optionally, the function computes Jacobians - matrices of partial derivatives of image points coordinates (as functions of all the input parameters) with respect to the particular parameters, intrinsic and/or extrinsic. The Jacobians are used during the global optimization in calibrateCamera, solvePnP, and stereoCalibrate . The function itself can also be used to compute a re-projection error given the current intrinsic and extrinsic parameters.
\note By setting rvec=tvec=(0,0,0) or by setting cameraMatrix to a 3x3 identity matrix, or by passing zero distortion coefficients, you can get various useful partial cases of the function. This means that you can compute the distorted coordinates for a sparse set of points or apply a perspective transformation (and also compute the derivatives) in the ideal zero-distortion setup.
@Namespace(value="cv") public static void projectPoints(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat imagePoints)
@Namespace(value="cv") @Cast(value="bool") public static boolean solvePnP(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec, @Cast(value="bool") boolean useExtrinsicGuess, int flags)
objectPoints - Array of object points in the object coordinate space, 3xN/Nx3 1-channel or
1xN/Nx1 3-channel, where N is the number of points. vector\imagePoints - Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel,
where N is the number of points. vector\cameraMatrix - Input camera matrix \f$A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}\f$ .distCoeffs - Input vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are
assumed.rvec - Output rotation vector (see Rodrigues ) that, together with tvec , brings points from
the model coordinate system to the camera coordinate system.tvec - Output translation vector.useExtrinsicGuess - Parameter used for SOLVEPNP_ITERATIVE. If true (1), the function uses
the provided rvec and tvec values as initial approximations of the rotation and translation
vectors, respectively, and further optimizes them.flags - Method for solving a PnP problem:
- **SOLVEPNP_ITERATIVE** Iterative method is based on Levenberg-Marquardt optimization. In
this case the function finds such a pose that minimizes reprojection error, that is the sum
of squared distances between the observed projections imagePoints and the projected (using
projectPoints ) objectPoints .
- **SOLVEPNP_P3P** Method is based on the paper of X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang
"Complete Solution Classification for the Perspective-Three-Point Problem". In this case the
function requires exactly four object and image points.
- **SOLVEPNP_EPNP** Method has been introduced by F.Moreno-Noguer, V.Lepetit and P.Fua in the
paper "EPnP: Efficient Perspective-n-Point Camera Pose Estimation".
- **SOLVEPNP_DLS** Method is based on the paper of Joel A. Hesch and Stergios I. Roumeliotis.
"A Direct Least-Squares (DLS) Method for PnP".
- **SOLVEPNP_UPNP** Method is based on the paper of A.Penate-Sanchez, J.Andrade-Cetto,
F.Moreno-Noguer. "Exhaustive Linearization for Robust Camera Pose and Focal Length
Estimation". In this case the function also estimates the parameters \f$f_x\f$ and \f$f_y\f$
assuming that both have the same value. Then the cameraMatrix is updated with the estimated
focal length.
The function estimates the object pose given a set of object points, their corresponding image projections, as well as the camera matrix and the distortion coefficients.
\note - An example of how to use solvePnP for planar augmented reality can be found at opencv_source_code/samples/python/plane_ar.py - If you are using Python: - Numpy array slices won't work as input because solvePnP requires contiguous arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of modules/calib3d/src/solvepnp.cpp version 2.4.9) - The P3P algorithm requires image points to be in an array of shape (N,1,2) due to its calling of cv::undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9) which requires 2-channel information. - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints = np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
@Namespace(value="cv") @Cast(value="bool") public static boolean solvePnP(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec)
@Namespace(value="cv") @Cast(value="bool") public static boolean solvePnPRansac(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec, @Cast(value="bool") boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, @ByVal(nullValue="cv::noArray()") opencv_core.Mat inliers, int flags)
objectPoints - Array of object points in the object coordinate space, 3xN/Nx3 1-channel or
1xN/Nx1 3-channel, where N is the number of points. vector\imagePoints - Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel,
where N is the number of points. vector\cameraMatrix - Input camera matrix \f$A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}\f$ .distCoeffs - Input vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are
assumed.rvec - Output rotation vector (see Rodrigues ) that, together with tvec , brings points from
the model coordinate system to the camera coordinate system.tvec - Output translation vector.useExtrinsicGuess - Parameter used for SOLVEPNP_ITERATIVE. If true (1), the function uses
the provided rvec and tvec values as initial approximations of the rotation and translation
vectors, respectively, and further optimizes them.iterationsCount - Number of iterations.reprojectionError - Inlier threshold value used by the RANSAC procedure. The parameter value
is the maximum allowed distance between the observed and computed point projections to consider it
an inlier.confidence - The probability that the algorithm produces a useful result.inliers - Output vector that contains indices of inliers in objectPoints and imagePoints .flags - Method for solving a PnP problem (see solvePnP ).
The function estimates an object pose given a set of object points, their corresponding image projections, as well as the camera matrix and the distortion coefficients. This function finds such a pose that minimizes reprojection error, that is, the sum of squared distances between the observed projections imagePoints and the projected (using projectPoints ) objectPoints. The use of RANSAC makes the function resistant to outliers.
\note - An example of how to use solvePNPRansac for object detection can be found at opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
@Namespace(value="cv") @Cast(value="bool") public static boolean solvePnPRansac(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec)
@Namespace(value="cv") @ByVal public static opencv_core.Mat initCameraMatrix2D(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @ByVal opencv_core.Size imageSize, double aspectRatio)
objectPoints - Vector of vectors of the calibration pattern points in the calibration pattern
coordinate space. In the old interface all the per-view vectors are concatenated. See
calibrateCamera for details.imagePoints - Vector of vectors of the projections of the calibration pattern points. In the
old interface all the per-view vectors are concatenated.imageSize - Image size in pixels used to initialize the principal point.aspectRatio - If it is zero or negative, both \f$f_x\f$ and \f$f_y\f$ are estimated independently.
Otherwise, \f$f_x = f_y * \texttt{aspectRatio}\f$ .
The function estimates and returns an initial camera matrix for the camera calibration process. Currently, the function only supports planar calibration patterns, which are patterns where each object point has z-coordinate =0.
@Namespace(value="cv") @ByVal public static opencv_core.Mat initCameraMatrix2D(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @ByVal opencv_core.Size imageSize)
@Namespace(value="cv") @Cast(value="bool") public static boolean findChessboardCorners(@ByVal opencv_core.Mat image, @ByVal opencv_core.Size patternSize, @ByVal opencv_core.Mat corners, int flags)
image - Source chessboard view. It must be an 8-bit grayscale or color image.patternSize - Number of inner corners per a chessboard row and column
( patternSize = cvSize(points_per_row,points_per_colum) = cvSize(columns,rows) ).corners - Output array of detected corners.flags - Various operation flags that can be zero or a combination of the following values:
- **CV_CALIB_CB_ADAPTIVE_THRESH** Use adaptive thresholding to convert the image to black
and white, rather than a fixed threshold level (computed from the average image brightness).
- **CV_CALIB_CB_NORMALIZE_IMAGE** Normalize the image gamma with equalizeHist before
applying fixed or adaptive thresholding.
- **CV_CALIB_CB_FILTER_QUADS** Use additional criteria (like contour area, perimeter,
square-like shape) to filter out false quads extracted at the contour retrieval stage.
- **CALIB_CB_FAST_CHECK** Run a fast check on the image that looks for chessboard corners,
and shortcut the call if none is found. This can drastically speed up the call in the
degenerate condition when no chessboard is observed.
The function attempts to determine whether the input image is a view of the chessboard pattern and locate the internal chessboard corners. The function returns a non-zero value if all of the corners are found and they are placed in a certain order (row by row, left to right in every row). Otherwise, if the function fails to find all the corners or reorder them, it returns 0. For example, a regular chessboard has 8 x 8 squares and 7 x 7 internal corners, that is, points where the black squares touch each other. The detected coordinates are approximate, and to determine their positions more accurately, the function calls cornerSubPix. You also may use the function cornerSubPix with different parameters if returned coordinates are not accurate enough.
Sample usage of detecting and drawing chessboard corners: :
Size patternsize(8,6); //interior number of corners
Mat gray = ....; //source image
vector<Point2f> corners; //this will be filled by the detected corners
//CALIB_CB_FAST_CHECK saves a lot of time on images
//that do not contain any chessboard corners
bool patternfound = findChessboardCorners(gray, patternsize, corners,
CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
+ CALIB_CB_FAST_CHECK);
if(patternfound)
cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
@Namespace(value="cv") @Cast(value="bool") public static boolean findChessboardCorners(@ByVal opencv_core.Mat image, @ByVal opencv_core.Size patternSize, @ByVal opencv_core.Mat corners)
@Namespace(value="cv") @Cast(value="bool") public static boolean find4QuadCornerSubpix(@ByVal opencv_core.Mat img, @ByVal opencv_core.Mat corners, @ByVal opencv_core.Size region_size)
@Namespace(value="cv") public static void drawChessboardCorners(@ByVal opencv_core.Mat image, @ByVal opencv_core.Size patternSize, @ByVal opencv_core.Mat corners, @Cast(value="bool") boolean patternWasFound)
image - Destination image. It must be an 8-bit color image.patternSize - Number of inner corners per a chessboard row and column
(patternSize = cv::Size(points_per_row,points_per_column)).corners - Array of detected corners, the output of findChessboardCorners.patternWasFound - Parameter indicating whether the complete board was found or not. The
return value of findChessboardCorners should be passed here.
The function draws individual chessboard corners detected either as red circles if the board was not found, or as colored corners connected with lines if the board was found.
@Namespace(value="cv") @Cast(value="bool") public static boolean findCirclesGrid(@ByVal opencv_core.Mat image, @ByVal opencv_core.Size patternSize, @ByVal opencv_core.Mat centers, int flags, @Cast(value="cv::FeatureDetector*")@opencv_core.Ptr opencv_features2d.Feature2D blobDetector)
image - grid view of input circles; it must be an 8-bit grayscale or color image.patternSize - number of circles per row and column
( patternSize = Size(points_per_row, points_per_colum) ).centers - output array of detected centers.flags - various operation flags that can be one of the following values:
- **CALIB_CB_SYMMETRIC_GRID** uses symmetric pattern of circles.
- **CALIB_CB_ASYMMETRIC_GRID** uses asymmetric pattern of circles.
- **CALIB_CB_CLUSTERING** uses a special algorithm for grid detection. It is more robust to
perspective distortions but much more sensitive to background clutter.blobDetector - feature detector that finds blobs like dark circles on light background.
The function attempts to determine whether the input image contains a grid of circles. If it is, the function locates centers of the circles. The function returns a non-zero value if all of the centers have been found and they have been placed in a certain order (row by row, left to right in every row). Otherwise, if the function fails to find all the corners or reorder them, it returns 0.
Sample usage of detecting and drawing the centers of circles: :
Size patternsize(7,7); //number of centers
Mat gray = ....; //source image
vector<Point2f> centers; //this will be filled by the detected centers
bool patternfound = findCirclesGrid(gray, patternsize, centers);
drawChessboardCorners(img, patternsize, Mat(centers), patternfound);
@Namespace(value="cv") @Cast(value="bool") public static boolean findCirclesGrid(@ByVal opencv_core.Mat image, @ByVal opencv_core.Size patternSize, @ByVal opencv_core.Mat centers)
@Namespace(value="cv") public static double calibrateCamera(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.MatVector rvecs, @ByVal opencv_core.MatVector tvecs, int flags, @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)") opencv_core.TermCriteria criteria)
objectPoints - In the new interface it is a vector of vectors of calibration pattern points in
the calibration pattern coordinate space (e.g. std::vectorimagePoints - In the new interface it is a vector of vectors of the projections of calibration
pattern points (e.g. std::vectorimageSize - Size of the image used only to initialize the intrinsic camera matrix.cameraMatrix - Output 3x3 floating-point camera matrix
\f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV\_CALIB\_USE\_INTRINSIC\_GUESS
and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be
initialized before calling the function.distCoeffs - Output vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements.rvecs - Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view
(e.g. std::vectortvecs - Output vector of translation vectors estimated for each pattern view.flags - Different flags that may be zero or a combination of the following values:
- **CV_CALIB_USE_INTRINSIC_GUESS** cameraMatrix contains valid initial values of
fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
center ( imageSize is used), and focal distances are computed in a least-squares fashion.
Note, that if intrinsic parameters are known, there is no need to use this function just to
estimate extrinsic parameters. Use solvePnP instead.
- **CV_CALIB_FIX_PRINCIPAL_POINT** The principal point is not changed during the global
optimization. It stays at the center or at a different location specified when
CV_CALIB_USE_INTRINSIC_GUESS is set too.
- **CV_CALIB_FIX_ASPECT_RATIO** The functions considers only fy as a free parameter. The
ratio fx/fy stays the same as in the input cameraMatrix . When
CV_CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are
ignored, only their ratio is computed and used further.
- **CV_CALIB_ZERO_TANGENT_DIST** Tangential distortion coefficients \f$(p_1, p_2)\f$ are set
to zeros and stay zero.
- **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** The corresponding radial distortion
coefficient is not changed during the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is
set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
- **CV_CALIB_RATIONAL_MODEL** Coefficients k4, k5, and k6 are enabled. To provide the
backward compatibility, this extra flag should be explicitly specified to make the
calibration function use the rational model and return 8 coefficients. If the flag is not
set, the function computes and returns only 5 distortion coefficients.
- **CALIB_THIN_PRISM_MODEL** Coefficients s1, s2, s3 and s4 are enabled. To provide the
backward compatibility, this extra flag should be explicitly specified to make the
calibration function use the thin prism model and return 12 coefficients. If the flag is not
set, the function computes and returns only 5 distortion coefficients.
- **CALIB_FIX_S1_S2_S3_S4** The thin prism distortion coefficients are not changed during
the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
supplied distCoeffs matrix is used. Otherwise, it is set to 0.
- **CALIB_TILTED_MODEL** Coefficients tauX and tauY are enabled. To provide the
backward compatibility, this extra flag should be explicitly specified to make the
calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
set, the function computes and returns only 5 distortion coefficients.
- **CALIB_FIX_TAUX_TAUY** The coefficients of the tilted sensor model are not changed during
the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
supplied distCoeffs matrix is used. Otherwise, it is set to 0.criteria - Termination criteria for the iterative optimization algorithm.
The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on \cite Zhang2000 and \cite BouguetMCT . The coordinates of 3D object points and their corresponding 2D projections in each view must be specified. That may be achieved by using an object with a known geometry and easily detectable feature points. Such an object is called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as a calibration rig (see findChessboardCorners ). Currently, initialization of intrinsic parameters (when CV_CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also be used as long as initial cameraMatrix is provided.
The algorithm performs the following steps:
- Compute the initial intrinsic parameters (the option only available for planar calibration patterns) or read them from the input parameters. The distortion coefficients are all set to zeros initially unless some of CV_CALIB_FIX_K? are specified.
- Estimate the initial camera pose as if the intrinsic parameters have been already known. This is done using solvePnP .
- Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error, that is, the total sum of squared distances between the observed feature points imagePoints and the projected (using the current estimates for camera parameters and the poses) object points objectPoints. See projectPoints for details.
The function returns the final re-projection error.
\note If you use a non-square (=non-NxN) grid and findChessboardCorners for calibration, and calibrateCamera returns bad values (zero distortion coefficients, an image center very far from (w/2-0.5,h/2-0.5), and/or large differences between \f$f_x\f$ and \f$f_y\f$ (ratios of 10:1 or more)), then you have probably used patternSize=cvSize(rows,cols) instead of using patternSize=cvSize(cols,rows) in findChessboardCorners .
\sa findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
@Namespace(value="cv") public static double calibrateCamera(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.MatVector rvecs, @ByVal opencv_core.MatVector tvecs)
@Namespace(value="cv") public static void calibrationMatrixValues(@ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Size imageSize, double apertureWidth, double apertureHeight, @ByRef DoublePointer fovx, @ByRef DoublePointer fovy, @ByRef DoublePointer focalLength, @ByRef opencv_core.Point2d principalPoint, @ByRef DoublePointer aspectRatio)
cameraMatrix - Input camera matrix that can be estimated by calibrateCamera or
stereoCalibrate .imageSize - Input image size in pixels.apertureWidth - Physical width in mm of the sensor.apertureHeight - Physical height in mm of the sensor.fovx - Output field of view in degrees along the horizontal sensor axis.fovy - Output field of view in degrees along the vertical sensor axis.focalLength - Focal length of the lens in mm.principalPoint - Principal point in mm.aspectRatio - \f$f_y/f_x\f$
The function computes various useful camera characteristics from the previously estimated camera matrix.
\note Do keep in mind that the unity measure 'mm' stands for whatever unit of measure one chooses for the chessboard pitch (it can thus be any value).
@Namespace(value="cv") public static void calibrationMatrixValues(@ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Size imageSize, double apertureWidth, double apertureHeight, @ByRef DoubleBuffer fovx, @ByRef DoubleBuffer fovy, @ByRef DoubleBuffer focalLength, @ByRef opencv_core.Point2d principalPoint, @ByRef DoubleBuffer aspectRatio)
@Namespace(value="cv") public static void calibrationMatrixValues(@ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Size imageSize, double apertureWidth, double apertureHeight, @ByRef double[] fovx, @ByRef double[] fovy, @ByRef double[] focalLength, @ByRef opencv_core.Point2d principalPoint, @ByRef double[] aspectRatio)
@Namespace(value="cv") public static double stereoCalibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints1, @ByVal opencv_core.MatVector imagePoints2, @ByVal opencv_core.Mat cameraMatrix1, @ByVal opencv_core.Mat distCoeffs1, @ByVal opencv_core.Mat cameraMatrix2, @ByVal opencv_core.Mat distCoeffs2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T, @ByVal opencv_core.Mat E, @ByVal opencv_core.Mat F, int flags, @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS, 30, 1e-6)") opencv_core.TermCriteria criteria)
objectPoints - Vector of vectors of the calibration pattern points.imagePoints1 - Vector of vectors of the projections of the calibration pattern points,
observed by the first camera.imagePoints2 - Vector of vectors of the projections of the calibration pattern points,
observed by the second camera.cameraMatrix1 - Input/output first camera matrix:
\f$\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\f$ , \f$j = 0,\, 1\f$ . If
any of CV_CALIB_USE_INTRINSIC_GUESS , CV_CALIB_FIX_ASPECT_RATIO ,
CV_CALIB_FIX_INTRINSIC , or CV_CALIB_FIX_FOCAL_LENGTH are specified, some or all of the
matrix components must be initialized. See the flags description for details.distCoeffs1 - Input/output vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements. The output vector length depends on the flags.cameraMatrix2 - Input/output second camera matrix. The parameter is similar to cameraMatrix1distCoeffs2 - Input/output lens distortion coefficients for the second camera. The parameter
is similar to distCoeffs1 .imageSize - Size of the image used only to initialize intrinsic camera matrix.R - Output rotation matrix between the 1st and the 2nd camera coordinate systems.T - Output translation vector between the coordinate systems of the cameras.E - Output essential matrix.F - Output fundamental matrix.flags - Different flags that may be zero or a combination of the following values:
- **CV_CALIB_FIX_INTRINSIC** Fix cameraMatrix? and distCoeffs? so that only R, T, E , and F
matrices are estimated.
- **CV_CALIB_USE_INTRINSIC_GUESS** Optimize some or all of the intrinsic parameters
according to the specified flags. Initial values are provided by the user.
- **CV_CALIB_FIX_PRINCIPAL_POINT** Fix the principal points during the optimization.
- **CV_CALIB_FIX_FOCAL_LENGTH** Fix \f$f^{(j)}_x\f$ and \f$f^{(j)}_y\f$ .
- **CV_CALIB_FIX_ASPECT_RATIO** Optimize \f$f^{(j)}_y\f$ . Fix the ratio \f$f^{(j)}_x/f^{(j)}_y\f$
.
- **CV_CALIB_SAME_FOCAL_LENGTH** Enforce \f$f^{(0)}_x=f^{(1)}_x\f$ and \f$f^{(0)}_y=f^{(1)}_y\f$ .
- **CV_CALIB_ZERO_TANGENT_DIST** Set tangential distortion coefficients for each camera to
zeros and fix there.
- **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** Do not change the corresponding radial
distortion coefficient during the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set,
the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
- **CV_CALIB_RATIONAL_MODEL** Enable coefficients k4, k5, and k6. To provide the backward
compatibility, this extra flag should be explicitly specified to make the calibration
function use the rational model and return 8 coefficients. If the flag is not set, the
function computes and returns only 5 distortion coefficients.
- **CALIB_THIN_PRISM_MODEL** Coefficients s1, s2, s3 and s4 are enabled. To provide the
backward compatibility, this extra flag should be explicitly specified to make the
calibration function use the thin prism model and return 12 coefficients. If the flag is not
set, the function computes and returns only 5 distortion coefficients.
- **CALIB_FIX_S1_S2_S3_S4** The thin prism distortion coefficients are not changed during
the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
supplied distCoeffs matrix is used. Otherwise, it is set to 0.
- **CALIB_TILTED_MODEL** Coefficients tauX and tauY are enabled. To provide the
backward compatibility, this extra flag should be explicitly specified to make the
calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
set, the function computes and returns only 5 distortion coefficients.
- **CALIB_FIX_TAUX_TAUY** The coefficients of the tilted sensor model are not changed during
the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
supplied distCoeffs matrix is used. Otherwise, it is set to 0.criteria - Termination criteria for the iterative optimization algorithm.
The function estimates transformation between two cameras making a stereo pair. If you have a stereo camera where the relative position and orientation of two cameras is fixed, and if you computed poses of an object relative to the first camera and to the second camera, (R1, T1) and (R2, T2), respectively (this can be done with solvePnP ), then those poses definitely relate to each other. This means that, given ( \f$R_1\f$,\f$T_1\f$ ), it should be possible to compute ( \f$R_2\f$,\f$T_2\f$ ). You only need to know the position and orientation of the second camera relative to the first camera. This is what the described function does. It computes ( \f$R\f$,\f$T\f$ ) so that:
\f[R_2=R*R_1 T_2=R*T_1 + T,\f]
Optionally, it computes the essential matrix E:
\f[E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} *R\f]
where \f$T_i\f$ are components of the translation vector \f$T\f$ : \f$T=[T_0, T_1, T_2]^T\f$ . And the function can also compute the fundamental matrix F:
\f[F = cameraMatrix2^{-T} E cameraMatrix1^{-1}\f]
Besides the stereo-related information, the function can also perform a full calibration of each of two cameras. However, due to the high dimensionality of the parameter space and noise in the input data, the function can diverge from the correct solution. If the intrinsic parameters can be estimated with high accuracy for each of the cameras individually (for example, using calibrateCamera ), you are recommended to do so and then pass CV_CALIB_FIX_INTRINSIC flag to the function along with the computed intrinsic parameters. Otherwise, if all the parameters are estimated at once, it makes sense to restrict some parameters, for example, pass CV_CALIB_SAME_FOCAL_LENGTH and CV_CALIB_ZERO_TANGENT_DIST flags, which is usually a reasonable assumption.
Similarly to calibrateCamera , the function minimizes the total re-projection error for all the points in all the available views from both cameras. The function returns the final value of the re-projection error.
@Namespace(value="cv") public static double stereoCalibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints1, @ByVal opencv_core.MatVector imagePoints2, @ByVal opencv_core.Mat cameraMatrix1, @ByVal opencv_core.Mat distCoeffs1, @ByVal opencv_core.Mat cameraMatrix2, @ByVal opencv_core.Mat distCoeffs2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T, @ByVal opencv_core.Mat E, @ByVal opencv_core.Mat F)
@Namespace(value="cv") public static void stereoRectify(@ByVal opencv_core.Mat cameraMatrix1, @ByVal opencv_core.Mat distCoeffs1, @ByVal opencv_core.Mat cameraMatrix2, @ByVal opencv_core.Mat distCoeffs2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat P1, @ByVal opencv_core.Mat P2, @ByVal opencv_core.Mat Q, int flags, double alpha, @ByVal(nullValue="cv::Size()") opencv_core.Size newImageSize, opencv_core.Rect validPixROI1, opencv_core.Rect validPixROI2)
cameraMatrix1 - First camera matrix.distCoeffs1 - First camera distortion parameters.cameraMatrix2 - Second camera matrix.distCoeffs2 - Second camera distortion parameters.imageSize - Size of the image used for stereo calibration.R - Rotation matrix between the coordinate systems of the first and the second cameras.T - Translation vector between coordinate systems of the cameras.R1 - Output 3x3 rectification transform (rotation matrix) for the first camera.R2 - Output 3x3 rectification transform (rotation matrix) for the second camera.P1 - Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
camera.P2 - Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
camera.Q - Output \f$4 \times 4\f$ disparity-to-depth mapping matrix (see reprojectImageTo3D ).flags - Operation flags that may be zero or CV_CALIB_ZERO_DISPARITY . If the flag is set,
the function makes the principal points of each camera have the same pixel coordinates in the
rectified views. And if the flag is not set, the function may still shift the images in the
horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
useful image area.alpha - Free scaling parameter. If it is -1 or absent, the function performs the default
scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
images are zoomed and shifted so that only valid pixels are visible (no black areas after
rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
pixels from the original images from the cameras are retained in the rectified images (no source
image pixels are lost). Obviously, any intermediate value yields an intermediate result between
those two extreme cases.newImageSize - New image resolution after rectification. The same size should be passed to
initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
is passed (default), it is set to the original imageSize . Setting it to larger value can help you
preserve details in the original image, especially when there is a big radial distortion.validPixROI1 - Optional output rectangles inside the rectified images where all the pixels
are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
(see the picture below).validPixROI2 - Optional output rectangles inside the rectified images where all the pixels
are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
(see the picture below).
The function computes the rotation matrices for each camera that (virtually) make both camera image planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies the dense stereo correspondence problem. The function takes the matrices computed by stereoCalibrate as input. As output, it provides two rotation matrices and also two projection matrices in the new coordinates. The function distinguishes the following two cases:
- **Horizontal stereo**: the first and the second camera views are shifted relative to each other mainly along the x axis (with possible small vertical shift). In the rectified images, the corresponding epipolar lines in the left and right cameras are horizontal and have the same y-coordinate. P1 and P2 look like:
\f[\texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\f]
\f[\texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x*f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\f]
where \f$T_x\f$ is a horizontal shift between the cameras and \f$cx_1=cx_2\f$ if CV_CALIB_ZERO_DISPARITY is set.
- **Vertical stereo**: the first and the second camera views are shifted relative to each other mainly in vertical direction (and probably a bit in the horizontal direction too). The epipolar lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
\f[\texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}\f]
\f[\texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y*f \\ 0 & 0 & 1 & 0 \end{bmatrix} ,\f]
where \f$T_y\f$ is a vertical shift between the cameras and \f$cy_1=cy_2\f$ if CALIB_ZERO_DISPARITY is set.
As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera matrices. The matrices, together with R1 and R2 , can then be passed to initUndistortRectifyMap to initialize the rectification map for each camera.
See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through the corresponding image regions. This means that the images are well rectified, which is what most stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that their interiors are all valid pixels.
@Namespace(value="cv") public static void stereoRectify(@ByVal opencv_core.Mat cameraMatrix1, @ByVal opencv_core.Mat distCoeffs1, @ByVal opencv_core.Mat cameraMatrix2, @ByVal opencv_core.Mat distCoeffs2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat P1, @ByVal opencv_core.Mat P2, @ByVal opencv_core.Mat Q)
@Namespace(value="cv") @Cast(value="bool") public static boolean stereoRectifyUncalibrated(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat F, @ByVal opencv_core.Size imgSize, @ByVal opencv_core.Mat H1, @ByVal opencv_core.Mat H2, double threshold)
points1 - Array of feature points in the first image.points2 - The corresponding points in the second image. The same formats as in
findFundamentalMat are supported.F - Input fundamental matrix. It can be computed from the same set of point pairs using
findFundamentalMat .imgSize - Size of the image.H1 - Output rectification homography matrix for the first image.H2 - Output rectification homography matrix for the second image.threshold - Optional threshold used to filter out the outliers. If the parameter is greater
than zero, all the point pairs that do not comply with the epipolar geometry (that is, the points
for which \f$|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}\f$ ) are
rejected prior to computing the homographies. Otherwise,all the points are considered inliers.
The function computes the rectification transformations without knowing intrinsic parameters of the cameras and their relative position in the space, which explains the suffix "uncalibrated". Another related difference from stereoRectify is that the function outputs not the rectification transformations in the object (3D) space, but the planar perspective transformations encoded by the homography matrices H1 and H2 . The function implements the algorithm \cite Hartley99 .
\note While the algorithm does not need to know the intrinsic parameters of the cameras, it heavily depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion, it would be better to correct it before computing the fundamental matrix and calling this function. For example, distortion coefficients can be estimated for each head of stereo camera separately by using calibrateCamera . Then, the images can be corrected using undistort , or just the point coordinates can be corrected with undistortPoints .
@Namespace(value="cv") @Cast(value="bool") public static boolean stereoRectifyUncalibrated(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat F, @ByVal opencv_core.Size imgSize, @ByVal opencv_core.Mat H1, @ByVal opencv_core.Mat H2)
@Namespace(value="cv") public static float rectify3Collinear(@ByVal opencv_core.Mat cameraMatrix1, @ByVal opencv_core.Mat distCoeffs1, @ByVal opencv_core.Mat cameraMatrix2, @ByVal opencv_core.Mat distCoeffs2, @ByVal opencv_core.Mat cameraMatrix3, @ByVal opencv_core.Mat distCoeffs3, @ByVal opencv_core.MatVector imgpt1, @ByVal opencv_core.MatVector imgpt3, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R12, @ByVal opencv_core.Mat T12, @ByVal opencv_core.Mat R13, @ByVal opencv_core.Mat T13, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat R3, @ByVal opencv_core.Mat P1, @ByVal opencv_core.Mat P2, @ByVal opencv_core.Mat P3, @ByVal opencv_core.Mat Q, double alpha, @ByVal opencv_core.Size newImgSize, opencv_core.Rect roi1, opencv_core.Rect roi2, int flags)
@Namespace(value="cv") @ByVal public static opencv_core.Mat getOptimalNewCameraMatrix(@ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Size imageSize, double alpha, @ByVal(nullValue="cv::Size()") opencv_core.Size newImgSize, opencv_core.Rect validPixROI, @Cast(value="bool") boolean centerPrincipalPoint)
cameraMatrix - Input camera matrix.distCoeffs - Input vector of distortion coefficients
\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6 [, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of
4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are
assumed.imageSize - Original image size.alpha - Free scaling parameter between 0 (when all the pixels in the undistorted image are
valid) and 1 (when all the source image pixels are retained in the undistorted image). See
stereoRectify for details.newImgSize - Image size after rectification. By default,it is set to imageSize .validPixROI - Optional output rectangle that outlines all-good-pixels region in the
undistorted image. See roi1, roi2 description in stereoRectify .centerPrincipalPoint - Optional flag that indicates whether in the new camera matrix the
principal point should be at the image center or not. By default, the principal point is chosen to
best fit a subset of the source image (determined by alpha) to the corrected image.The function computes and returns the optimal new camera matrix based on the free scaling parameter. By varying this parameter, you may retrieve only sensible pixels alpha=0 , keep all the original image pixels if there is valuable information in the corners alpha=1 , or get something in between. When alpha\>0 , the undistortion result is likely to have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera matrix, distortion coefficients, the computed new camera matrix, and newImageSize should be passed to initUndistortRectifyMap to produce the maps for remap .
@Namespace(value="cv") @ByVal public static opencv_core.Mat getOptimalNewCameraMatrix(@ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat distCoeffs, @ByVal opencv_core.Size imageSize, double alpha)
@Namespace(value="cv") public static void convertPointsToHomogeneous(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst)
src - Input vector of N-dimensional points.dst - Output vector of N+1-dimensional points.
The function converts points from Euclidean to homogeneous space by appending 1's to the tuple of point coordinates. That is, each point (x1, x2, ..., xn) is converted to (x1, x2, ..., xn, 1).
@Namespace(value="cv") public static void convertPointsFromHomogeneous(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst)
src - Input vector of N-dimensional points.dst - Output vector of N-1-dimensional points.
The function converts points homogeneous to Euclidean space using perspective projection. That is, each point (x1, x2, ... x(n-1), xn) is converted to (x1/xn, x2/xn, ..., x(n-1)/xn). When xn=0, the output point coordinates will be (0,0,0,...).
@Namespace(value="cv") public static void convertPointsHomogeneous(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst)
src - Input array or vector of 2D, 3D, or 4D points.dst - Output vector of 2D, 3D, or 4D points.
The function converts 2D or 3D points from/to homogeneous coordinates by calling either convertPointsToHomogeneous or convertPointsFromHomogeneous.
\note The function is obsolete. Use one of the previous two functions instead.
@Namespace(value="cv") @ByVal public static opencv_core.Mat findFundamentalMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, int method, double param1, double param2, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask)
points1 - Array of N points from the first image. The point coordinates should be
floating-point (single or double precision).points2 - Array of the second image points of the same size and format as points1 .method - Method for computing a fundamental matrix.
- **CV_FM_7POINT** for a 7-point algorithm. \f$N = 7\f$
- **CV_FM_8POINT** for an 8-point algorithm. \f$N \ge 8\f$
- **CV_FM_RANSAC** for the RANSAC algorithm. \f$N \ge 8\f$
- **CV_FM_LMEDS** for the LMedS algorithm. \f$N \ge 8\f$param1 - Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
line in pixels, beyond which the point is considered an outlier and is not used for computing the
final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
point localization, image resolution, and the image noise.param2 - Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level
of confidence (probability) that the estimated matrix is correct.mask - The epipolar geometry is described by the following equation:
\f[[p_2; 1]^T F [p_1; 1] = 0\f]
where \f$F\f$ is a fundamental matrix, \f$p_1\f$ and \f$p_2\f$ are corresponding points in the first and the second images, respectively.
The function calculates the fundamental matrix using one of four methods listed above and returns the found fundamental matrix. Normally just one matrix is found. But in case of the 7-point algorithm, the function may return up to 3 solutions ( \f$9 \times 3\f$ matrix that stores all 3 matrices sequentially).
The calculated fundamental matrix may be passed further to computeCorrespondEpilines that finds the epipolar lines corresponding to the specified points. It can also be passed to stereoRectifyUncalibrated to compute the rectification transformation. :
// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
Mat fundamental_matrix =
findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
@Namespace(value="cv") @ByVal public static opencv_core.Mat findFundamentalMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findFundamentalMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat mask, int method, double param1, double param2)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findFundamentalMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat mask)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findEssentialMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat cameraMatrix, int method, double prob, double threshold, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask)
points1 - Array of N (N \>= 5) 2D points from the first image. The point coordinates should
be floating-point (single or double precision).points2 - Array of the second image points of the same size and format as points1 .cameraMatrix - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ .
Note that this function assumes that points1 and points2 are feature points from cameras with the
same camera matrix.method - Method for computing a fundamental matrix.
- **RANSAC** for the RANSAC algorithm.
- **MEDS** for the LMedS algorithm.threshold - Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
line in pixels, beyond which the point is considered an outlier and is not used for computing the
final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
point localization, image resolution, and the image noise.prob - Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
confidence (probability) that the estimated matrix is correct.mask - Output array of N elements, every element of which is set to 0 for outliers and to 1
for the other points. The array is computed only in the RANSAC and LMedS methods.
This function estimates essential matrix based on the five-point algorithm solver in \cite Nister03 . \cite SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
\f[[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0\f]
where \f$E\f$ is an essential matrix, \f$p_1\f$ and \f$p_2\f$ are corresponding points in the first and the second images, respectively. The result of this function may be passed further to decomposeEssentialMat or recoverPose to recover the relative pose between cameras.
@Namespace(value="cv") @ByVal public static opencv_core.Mat findEssentialMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat cameraMatrix)
@Namespace(value="cv") @ByVal public static opencv_core.Mat findEssentialMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, double focal, @ByVal(nullValue="cv::Point2d(0, 0)") opencv_core.Point2d pp, int method, double prob, double threshold, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask)
points1 - Array of N (N \>= 5) 2D points from the first image. The point coordinates should
be floating-point (single or double precision).points2 - Array of the second image points of the same size and format as points1 .focal - focal length of the camera. Note that this function assumes that points1 and points2
are feature points from cameras with same focal length and principle point.pp - principle point of the camera.method - Method for computing a fundamental matrix.
- **RANSAC** for the RANSAC algorithm.
- **LMEDS** for the LMedS algorithm.threshold - Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
line in pixels, beyond which the point is considered an outlier and is not used for computing the
final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
point localization, image resolution, and the image noise.prob - Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
confidence (probability) that the estimated matrix is correct.mask - Output array of N elements, every element of which is set to 0 for outliers and to 1
for the other points. The array is computed only in the RANSAC and LMedS methods.
This function differs from the one above that it computes camera matrix from focal length and principal point:
\f[K = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\f]
@Namespace(value="cv") @ByVal public static opencv_core.Mat findEssentialMat(@ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2)
@Namespace(value="cv") public static void decomposeEssentialMat(@ByVal opencv_core.Mat E, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat t)
E - The input essential matrix.R1 - One possible rotation matrix.R2 - Another possible rotation matrix.t - One possible translation.
This function decompose an essential matrix E using svd decomposition \cite HartleyZ00 . Generally 4 possible poses exists for a given E. They are \f$[R_1, t]\f$, \f$[R_1, -t]\f$, \f$[R_2, t]\f$, \f$[R_2, -t]\f$. By decomposing E, you can only get the direction of the translation, so the function returns unit t.
@Namespace(value="cv") public static int recoverPose(@ByVal opencv_core.Mat E, @ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat t, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask)
E - The input essential matrix.points1 - Array of N 2D points from the first image. The point coordinates should be
floating-point (single or double precision).points2 - Array of the second image points of the same size and format as points1 .cameraMatrix - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ .
Note that this function assumes that points1 and points2 are feature points from cameras with the
same camera matrix.R - Recovered relative rotation.t - Recoverd relative translation.mask - Input/output mask for inliers in points1 and points2.
: If it is not empty, then it marks inliers in points1 and points2 for then given essential
matrix E. Only these inliers will be used to recover pose. In the output mask only inliers
which pass the cheirality check.
This function decomposes an essential matrix using decomposeEssentialMat and then verifies possible
pose hypotheses by doing cheirality check. The cheirality check basically means that the
triangulated 3D points should have positive depth. Some details can be found in \cite Nister03 .
This function can be used to process output E and mask from findEssentialMat. In this scenario, points1 and points2 are the same input for findEssentialMat. :
// Example. Estimation of fundamental matrix using the RANSAC algorithm
int point_count = 100;
vector<Point2f> points1(point_count);
vector<Point2f> points2(point_count);
// initialize the points here ...
for( int i = 0; i < point_count; i++ )
{
points1[i] = ...;
points2[i] = ...;
}
// cametra matrix with both focal lengths = 1, and principal point = (0, 0)
Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
Mat E, R, t, mask;
E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask);
recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
@Namespace(value="cv") public static int recoverPose(@ByVal opencv_core.Mat E, @ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat cameraMatrix, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat t)
@Namespace(value="cv") public static int recoverPose(@ByVal opencv_core.Mat E, @ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat t, double focal, @ByVal(nullValue="cv::Point2d(0, 0)") opencv_core.Point2d pp, @ByVal(nullValue="cv::noArray()") opencv_core.Mat mask)
E - The input essential matrix.points1 - Array of N 2D points from the first image. The point coordinates should be
floating-point (single or double precision).points2 - Array of the second image points of the same size and format as points1 .R - Recovered relative rotation.t - Recoverd relative translation.focal - Focal length of the camera. Note that this function assumes that points1 and points2
are feature points from cameras with same focal length and principle point.pp - Principle point of the camera.mask - Input/output mask for inliers in points1 and points2.
: If it is not empty, then it marks inliers in points1 and points2 for then given essential
matrix E. Only these inliers will be used to recover pose. In the output mask only inliers
which pass the cheirality check.
This function differs from the one above that it computes camera matrix from focal length and principal point:
\f[K = \begin{bmatrix} f & 0 & x_{pp} \\ 0 & f & y_{pp} \\ 0 & 0 & 1 \end{bmatrix}\f]
@Namespace(value="cv") public static int recoverPose(@ByVal opencv_core.Mat E, @ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat t)
@Namespace(value="cv") public static void computeCorrespondEpilines(@ByVal opencv_core.Mat points, int whichImage, @ByVal opencv_core.Mat F, @ByVal opencv_core.Mat lines)
points - Input points. \f$N \times 1\f$ or \f$1 \times N\f$ matrix of type CV_32FC2 or
vector\whichImage - Index of the image (1 or 2) that contains the points .F - Fundamental matrix that can be estimated using findFundamentalMat or stereoRectify .lines - Output vector of the epipolar lines corresponding to the points in the other image.
Each line \f$ax + by + c=0\f$ is encoded by 3 numbers \f$(a, b, c)\f$ .
For every point in one of the two images of a stereo pair, the function finds the equation of the corresponding epipolar line in the other image.
From the fundamental matrix definition (see findFundamentalMat ), line \f$l^{(2)}_i\f$ in the second image for the point \f$p^{(1)}_i\f$ in the first image (when whichImage=1 ) is computed as:
\f[l^{(2)}_i = F p^{(1)}_i\f]
And vice versa, when whichImage=2, \f$l^{(1)}_i\f$ is computed from \f$p^{(2)}_i\f$ as:
\f[l^{(1)}_i = F^T p^{(2)}_i\f]
Line coefficients are defined up to a scale. They are normalized so that \f$a_i^2+b_i^2=1\f$ .
@Namespace(value="cv") public static void triangulatePoints(@ByVal opencv_core.Mat projMatr1, @ByVal opencv_core.Mat projMatr2, @ByVal opencv_core.Mat projPoints1, @ByVal opencv_core.Mat projPoints2, @ByVal opencv_core.Mat points4D)
projMatr1 - 3x4 projection matrix of the first camera.projMatr2 - 3x4 projection matrix of the second camera.projPoints1 - 2xN array of feature points in the first image. In case of c++ version it can
be also a vector of feature points or two-channel matrix of size 1xN or Nx1.projPoints2 - 2xN array of corresponding points in the second image. In case of c++ version
it can be also a vector of feature points or two-channel matrix of size 1xN or Nx1.points4D - 4xN array of reconstructed points in homogeneous coordinates.
The function reconstructs 3-dimensional points (in homogeneous coordinates) by using their observations with a stereo camera. Projections matrices can be obtained from stereoRectify.
\note Keep in mind that all input data should be of float type in order for this function to work.
\sa reprojectImageTo3D
@Namespace(value="cv") public static void correctMatches(@ByVal opencv_core.Mat F, @ByVal opencv_core.Mat points1, @ByVal opencv_core.Mat points2, @ByVal opencv_core.Mat newPoints1, @ByVal opencv_core.Mat newPoints2)
F - 3x3 fundamental matrix.points1 - 1xN array containing the first set of points.points2 - 1xN array containing the second set of points.newPoints1 - The optimized points1.newPoints2 - The optimized points2.
The function implements the Optimal Triangulation Method (see Multiple View Geometry for details). For each given point correspondence points1[i] \<-\> points2[i], and a fundamental matrix F, it computes the corrected correspondences newPoints1[i] \<-\> newPoints2[i] that minimize the geometric error \f$d(points1[i], newPoints1[i])^2 + d(points2[i],newPoints2[i])^2\f$ (where \f$d(a,b)\f$ is the geometric distance between points \f$a\f$ and \f$b\f$ ) subject to the epipolar constraint \f$newPoints2^T * F * newPoints1 = 0\f$ .
@Namespace(value="cv") public static void filterSpeckles(@ByVal opencv_core.Mat img, double newVal, int maxSpeckleSize, double maxDiff, @ByVal(nullValue="cv::noArray()") opencv_core.Mat buf)
img - The input 16-bit signed disparity imagenewVal - The disparity value used to paint-off the specklesmaxSpeckleSize - The maximum speckle size to consider it a speckle. Larger blobs are not
affected by the algorithmmaxDiff - Maximum difference between neighbor disparity pixels to put them into the same
blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point
disparity map, where disparity values are multiplied by 16, this scale factor should be taken into
account when specifying this parameter value.buf - The optional temporary buffer to avoid memory allocation within the function.@Namespace(value="cv") public static void filterSpeckles(@ByVal opencv_core.Mat img, double newVal, int maxSpeckleSize, double maxDiff)
@Namespace(value="cv") @ByVal public static opencv_core.Rect getValidDisparityROI(@ByVal opencv_core.Rect roi1, @ByVal opencv_core.Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
@Namespace(value="cv") public static void validateDisparity(@ByVal opencv_core.Mat disparity, @ByVal opencv_core.Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)
@Namespace(value="cv") public static void validateDisparity(@ByVal opencv_core.Mat disparity, @ByVal opencv_core.Mat cost, int minDisparity, int numberOfDisparities)
@Namespace(value="cv") public static void reprojectImageTo3D(@ByVal opencv_core.Mat disparity, @ByVal opencv_core.Mat _3dImage, @ByVal opencv_core.Mat Q, @Cast(value="bool") boolean handleMissingValues, int ddepth)
disparity - Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit
floating-point disparity image. If 16-bit signed format is used, the values are assumed to have no
fractional bits._3dImage - Output 3-channel floating-point image of the same size as disparity . Each
element of _3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity
map.Q - \f$4 \times 4\f$ perspective transformation matrix that can be obtained with stereoRectify.handleMissingValues - Indicates, whether the function should handle missing values (i.e.
points where the disparity was not computed). If handleMissingValues=true, then pixels with the
minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed
to 3D points with a very large Z value (currently set to 10000).ddepth - The optional output array depth. If it is -1, the output image will have CV_32F
depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.
The function transforms a single-channel disparity map to a 3-channel image representing a 3D surface. That is, for each pixel (x,y) andthe corresponding disparity d=disparity(x,y) , it computes:
\f[\begin{array}{l} [X \; Y \; Z \; W]^T = \texttt{Q} *[x \; y \; \texttt{disparity} (x,y) \; 1]^T \\ \texttt{\_3dImage} (x,y) = (X/W, \; Y/W, \; Z/W) \end{array}\f]
The matrix Q can be an arbitrary \f$4 \times 4\f$ matrix (for example, the one computed by stereoRectify). To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform .
@Namespace(value="cv") public static void reprojectImageTo3D(@ByVal opencv_core.Mat disparity, @ByVal opencv_core.Mat _3dImage, @ByVal opencv_core.Mat Q)
@Namespace(value="cv") public static double sampsonDistance(@ByVal opencv_core.Mat pt1, @ByVal opencv_core.Mat pt2, @ByVal opencv_core.Mat F)
The function sampsonDistance calculates and returns the first order approximation of the geometric error as: \f[sd( \texttt{pt1} , \texttt{pt2} )= \frac{(\texttt{pt2}^t \cdot \texttt{F} \cdot \texttt{pt1})^2}{(\texttt{F} \cdot \texttt{pt1})(0) + (\texttt{F} \cdot \texttt{pt1})(1) + (\texttt{F}^t \cdot \texttt{pt2})(0) + (\texttt{F}^t \cdot \texttt{pt2})(1)}\f] The fundamental matrix may be calculated using the cv::findFundamentalMat function. See HZ 11.4.3 for details.
pt1 - first homogeneous 2d pointpt2 - second homogeneous 2d pointF - fundamental matrix@Namespace(value="cv") public static int estimateAffine3D(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst, @ByVal opencv_core.Mat out, @ByVal opencv_core.Mat inliers, double ransacThreshold, double confidence)
src - First input 3D point set.dst - Second input 3D point set.out - Output 3D affine transformation matrix \f$3 \times 4\f$ .inliers - Output vector indicating which points are inliers.ransacThreshold - Maximum reprojection error in the RANSAC algorithm to consider a point as
an inlier.confidence - Confidence level, between 0 and 1, for the estimated transformation. Anything
between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
The function estimates an optimal 3D affine transformation between two 3D point sets using the RANSAC algorithm.
@Namespace(value="cv") public static int estimateAffine3D(@ByVal opencv_core.Mat src, @ByVal opencv_core.Mat dst, @ByVal opencv_core.Mat out, @ByVal opencv_core.Mat inliers)
@Namespace(value="cv") public static int decomposeHomographyMat(@ByVal opencv_core.Mat H, @ByVal opencv_core.Mat K, @ByVal opencv_core.MatVector rotations, @ByVal opencv_core.MatVector translations, @ByVal opencv_core.MatVector normals)
H - The input homography matrix between two images.K - The input intrinsic camera calibration matrix.rotations - Array of rotation matrices.translations - Array of translation matrices.normals - Array of plane normal matrices.
This function extracts relative camera motion between two views observing a planar object from the homography H induced by the plane. The intrinsic camera matrix K must also be provided. The function may return up to four mathematical solution sets. At least two of the solutions may further be invalidated if point correspondences are available by applying positive depth constraint (all points must be in front of the camera). The decomposition method is described in detail in \cite Malis .
@Namespace(value="cv::fisheye") public static void projectPoints(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @Const@ByRef opencv_core.Mat affine, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, double alpha, @ByVal(nullValue="cv::noArray()") opencv_core.Mat jacobian)
objectPoints - Array of object points, 1xN/Nx1 3-channel (or vector\imagePoints - Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or
vector\affine - K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.alpha - The skew coefficient.jacobian - Optional output 2Nx15 jacobian matrix of derivatives of image points with respect
to components of the focal lengths, coordinates of the principal point, distortion coefficients,
rotation vector, translation vector, and the skew. In the old interface different components of
the jacobian are returned via different output parameters.
The function computes projections of 3D points to the image plane given intrinsic and extrinsic camera parameters. Optionally, the function computes Jacobians - matrices of partial derivatives of image points coordinates (as functions of all the input parameters) with respect to the particular parameters, intrinsic and/or extrinsic.
@Namespace(value="cv::fisheye") public static void projectPoints(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @Const@ByRef opencv_core.Mat affine, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D)
@Namespace(value="cv::fisheye") public static void projectPoints(@ByVal opencv_core.Mat objectPoints, @ByVal opencv_core.Mat imagePoints, @ByVal opencv_core.Mat rvec, @ByVal opencv_core.Mat tvec, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, double alpha, @ByVal(nullValue="cv::noArray()") opencv_core.Mat jacobian)
@Namespace(value="cv::fisheye") public static void distortPoints(@ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, double alpha)
undistorted - Array of object points, 1xN/Nx1 2-channel (or vector\K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.alpha - The skew coefficient.distorted - Output array of image points, 1xN/Nx1 2-channel, or vector\@Namespace(value="cv::fisheye") public static void distortPoints(@ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D)
@Namespace(value="cv::fisheye") public static void undistortPoints(@ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @ByVal(nullValue="cv::noArray()") opencv_core.Mat R, @ByVal(nullValue="cv::noArray()") opencv_core.Mat P)
distorted - Array of object points, 1xN/Nx1 2-channel (or vector\K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.R - Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
1-channel or 1x1 3-channelP - New camera matrix (3x3) or new projection matrix (3x4)undistorted - Output array of image points, 1xN/Nx1 2-channel, or vector\@Namespace(value="cv::fisheye") public static void undistortPoints(@ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D)
@Namespace(value="cv::fisheye") public static void initUndistortRectifyMap(@ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat P, @Const@ByRef opencv_core.Size size, int m1type, @ByVal opencv_core.Mat map1, @ByVal opencv_core.Mat map2)
K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.R - Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
1-channel or 1x1 3-channelP - New camera matrix (3x3) or new projection matrix (3x4)size - Undistorted image size.m1type - Type of the first output map that can be CV_32FC1 or CV_16SC2 . See convertMaps()
for details.map1 - The first output map.map2 - The second output map.@Namespace(value="cv::fisheye") public static void undistortImage(@ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @ByVal(nullValue="cv::noArray()") opencv_core.Mat Knew, @Const@ByRef(nullValue="cv::Size()") opencv_core.Size new_size)
distorted - image with fisheye lens distortion.undistorted - Output image with compensated fisheye lens distortion.K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.Knew - Camera matrix of the distorted image. By default, it is the identity matrix but you
may additionally scale and shift the result by using a different matrix.new_size - The function transforms an image to compensate radial and tangential lens distortion.
The function is simply a combination of fisheye::initUndistortRectifyMap (with unity R ) and remap (with bilinear interpolation). See the former function for details of the transformation being performed.
See below the results of undistortImage. - a\) result of undistort of perspective camera model (all possible coefficients (k_1, k_2, k_3, k_4, k_5, k_6) of distortion were optimized under calibration) - b\) result of fisheye::undistortImage of fisheye camera model (all possible coefficients (k_1, k_2, k_3, k_4) of fisheye distortion were optimized under calibration) - c\) original image was captured with fisheye lens
Pictures a) and b) almost the same. But if we consider points of image located far from the center of image, we can notice that on image a) these points are distorted.
@Namespace(value="cv::fisheye") public static void undistortImage(@ByVal opencv_core.Mat distorted, @ByVal opencv_core.Mat undistorted, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D)
@Namespace(value="cv::fisheye") public static void estimateNewCameraMatrixForUndistortRectify(@ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @Const@ByRef opencv_core.Size image_size, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat P, double balance, @Const@ByRef(nullValue="cv::Size()") opencv_core.Size new_size, double fov_scale)
K - Camera matrix \f$K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}\f$.image_size - D - Input vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.R - Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
1-channel or 1x1 3-channelP - New camera matrix (3x3) or new projection matrix (3x4)balance - Sets the new focal length in range between the min focal length and the max focal
length. Balance is in range of [0, 1].new_size - fov_scale - Divisor for new focal length.@Namespace(value="cv::fisheye") public static void estimateNewCameraMatrixForUndistortRectify(@ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @Const@ByRef opencv_core.Size image_size, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat P)
@Namespace(value="cv::fisheye") public static double calibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @Const@ByRef opencv_core.Size image_size, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @ByVal opencv_core.MatVector rvecs, @ByVal opencv_core.MatVector tvecs, int flags, @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 100, DBL_EPSILON)") opencv_core.TermCriteria criteria)
objectPoints - vector of vectors of calibration pattern points in the calibration pattern
coordinate space.imagePoints - vector of vectors of the projections of calibration pattern points.
imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to
objectPoints[i].size() for each i.image_size - Size of the image used only to initialize the intrinsic camera matrix.K - Output 3x3 floating-point camera matrix
\f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If
fisheye::CALIB_USE_INTRINSIC_GUESS/ is specified, some or all of fx, fy, cx, cy must be
initialized before calling the function.D - Output vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$.rvecs - Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view.
That is, each k-th rotation vector together with the corresponding k-th translation vector (see
the next output parameter description) brings the calibration pattern from the model coordinate
space (in which object points are specified) to the world coordinate space, that is, a real
position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).tvecs - Output vector of translation vectors estimated for each pattern view.flags - Different flags that may be zero or a combination of the following values:
- **fisheye::CALIB_USE_INTRINSIC_GUESS** cameraMatrix contains valid initial values of
fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
center ( imageSize is used), and focal distances are computed in a least-squares fashion.
- **fisheye::CALIB_RECOMPUTE_EXTRINSIC** Extrinsic will be recomputed after each iteration
of intrinsic optimization.
- **fisheye::CALIB_CHECK_COND** The functions will check validity of condition number.
- **fisheye::CALIB_FIX_SKEW** Skew coefficient (alpha) is set to zero and stay zero.
- **fisheye::CALIB_FIX_K1..4** Selected distortion coefficients are set to zeros and stay
zero.criteria - Termination criteria for the iterative optimization algorithm.@Namespace(value="cv::fisheye") public static double calibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints, @Const@ByRef opencv_core.Size image_size, @ByVal opencv_core.Mat K, @ByVal opencv_core.Mat D, @ByVal opencv_core.MatVector rvecs, @ByVal opencv_core.MatVector tvecs)
@Namespace(value="cv::fisheye") public static void stereoRectify(@ByVal opencv_core.Mat K1, @ByVal opencv_core.Mat D1, @ByVal opencv_core.Mat K2, @ByVal opencv_core.Mat D2, @Const@ByRef opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat tvec, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat P1, @ByVal opencv_core.Mat P2, @ByVal opencv_core.Mat Q, int flags, @Const@ByRef(nullValue="cv::Size()") opencv_core.Size newImageSize, double balance, double fov_scale)
K1 - First camera matrix.D1 - First camera distortion parameters.K2 - Second camera matrix.D2 - Second camera distortion parameters.imageSize - Size of the image used for stereo calibration.R - Rotation matrix between the coordinate systems of the first and the second
cameras.tvec - Translation vector between coordinate systems of the cameras.R1 - Output 3x3 rectification transform (rotation matrix) for the first camera.R2 - Output 3x3 rectification transform (rotation matrix) for the second camera.P1 - Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
camera.P2 - Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
camera.Q - Output \f$4 \times 4\f$ disparity-to-depth mapping matrix (see reprojectImageTo3D ).flags - Operation flags that may be zero or CV_CALIB_ZERO_DISPARITY . If the flag is set,
the function makes the principal points of each camera have the same pixel coordinates in the
rectified views. And if the flag is not set, the function may still shift the images in the
horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
useful image area.newImageSize - New image resolution after rectification. The same size should be passed to
initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
is passed (default), it is set to the original imageSize . Setting it to larger value can help you
preserve details in the original image, especially when there is a big radial distortion.balance - Sets the new focal length in range between the min focal length and the max focal
length. Balance is in range of [0, 1].fov_scale - Divisor for new focal length.@Namespace(value="cv::fisheye") public static void stereoRectify(@ByVal opencv_core.Mat K1, @ByVal opencv_core.Mat D1, @ByVal opencv_core.Mat K2, @ByVal opencv_core.Mat D2, @Const@ByRef opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat tvec, @ByVal opencv_core.Mat R1, @ByVal opencv_core.Mat R2, @ByVal opencv_core.Mat P1, @ByVal opencv_core.Mat P2, @ByVal opencv_core.Mat Q, int flags)
@Namespace(value="cv::fisheye") public static double stereoCalibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints1, @ByVal opencv_core.MatVector imagePoints2, @ByVal opencv_core.Mat K1, @ByVal opencv_core.Mat D1, @ByVal opencv_core.Mat K2, @ByVal opencv_core.Mat D2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T, int flags, @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 100, DBL_EPSILON)") opencv_core.TermCriteria criteria)
objectPoints - Vector of vectors of the calibration pattern points.imagePoints1 - Vector of vectors of the projections of the calibration pattern points,
observed by the first camera.imagePoints2 - Vector of vectors of the projections of the calibration pattern points,
observed by the second camera.K1 - Input/output first camera matrix:
\f$\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\f$ , \f$j = 0,\, 1\f$ . If
any of fisheye::CALIB_USE_INTRINSIC_GUESS , fisheye::CV_CALIB_FIX_INTRINSIC are specified,
some or all of the matrix components must be initialized.D1 - Input/output vector of distortion coefficients \f$(k_1, k_2, k_3, k_4)\f$ of 4 elements.K2 - Input/output second camera matrix. The parameter is similar to K1 .D2 - Input/output lens distortion coefficients for the second camera. The parameter is
similar to D1 .imageSize - Size of the image used only to initialize intrinsic camera matrix.R - Output rotation matrix between the 1st and the 2nd camera coordinate systems.T - Output translation vector between the coordinate systems of the cameras.flags - Different flags that may be zero or a combination of the following values:
- **fisheye::CV_CALIB_FIX_INTRINSIC** Fix K1, K2? and D1, D2? so that only R, T matrices
are estimated.
- **fisheye::CALIB_USE_INTRINSIC_GUESS** K1, K2 contains valid initial values of
fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
center (imageSize is used), and focal distances are computed in a least-squares fashion.
- **fisheye::CALIB_RECOMPUTE_EXTRINSIC** Extrinsic will be recomputed after each iteration
of intrinsic optimization.
- **fisheye::CALIB_CHECK_COND** The functions will check validity of condition number.
- **fisheye::CALIB_FIX_SKEW** Skew coefficient (alpha) is set to zero and stay zero.
- **fisheye::CALIB_FIX_K1..4** Selected distortion coefficients are set to zeros and stay
zero.criteria - Termination criteria for the iterative optimization algorithm.@Namespace(value="cv::fisheye") public static double stereoCalibrate(@ByVal opencv_core.MatVector objectPoints, @ByVal opencv_core.MatVector imagePoints1, @ByVal opencv_core.MatVector imagePoints2, @ByVal opencv_core.Mat K1, @ByVal opencv_core.Mat D1, @ByVal opencv_core.Mat K2, @ByVal opencv_core.Mat D2, @ByVal opencv_core.Size imageSize, @ByVal opencv_core.Mat R, @ByVal opencv_core.Mat T)
Copyright © 2016. All rights reserved.