namespace cv
{
-
+
+//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
CV_EXPORTS void Rodrigues(const Mat& src, Mat& dst);
+
+//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation. Also computes the Jacobian matrix
CV_EXPORTS void Rodrigues(const Mat& src, Mat& dst, Mat& jacobian);
-enum { LMEDS=4, RANSAC=8 };
+//! type of the robust estimation algorithm
+enum
+{
+ LMEDS=4, //!< least-median algorithm
+ RANSAC=8 //!< RANSAC algorithm
+};
+//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
CV_EXPORTS Mat findHomography( const Mat& srcPoints,
const Mat& dstPoints,
Mat& mask, int method=0,
double ransacReprojThreshold=3 );
+//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
CV_EXPORTS Mat findHomography( const Mat& srcPoints,
const Mat& dstPoints,
vector<uchar>& mask, int method=0,
double ransacReprojThreshold=3 );
+//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
CV_EXPORTS Mat findHomography( const Mat& srcPoints,
const Mat& dstPoints,
int method=0, double ransacReprojThreshold=3 );
-/* Computes RQ decomposition for 3x3 matrices */
+//! Computes RQ decomposition of 3x3 matrix
CV_EXPORTS void RQDecomp3x3( const Mat& M, Mat& R, Mat& Q );
+
+//! Computes RQ decomposition of 3x3 matrix. Also, decomposes the output orthogonal matrix into the 3 primitive rotation matrices
CV_EXPORTS Vec3d RQDecomp3x3( const Mat& M, Mat& R, Mat& Q,
Mat& Qx, Mat& Qy, Mat& Qz );
+//! Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
Mat& rotMatrix, Mat& transVect );
+
+//! Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. The rotation matrix is further decomposed
CV_EXPORTS void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix,
Mat& rotMatrix, Mat& transVect,
Mat& rotMatrixX, Mat& rotMatrixY,
Mat& rotMatrixZ, Vec3d& eulerAngles );
+//! computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
CV_EXPORTS void matMulDeriv( const Mat& A, const Mat& B, Mat& dABdA, Mat& dABdB );
+//! composes 2 [R|t] transformations together
CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
const Mat& rvec2, const Mat& tvec2,
Mat& rvec3, Mat& tvec3 );
+//! composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
const Mat& rvec2, const Mat& tvec2,
Mat& rvec3, Mat& tvec3,
Mat& dt3dr1, Mat& dt3dt1,
Mat& dt3dr2, Mat& dt3dt2 );
+//! projects points from the model coordinate space to the image coordinates. Takes the intrinsic and extrinsic camera parameters into account
CV_EXPORTS void projectPoints( const Mat& objectPoints,
const Mat& rvec, const Mat& tvec,
const Mat& cameraMatrix,
const Mat& distCoeffs,
vector<Point2f>& imagePoints );
+//! projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters
CV_EXPORTS void projectPoints( const Mat& objectPoints,
const Mat& rvec, const Mat& tvec,
const Mat& cameraMatrix,
Mat& dpdc, Mat& dpddist,
double aspectRatio=0 );
+//! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.
CV_EXPORTS void solvePnP( const Mat& objectPoints,
const Mat& imagePoints,
const Mat& cameraMatrix,
Mat& rvec, Mat& tvec,
bool useExtrinsicGuess=false );
+//! initializes camera matrix from a few 3D points and the corresponding projections.
CV_EXPORTS Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints,
const vector<vector<Point2f> >& imagePoints,
Size imageSize, double aspectRatio=1. );
+
enum { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2,
CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 };
+//! finds checkerboard pattern of the specified size in the image
CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize,
vector<Point2f>& corners,
int flags=CALIB_CB_ADAPTIVE_THRESH+
CALIB_CB_NORMALIZE_IMAGE );
+//! draws the checkerboard pattern (found or partly found) in the image
CV_EXPORTS void drawChessboardCorners( Mat& image, Size patternSize,
const Mat& corners,
bool patternWasFound );
CALIB_ZERO_DISPARITY = 1024
};
+//! finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
CV_EXPORTS double calibrateCamera( const vector<vector<Point3f> >& objectPoints,
const vector<vector<Point2f> >& imagePoints,
Size imageSize,
vector<Mat>& rvecs, vector<Mat>& tvecs,
int flags=0 );
+//! computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
CV_EXPORTS void calibrationMatrixValues( const Mat& cameraMatrix,
Size imageSize,
double apertureWidth,
double& focalLength,
Point2d& principalPoint,
double& aspectRatio );
-
+
+//! finds intrinsic and extrinsic parameters of a stereo camera
CV_EXPORTS double stereoCalibrate( const vector<vector<Point3f> >& objectPoints,
const vector<vector<Point2f> >& imagePoints1,
const vector<vector<Point2f> >& imagePoints2,
TermCriteria::EPS, 30, 1e-6),
int flags=CALIB_FIX_INTRINSIC );
+//! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
const Mat& cameraMatrix2, const Mat& distCoeffs2,
Size imageSize, const Mat& R, const Mat& T,
Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
int flags=CALIB_ZERO_DISPARITY );
+//! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
const Mat& cameraMatrix2, const Mat& distCoeffs2,
Size imageSize, const Mat& R, const Mat& T,
Rect* validPixROI1=0, Rect* validPixROI2=0,
int flags=CALIB_ZERO_DISPARITY );
+//! computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
CV_EXPORTS bool stereoRectifyUncalibrated( const Mat& points1,
const Mat& points2,
const Mat& F, Size imgSize,
Mat& H1, Mat& H2,
double threshold=5 );
+//! returns the optimal new camera matrix
CV_EXPORTS Mat getOptimalNewCameraMatrix( const Mat& cameraMatrix, const Mat& distCoeffs,
Size imageSize, double alpha, Size newImgSize=Size(),
Rect* validPixROI=0);
+//! converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst );
+//! converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst );
+//! the algorithm for finding fundamental matrix
enum
{
- FM_7POINT = 1, FM_8POINT = 2, FM_LMEDS = 4, FM_RANSAC = 8
+ FM_7POINT = 1, //!< 7-point algorithm
+ FM_8POINT = 2, //!< 8-point algorithm
+ FM_LMEDS = 4, //!< least-median algorithm
+ FM_RANSAC = 8 //!< RANSAC algorithm
};
+// finds fundamental matrix from a set of corresponding 2D points
CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2,
vector<uchar>& mask, int method=FM_RANSAC,
double param1=3., double param2=0.99 );
+// finds fundamental matrix from a set of corresponding 2D points
CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2,
int method=FM_RANSAC,
double param1=3., double param2=0.99 );
+// finds coordinates of epipolar lines corresponding the specified points
CV_EXPORTS void computeCorrespondEpilines( const Mat& points1,
int whichImage, const Mat& F,
vector<Vec3f>& lines );
template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
-// Block matching stereo correspondence algorithm
+/*!
+ Block Matching Stereo Correspondence Algorithm
+
+ The class implements BM stereo correspondence algorithm by K. Konolige.
+*/
class CV_EXPORTS StereoBM
{
public:
enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1,
BASIC_PRESET=0, FISH_EYE_PRESET=1, NARROW_PRESET=2 };
+ //! the default constructor
StereoBM();
+ //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size
StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);
+ //! the method that reinitializes the state. The previous content is destroyed
void init(int preset, int ndisparities=0, int SADWindowSize=21);
+ //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
void operator()( const Mat& left, const Mat& right, Mat& disparity, int disptype=CV_16S );
+ //! pointer to the underlying CvStereoBMState
Ptr<CvStereoBMState> state;
};
+/*!
+ Semi-Global Block Matching Stereo Correspondence Algorithm
+
+ The class implements the original SGBM stereo correspondence algorithm by H. Hirschmuller and some its modification.
+ */
class CV_EXPORTS StereoSGBM
{
public:
enum { DISP_SHIFT=4, DISP_SCALE = (1<<DISP_SHIFT) };
+ //! the default constructor
StereoSGBM();
+
+ //! the full constructor taking all the necessary algorithm parameters
StereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
int P1=0, int P2=0, int disp12MaxDiff=0,
int preFilterCap=0, int uniquenessRatio=0,
int speckleWindowSize=0, int speckleRange=0,
bool fullDP=false);
+ //! the destructor
virtual ~StereoSGBM();
+ //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair
virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
int minDisparity;
Mat buffer;
};
-
+//! filters off speckles (small regions of incorrectly computed disparity)
CV_EXPORTS void filterSpeckles( Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf );
+//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
CV_EXPORTS Rect getValidDisparityROI( Rect roi1, Rect roi2,
int minDisparity, int numberOfDisparities,
int SADWindowSize );
+//! validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
CV_EXPORTS void validateDisparity( Mat& disparity, const Mat& cost,
int minDisparity, int numberOfDisparities,
int disp12MaxDisp=1 );
+//! reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
CV_EXPORTS void reprojectImageTo3D( const Mat& disparity,
Mat& _3dImage, const Mat& Q,
bool handleMissingValues=false );
+/*! \file tracking.hpp
+ \brief The Object and Feature Tracking
+ */
+
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
(corrects state of the system and internal matrices) */
CVAPI(const CvMat*) cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement );
+#define cvKalmanUpdateByTime cvKalmanPredict
+#define cvKalmanUpdateByMeasurement cvKalmanCorrect
+
#ifdef __cplusplus
}
namespace cv
{
+//! updates motion history image using the current silhouette
CV_EXPORTS void updateMotionHistory( const Mat& silhouette, Mat& mhi,
double timestamp, double duration );
+//! computes the motion gradient orientation image from the motion history image
CV_EXPORTS void calcMotionGradient( const Mat& mhi, Mat& mask,
Mat& orientation,
double delta1, double delta2,
int apertureSize=3 );
+//! computes the global orientation of the selected motion history image part
CV_EXPORTS double calcGlobalOrientation( const Mat& orientation, const Mat& mask,
const Mat& mhi, double timestamp,
double duration );
// TODO: need good API for cvSegmentMotion
+//! updates the object tracking window using CAMSHIFT algorithm
CV_EXPORTS RotatedRect CamShift( const Mat& probImage, Rect& window,
TermCriteria criteria );
+//! updates the object tracking window using meanshift algorithm
CV_EXPORTS int meanShift( const Mat& probImage, Rect& window,
TermCriteria criteria );
+/*!
+ Kalman filter.
+
+ The class implements standard Kalman filter \url{http://en.wikipedia.org/wiki/Kalman_filter}.
+ However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and
+ KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.
+*/
class CV_EXPORTS KalmanFilter
{
public:
+ //! the default constructor
KalmanFilter();
+ //! the full constructor taking the dimensionality of the state, of the measurement and of the control vector
KalmanFilter(int dynamParams, int measureParams, int controlParams=0);
+ //! re-initializes Kalman filter. The previous content is destroyed.
void init(int dynamParams, int measureParams, int controlParams=0);
+ //! computes predicted state
const Mat& predict(const Mat& control=Mat());
+ //! updates the predicted state from the measurement
const Mat& correct(const Mat& measurement);
- Mat statePre; // predicted state (x'(k)):
- // x(k)=A*x(k-1)+B*u(k)
- Mat statePost; // corrected state (x(k)):
- // x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
- Mat transitionMatrix; // state transition matrix (A)
- Mat controlMatrix; // control matrix (B)
- // (it is not used if there is no control)
- Mat measurementMatrix; // measurement matrix (H)
- Mat processNoiseCov; // process noise covariance matrix (Q)
- Mat measurementNoiseCov;// measurement noise covariance matrix (R)
- Mat errorCovPre; // priori error estimate covariance matrix (P'(k)):
- // P'(k)=A*P(k-1)*At + Q)*/
- Mat gain; // Kalman gain matrix (K(k)):
- // K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
- Mat errorCovPost; // posteriori error estimate covariance matrix (P(k)):
- // P(k)=(I-K(k)*H)*P'(k)
- Mat temp1; // temporary matrices
+ Mat statePre; //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
+ Mat statePost; //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
+ Mat transitionMatrix; //!< state transition matrix (A)
+ Mat controlMatrix; //!< control matrix (B) (not used if there is no control)
+ Mat measurementMatrix; //!< measurement matrix (H)
+ Mat processNoiseCov; //!< process noise covariance matrix (Q)
+ Mat measurementNoiseCov;//!< measurement noise covariance matrix (R)
+ Mat errorCovPre; //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
+ Mat gain; //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
+ Mat errorCovPost; //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
+
+ // temporary matrices
+ Mat temp1;
Mat temp2;
Mat temp3;
Mat temp4;
};
-#define cvKalmanUpdateByTime cvKalmanPredict
-#define cvKalmanUpdateByMeasurement cvKalmanCorrect
-
-
enum { OPTFLOW_USE_INITIAL_FLOW=4, OPTFLOW_FARNEBACK_GAUSSIAN=256 };
+//! computes sparse optical flow using multi-scale Lucas-Kanade algorithm
CV_EXPORTS void calcOpticalFlowPyrLK( const Mat& prevImg, const Mat& nextImg,
const vector<Point2f>& prevPts, vector<Point2f>& nextPts,
vector<uchar>& status, vector<float>& err,
double derivLambda=0.5,
int flags=0 );
+//! computes dense optical flow using Farneback algorithm
CV_EXPORTS void calcOpticalFlowFarneback( const Mat& prev0, const Mat& next0,
Mat& flow0, double pyr_scale, int levels, int winsize,
int iterations, int poly_n, double poly_sigma, int flags );
projects / platform / upstream / opencv.git / commitdiff