注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

dp: 生活的脚步,进步的点滴...

Cam、DSP、FPGA、PM、Life、More ...

 
 
 

日志

 
 

Camera Calibration (1)  

2015-09-15 15:33:04|  分类: 默认分类 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

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.

相机标定英文原汁原味

or

相机标定英文原汁原味

where:

  • 相机标定英文原汁原味
     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:

相机标定英文原汁原味

相机标定英文原汁原味
相机标定英文原汁原味
相机标定英文原汁原味
相机标定英文原汁原味
相机标定英文原汁原味
, and 相机标定英文原汁原味
 are radial distortion coefficients. 相机标定英文原汁原味
 and 相机标定英文原汁原味
 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 240 resolution, absolutely the same distortion coefficients can be used for 640 480 images from the same camera while 相机标定英文原汁原味
相机标定英文原汁原味
相机标定英文原汁原味
, and 相机标定英文原汁原味
 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.

Note

  • 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

calibrateCamera

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
Parameters:
  • 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:

  1. 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.
  2. Estimate the initial camera pose as if the intrinsic parameters have been already known. This is done using solvePnP().
  3. 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 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 相机标定英文原汁原味
 and 相机标定英文原汁原味
 (ratios of 10:1 or more)), then you have probably used patternSize=cvSize(rows,cols) instead of using patternSize=cvSize(cols,rows) in findChessboardCorners() .

calibrationMatrixValues

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
Parameters:
  • 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.

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

composeRT

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
Parameters:
  • 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 rvec1rvec2tvec1 and tvec2, respectively.

The functions compute:

相机标定英文原汁原味

where 相机标定英文原汁原味
 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.

computeCorrespondEpilines

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
Parameters:
  • points – Input points. 相机标定英文原汁原味
     or 相机标定英文原汁原味
     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 相机标定英文原汁原味
 as:

相机标定英文原汁原味

Line coefficients are defined up to a scale. They are normalized so that 相机标定英文原汁原味
 .

convertPointsToHomogeneous

Converts points from Euclidean to homogeneous space.

C++: void convertPointsToHomogeneous(InputArray src, OutputArray dst)
Python: cv2.convertPointsToHomogeneous(src[, dst]) → dst
Parameters:
  • 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).

convertPointsFromHomogeneous

Converts points from homogeneous to Euclidean space.

C++: void convertPointsFromHomogeneous(InputArray src, OutputArray dst)
Python: cv2.convertPointsFromHomogeneous(src[, dst]) → dst
Parameters:
  • 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,...).

convertPointsHomogeneous

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
Parameters:
  • 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().

Note

 

The function is obsolete. Use one of the previous two functions instead.

correctMatches

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)
Parameters:
  • 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相机标定英文原汁原味
 (where 相机标定英文原汁原味
 is the geometric distance between points 相机标定英文原汁原味
 and相机标定英文原汁原味
 ) subject to the epipolar constraint 相机标定英文原汁原味
 .

decomposeProjectionMatrix

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
Parameters:
  • 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() .

drawChessboardCorners

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
Parameters:
  • 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.

findChessboardCorners

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
Parameters:
  • 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);

Note

 

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.

findCirclesGrid

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
Parameters:
  • 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);

Note

 

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.

solvePnP

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
Parameters:
  • 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.
  • flags –

    Method for solving a PnP problem:

    • CV_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 .
    • CV_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.
    • CV_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”.

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/python2/plane_ar.py

solvePnPRansac

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
Parameters:
  • 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.

findFundamentalMat

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
Parameters:
  • 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. 相机标定英文原汁原味
    • CV_FM_8POINT for an 8-point algorithm. 相机标定英文原汁原味
    • CV_FM_RANSAC for the RANSAC algorithm. 相机标定英文原汁原味
    • CV_FM_LMEDS for the LMedS algorithm. 相机标定英文原汁原味
  • 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.
  • status – 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. For other methods, it is set to all 1’s.

The epipolar geometry is described by the following equation:

相机标定英文原汁原味

where 相机标定英文原汁原味
 is a fundamental matrix, 相机标定英文原汁原味
 and 相机标定英文原汁原味
 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;
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);

findHomography

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
Parameters:
  • 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.

Note

  • A example on calculating a homography for image matching can be found at opencv_source_code/samples/cpp/video_homography.cpp
  评论这张
 
阅读(868)| 评论(0)
推荐

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2016