The functions in this section use a so-called pinhole camera model. In this model, a scene view is formed by projecting 3D points into the image plane using a perspective transformation.
are the coordinates of a 3D point in the world coordinate space
are the coordinates of the projection point in pixels
is a camera matrix, or a matrix of intrinsic parameters
is a principal point that is usually at the image center
are the focal lengths expressed in pixel units.
Thus, if an image from the camera is scaled by a factor, all of these parameters should be scaled (multiplied/divided, respectively) by the same factor. The matrix of intrinsic parameters does not depend on the scene viewed. So, once estimated, it can be re-used as long as the focal length is fixed (in case of zoom lens). The joint rotation-translation matrix
is called a matrix of extrinsic parameters. It is used to describe the camera motion around a static scene, or vice versa, rigid motion of an object in front of a still camera. That is,
translates coordinates of a point
to a coordinate system, fixed with respect to the camera. The transformation above is equivalent to the following (when
Real lenses usually have some distortion, mostly radial distortion and slight tangential distortion. So, the above model is extended as:
are radial distortion coefficients.
are tangential distortion coefficients. Higher-order coefficients are not considered in OpenCV. In the functions below the coefficients are passed or returned as
vector. That is, if the vector contains four elements, it means that
. The distortion coefficients do not depend on the scene viewed. Thus, they also belong to the intrinsic camera parameters. And they remain the same regardless of the captured image resolution. If, for example, a camera has been calibrated on images of 320 x 240 resolution, absolutely the same distortion coefficients can be used for 640 x 480 images from the same camera while
need to be scaled appropriately.
The functions below use the above model to do the following:
- Project 3D points to the image plane given intrinsic and extrinsic parameters.
- Compute extrinsic parameters given intrinsic parameters, a few 3D points, and their projections.
- Estimate intrinsic and extrinsic camera parameters from several views of a known calibration pattern (every view is described by several 3D-2D point correspondences).
- Estimate the relative position and orientation of the stereo camera “heads” and compute the rectificationtransformation that makes the camera optical axes parallel.
- A calibration sample for 3 cameras in horizontal position can be found at opencv_source_code/samples/cpp/3calibration.cpp
- A calibration sample based on a sequence of images can be found at opencv_source_code/samples/cpp/calibration.cpp
- A calibration sample in order to do 3D reconstruction can be found at opencv_source_code/samples/cpp/build3dmodel.cpp
- A calibration sample of an artificially generated camera and chessboard patterns can be found at opencv_source_code/samples/cpp/calibration_artificial.cpp
- A calibration example on stereo calibration can be found at opencv_source_code/samples/cpp/stereo_calib.cpp
- A calibration example on stereo matching can be found at opencv_source_code/samples/cpp/stereo_match.cpp
- (Python) A camera calibration sample can be found at opencv_source_code/samples/python2/calibrate.py
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
- C++: double calibrateCamera(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, intflags=0, TermCriteria criteria=TermCriteria( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) )
- Python: cv2.calibrateCamera(objectPoints, imagePoints, imageSize[, cameraMatrix[, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]]]) → retval, cameraMatrix, distCoeffs, rvecs, tvecs
- C: double cvCalibrateCamera2(const CvMat* object_points, const CvMat* image_points, const CvMat* point_counts, CvSize image_size, CvMat* camera_matrix, CvMat* distortion_coeffs, CvMat* rotation_vectors=NULL, CvMat*translation_vectors=NULL, int flags=0, CvTermCriteria term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON) )
- Python: cv.CalibrateCamera2(objectPoints, imagePoints, pointCounts, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags=0) → None
- objectPoints –
In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. The outer vector contains as many elements as the number of the pattern views. If the same calibration pattern is shown in each view and it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns, or even different patterns in different views. Then, the vectors will be different. The points are 3D, but since they are in a pattern coordinate system, then, if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0.
In the old interface all the vectors of object points from different views are concatenated together.
- imagePoints –
In the new interface it is a vector of vectors of the projections of calibration pattern points.imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal toobjectPoints[i].size() for each i.
In the old interface all the vectors of object points from different views are concatenated together.
- point_counts – In the old interface this is a vector of integers, containing as many elements, as the number of views of the calibration pattern. Each element is the number of points in each view. Usually, all the elements are the same and equal to the number of feature points on the calibration pattern.
- imageSize – Size of the image used only to initialize the intrinsic camera matrix.
- cameraMatrix – Output 3x3 floating-point camera matrix
. IfCV_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
of 4, 5, or 8 elements.
- 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:
- 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 whenCV_CALIB_USE_INTRINSIC_GUESS is set too.
- CV_CALIB_FIX_ASPECT_RATIO The functions considers only fy as a free parameter. The ratiofx/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
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.
- criteria – Termination criteria for the iterative optimization algorithm.
- term_crit – same as criteria.
The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on [Zhang2] and [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 (whenCV_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.
If you use a non-square (=non-NxN) grid and findChessboardCorners() for calibration, and calibrateCamerareturns bad values (zero distortion coefficients, an image center very far from (w/2-0.5,h/2-0.5), and/or large differences between
(ratios of 10:1 or more)), then you have probably used patternSize=cvSize(rows,cols) instead of using patternSize=cvSize(cols,rows) in findChessboardCorners() .
Computes useful camera characteristics from the camera matrix.
- C++: void calibrationMatrixValues(InputArray cameraMatrix, Size imageSize, double apertureWidth, doubleapertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio)
- Python: cv2.calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight) → fovx, fovy, focalLength, principalPoint, aspectRatio
- cameraMatrix – Input camera matrix that can be estimated by calibrateCamera() orstereoCalibrate() .
- 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 –
The function computes various useful camera characteristics from the previously estimated camera matrix.
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).
Combines two rotation-and-shift transformations.
- C++: void composeRT(InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArraydr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArraydt3dt2=noArray() )
- Python: cv2.composeRT(rvec1, tvec1, rvec2, tvec2[, rvec3[, tvec3[, dr3dr1[, dr3dt1[, dr3dr2[, dr3dt2[, dt3dr1[, dt3dt1[, dt3dr2[, dt3dt2]]]]]]]]]]) → rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, 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.
- d*d* – Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
The functions compute:
denotes a rotation vector to a rotation matrix transformation, and
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.
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
- C++: void computeCorrespondEpilines(InputArray points, int whichImage, InputArray F, OutputArray lines)
- C: void cvComputeCorrespondEpilines(const CvMat* points, int which_image, const CvMat* fundamental_matrix, CvMat* correspondent_lines)
- Python: cv.ComputeCorrespondEpilines(points, whichImage, F, lines) → None
- points – Input points.
matrix of type CV_32FC2 or vector<Point2f> .
- 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
is encoded by 3 numbers
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
in the second image for the point
in the first image (when whichImage=1 ) is computed as:
And vice versa, when whichImage=2,
is computed from
Line coefficients are defined up to a scale. They are normalized so that
Converts points from Euclidean to homogeneous space.
- C++: void convertPointsToHomogeneous(InputArray src, OutputArray dst)
- Python: cv2.convertPointsToHomogeneous(src[, dst]) → 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).
Converts points from homogeneous to Euclidean space.
- C++: void convertPointsFromHomogeneous(InputArray src, OutputArray dst)
- Python: cv2.convertPointsFromHomogeneous(src[, dst]) → 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,...).
Converts points to/from homogeneous coordinates.
- C++: void convertPointsHomogeneous(InputArray src, OutputArray dst)
- C: void cvConvertPointsHomogeneous(const CvMat* src, CvMat* dst)
- Python: cv.ConvertPointsHomogeneous(src, dst) → None
- 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() orconvertPointsFromHomogeneous().
The function is obsolete. Use one of the previous two functions instead.
Refines coordinates of corresponding points.
- C++: void correctMatches(InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArraynewPoints2)
- Python: cv2.correctMatches(F, points1, points2[, newPoints1[, newPoints2]]) → newPoints1, newPoints2
- C: void cvCorrectMatches(CvMat* F, CvMat* points1, CvMat* points2, CvMat* new_points1, CvMat* new_points2)
- 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
is the geometric distance between points
) subject to the epipolar constraint
Decomposes a projection matrix into a rotation matrix and a camera matrix.
- C++: void decomposeProjectionMatrix(InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArrayrotMatrixZ=noArray(), OutputArray eulerAngles=noArray() )
- Python: cv2.decomposeProjectionMatrix(projMatrix[, cameraMatrix[, rotMatrix[, transVect[, rotMatrixX[, rotMatrixY[, rotMatrixZ[, eulerAngles]]]]]]]) → cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles
- C: void cvDecomposeProjectionMatrix(const CvMat* projMatr, CvMat* calibMatr, CvMat* rotMatr, CvMat* posVect, CvMat* rotMatrX=NULL, CvMat* rotMatrY=NULL, CvMat* rotMatrZ=NULL, CvPoint3D64f* eulerAngles=NULL )
- Python: cv.DecomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrX=None, rotMatrY=None, rotMatrZ=None) → 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.
- rotMatrX – Optional 3x3 rotation matrix around x-axis.
- rotMatrY – Optional 3x3 rotation matrix around y-axis.
- rotMatrZ – 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 [Slabaugh]. Returned tree rotation matrices and corresponding three Euler angules are only one of the possible solutions.
The function is based on RQDecomp3x3() .
Renders the detected chessboard corners.
- C++: void drawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, boolpatternWasFound)
- Python: cv2.drawChessboardCorners(image, patternSize, corners, patternWasFound) → None
- C: void cvDrawChessboardCorners(CvArr* image, CvSize pattern_size, CvPoint2D32f* corners, int count, intpattern_was_found)
- Python: cv.DrawChessboardCorners(image, patternSize, corners, patternWasFound) → None
- 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.
Finds the positions of internal corners of the chessboard.
- C++: bool findChessboardCorners(InputArray image, Size patternSize, OutputArray corners, intflags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE )
- Python: cv2.findChessboardCorners(image, patternSize[, corners[, flags]]) → retval, corners
- C: int cvFindChessboardCorners(const void* image, CvSize pattern_size, CvPoint2D32f* corners, int*corner_count=NULL, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE )
- Python: cv.FindChessboardCorners(image, patternSize, flags=CV_CALIB_CB_ADAPTIVE_THRESH) → corners
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
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);
The function requires white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environments. Otherwise, if there is no border and the background is dark, the outer black squares cannot be segmented properly and so the square grouping and ordering algorithm fails.
Finds centers in the grid of circles.
- C++: bool findCirclesGrid(InputArray image, Size patternSize, OutputArray centers, intflags=CALIB_CB_SYMMETRIC_GRID, const Ptr<FeatureDetector>& blobDetector=new SimpleBlobDetector() )
- Python: cv2.findCirclesGridDefault(image, patternSize[, centers[, flags]]) → retval, centers
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);
The function requires white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environments.
Finds an object pose from 3D-2D point correspondences.
- C++: bool solvePnP(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=ITERATIVE )
- Python: cv2.solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, flags]]]]) → retval, rvec, tvec
- C: void cvFindExtrinsicCameraParams2(const CvMat* object_points, const CvMat* image_points, const CvMat*camera_matrix, const CvMat* distortion_coeffs, CvMat* rotation_vector, CvMat* translation_vector, intuse_extrinsic_guess=0 )
- Python: cv.FindExtrinsicCameraParams2(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess=0) → None
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.
- An example of how to use solvePNP for planar augmented reality can be found at opencv_source_code/samples/python2/plane_ar.py
Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
- C++: void solvePnPRansac(InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArraydistCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, floatreprojectionError=8.0, int minInliersCount=100, OutputArray inliers=noArray(), int flags=ITERATIVE )
- Python: cv2.solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs[, rvec[, tvec[, useExtrinsicGuess[, iterationsCount[, reprojectionError[, minInliersCount[, inliers[, flags]]]]]]]]) → rvec, tvec, inliers
- 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<Point3f> can be also passed here.
- imagePoints – Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. vector<Point2f> can be also passed here.
- cameraMatrix – Input camera matrix
- distCoeffs – Input vector of distortion coefficients
of 4, 5, or 8 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 – 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.
- minInliersCount – Number of inliers. If the algorithm at some stage finds more inliers thanminInliersCount , it finishes.
- 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. The function is parallelized with the TBB library.
Calculates a fundamental matrix from the corresponding points in two images.
- C++: Mat findFundamentalMat(InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., doubleparam2=0.99, OutputArray mask=noArray() )
- Python: cv2.findFundamentalMat(points1, points2[, method[, param1[, param2[, mask]]]]) → retval, mask
- C: int cvFindFundamentalMat(const CvMat* points1, const CvMat* points2, CvMat* fundamental_matrix, intmethod=CV_FM_RANSAC, double param1=3., double param2=0.99, CvMat* status=NULL )
- Python: cv.FindFundamentalMat(points1, points2, fundamentalMatrix, method=CV_FM_RANSAC, param1=1., param2=0.99, status=None) → retval
The epipolar geometry is described by the following equation:
is a fundamental matrix,
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 (
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;
// 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);
Finds a perspective transformation between two planes.
- C++: Mat findHomography(InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() )
- Python: cv2.findHomography(srcPoints, dstPoints[, method[, ransacReprojThreshold[, mask]]]) → retval, mask
- C: int cvFindHomography(const CvMat* src_points, const CvMat* dst_points, CvMat* homography, int method=0, doubleransacReprojThreshold=3, CvMat* mask=0 )
- Python: cv.FindHomography(srcPoints, dstPoints, H, method=0, ransacReprojThreshold=3.0, status=None) → None
- srcPoints – Coordinates of the points in the original plane, a matrix of the type CV_32FC2 orvector<Point2f> .
- dstPoints – Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or avector<Point2f> .
- method –
Method used to computed a homography matrix. The following methods are possible:
- 0 - a regular method using all the points
- CV_RANSAC - RANSAC-based robust method
- CV_LMEDS - Least-Median robust method
- ransacReprojThreshold –
Maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only). That is, if
then the point
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 ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored.
The functions find and return the perspective transformation
between the source and the destination planes:
so that the back-projection error
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 (
) 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 two robust methods. Both methods, RANSAC and LMeDS , 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 method RANSAC can handle practically any ratio of outliers but it needs 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
. Note that whenever an H matrix cannot be estimated, an empty one will be returned.
- A example on calculating a homography for image matching can be found at opencv_source_code/samples/cpp/video_homography.cpp