{
//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
-CV_EXPORTS void Rodrigues(const Mat& src, Mat& dst);
+CV_EXPORTS_W void Rodrigues(const Mat& src, CV_OUT 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);
+CV_EXPORTS_AS(RodriguesJ) void Rodrigues(const Mat& src, CV_OUT Mat& dst, CV_OUT Mat& jacobian);
//! type of the robust estimation algorithm
enum
};
//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
-CV_EXPORTS Mat findHomography( const Mat& srcPoints,
+CV_EXPORTS_AS(findHomographyAndOutliers) Mat findHomography( const Mat& srcPoints,
const Mat& dstPoints,
- Mat& mask, int method=0,
+ CV_OUT Mat& mask, int method=0,
double ransacReprojThreshold=3 );
//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
double ransacReprojThreshold=3 );
//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.
-CV_EXPORTS Mat findHomography( const Mat& srcPoints,
+CV_EXPORTS_W Mat findHomography( const Mat& srcPoints,
const Mat& dstPoints,
int method=0, double ransacReprojThreshold=3 );
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 );
+CV_EXPORTS_W Vec3d RQDecomp3x3( const Mat& M, Mat& R, Mat& Q,
+ CV_OUT Mat& Qx, CV_OUT Mat& Qy, CV_OUT 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 );
+CV_EXPORTS_W void decomposeProjectionMatrix( const Mat& projMatrix, CV_OUT Mat& cameraMatrix,
+ CV_OUT Mat& rotMatrix, CV_OUT Mat& transVect,
+ CV_OUT Mat& rotMatrixX, CV_OUT Mat& rotMatrixY,
+ CV_OUT Mat& rotMatrixZ, CV_OUT 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 );
+CV_EXPORTS_W void matMulDeriv( const Mat& A, const Mat& B, CV_OUT Mat& dABdA, CV_OUT Mat& dABdB );
//! composes 2 [R|t] transformations together
-CV_EXPORTS void composeRT( const Mat& rvec1, const Mat& tvec1,
+CV_EXPORTS_W void composeRT( const Mat& rvec1, const Mat& tvec1,
const Mat& rvec2, const Mat& tvec2,
- Mat& rvec3, Mat& tvec3 );
+ CV_OUT Mat& rvec3, CV_OUT 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,
+CV_EXPORTS_AS(composeRT_J) void composeRT( const Mat& rvec1, const Mat& tvec1,
const Mat& rvec2, const Mat& tvec2,
- Mat& rvec3, Mat& tvec3,
- Mat& dr3dr1, Mat& dr3dt1,
- Mat& dr3dr2, Mat& dr3dt2,
- Mat& dt3dr1, Mat& dt3dt1,
- Mat& dt3dr2, Mat& dt3dt2 );
+ CV_OUT Mat& rvec3, CV_OUT Mat& tvec3,
+ CV_OUT Mat& dr3dr1, CV_OUT Mat& dr3dt1,
+ CV_OUT Mat& dr3dr2, CV_OUT Mat& dr3dt2,
+ CV_OUT Mat& dt3dr1, CV_OUT Mat& dt3dt1,
+ CV_OUT Mat& dt3dr2, CV_OUT 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 );
+
CV_OUT 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,
const Mat& distCoeffs,
- vector<Point2f>& imagePoints,
- Mat& dpdrot, Mat& dpdt, Mat& dpdf,
- Mat& dpdc, Mat& dpddist,
+
CV_OUT vector<Point2f>& imagePoints,
+ CV_OUT Mat& dpdrot, CV_OUT Mat& dpdt, CV_OUT Mat& dpdf,
+ CV_OUT Mat& dpdc, CV_OUT 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,
- const Mat& distCoeffs,
- Mat& rvec, Mat& tvec,
- bool useExtrinsicGuess=false );
+CV_EXPORTS_W void solvePnP( const Mat& objectPoints,
+ const Mat& imagePoints,
+ const Mat& cameraMatrix,
+ const Mat& distCoeffs,
+ CV_OUT Mat& rvec, CV_OUT 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,
//! finds checkerboard pattern of the specified size in the image
CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize,
- vector<Point2f>& corners,
+
CV_OUT vector<Point2f>& corners,
int flags=CALIB_CB_ADAPTIVE_THRESH+
- CALIB_CB_NORMALIZE_IMAGE );
+ 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 );
+CV_EXPORTS_W void drawChessboardCorners( Mat& image, Size patternSize,
+ const Mat& corners,
+ bool patternWasFound );
enum
{
//! 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,
- Mat& cameraMatrix, Mat& distCoeffs,
- vector<Mat>& rvecs, vector<Mat>& tvecs,
- int flags=0 );
+ const vector<vector<Point2f> >& imagePoints,
+ Size imageSize,
+ CV_IN_OUT Mat& cameraMatrix,
+ CV_IN_OUT Mat& distCoeffs,
+ CV_OUT vector<Mat>& rvecs, CV_OUT 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,
+CV_EXPORTS_W void calibrationMatrixValues( const Mat& cameraMatrix,
Size imageSize,
double apertureWidth,
double apertureHeight,
- double& fovx,
- double& fovy,
- double& focalLength,
- Point2d& principalPoint,
- double& aspectRatio );
+ CV_OUT double& fovx,
+ CV_OUT double& fovy,
+ CV_OUT double& focalLength,
+ CV_OUT Point2d& principalPoint,
+ CV_OUT 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,
- Mat& cameraMatrix1, Mat& distCoeffs1,
- Mat& cameraMatrix2, Mat& distCoeffs2,
- Size imageSize, Mat& R, Mat& T,
- Mat& E, Mat& F,
- TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
- TermCriteria::EPS, 30, 1e-6),
- int flags=CALIB_FIX_INTRINSIC );
+
const vector<vector<Point2f> >& imagePoints1,
+
const vector<vector<Point2f> >& imagePoints2,
+ CV_IN_OUT Mat& cameraMatrix1, CV_IN_OUT Mat& distCoeffs1,
+ CV_IN_OUT Mat& cameraMatrix2, CV_IN_OUT Mat& distCoeffs2,
+ Size imageSize, CV_OUT Mat& R, CV_OUT Mat& T,
+ CV_OUT Mat& E, CV_OUT Mat& F,
+ TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
+ 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,
+ CV_OUT Mat& R1, CV_OUT Mat& R2,
+ CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT 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,
- Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
- double alpha, Size newImageSize=Size(),
- Rect* validPixROI1=0, Rect* validPixROI2=0,
- int flags=CALIB_ZERO_DISPARITY );
+CV_EXPORTS_W void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
+ const Mat& cameraMatrix2, const Mat& distCoeffs2,
+ Size imageSize, const Mat& R, const Mat& T,
+ CV_OUT Mat& R1, CV_OUT Mat& R2,
+ CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& Q,
+ double alpha, Size newImageSize=Size(),
+ CV_OUT Rect* validPixROI1=0, CV_OUT 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 );
-
-//! computes the rectification transformations for 3-head camera, where the heads are on the same line.
-CV_EXPORTS float rectify3( const Mat& cameraMatrix1, const Mat& distCoeffs1,
- const Mat& cameraMatrix2, const Mat& distCoeffs2,
- const Mat& cameraMatrix3, const Mat& distCoeffs3,
- const vector<vector<Point2f> >& imgpt1,
- const vector<vector<Point2f> >& imgpt3,
- Size imageSize, const Mat& R12, const Mat& T12, const Mat& R13, const Mat& T13,
- Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q,
- double alpha, Size newImgSize,
- Rect* roi1, Rect* roi2, int flags );
+CV_EXPORTS_W bool stereoRectifyUncalibrated( const Mat& points1, const Mat& points2,
+ const Mat& F, Size imgSize,
+ CV_OUT Mat& H1, CV_OUT Mat& H2,
+ double threshold=5 );
+
+//! computes the rectification transformations for 3-head camera, where all the heads are on the same line.
+CV_EXPORTS float rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1,
+ const Mat& cameraMatrix2, const Mat& distCoeffs2,
+ const Mat& cameraMatrix3, const Mat& distCoeffs3,
+ const vector<vector<Point2f> >& imgpt1,
+ const vector<vector<Point2f> >& imgpt3,
+ Size imageSize, const Mat& R12, const Mat& T12,
+ const Mat& R13, const Mat& T13,
+ CV_OUT Mat& R1, CV_OUT Mat& R2, CV_OUT Mat& R3,
+ CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& P3, CV_OUT Mat& Q,
+ double alpha, Size newImgSize,
+ CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags );
//! 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);
+CV_EXPORTS_W Mat getOptimalNewCameraMatrix( const Mat& cameraMatrix, const Mat& distCoeffs,
+ Size imageSize, double alpha, Size newImgSize=Size(),
+ CV_OUT 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 );
+CV_EXPORTS void convertPointsHomogeneous( const Mat& src,
CV_OUT 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 );
+CV_EXPORTS void convertPointsHomogeneous( const Mat& src,
CV_OUT vector<Point2f>& dst );
//! the algorithm for finding fundamental matrix
enum
//! 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 );
+ CV_OUT 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 );
+CV_EXPORTS_W 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 );
+ int whichImage, const Mat& F,
+ CV_OUT vector<Vec3f>& lines );
template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
The class implements BM stereo correspondence algorithm by K. Konolige.
*/
-class CV_EXPORTS StereoBM
+class CV_EXPORTS_W StereoBM
{
public:
enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1,
BASIC_PRESET=0, FISH_EYE_PRESET=1, NARROW_PRESET=2 };
//! the default constructor
- StereoBM();
+ CV_WRAP 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);
+ CV_WRAP 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 );
+ CV_WRAP_AS(compute) void operator()( const Mat& left, const Mat& right, Mat& disparity, int disptype=CV_16S );
//! pointer to the underlying CvStereoBMState
Ptr<CvStereoBMState> state;
The class implements the original SGBM stereo correspondence algorithm by H. Hirschmuller and some its modification.
*/
-class CV_EXPORTS StereoSGBM
+class CV_EXPORTS_W StereoSGBM
{
public:
enum { DISP_SHIFT=4, DISP_SCALE = (1<<DISP_SHIFT) };
//! the default constructor
- StereoSGBM();
+ CV_WRAP StereoSGBM();
//! the full constructor taking all the necessary algorithm parameters
- StereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
+ CV_WRAP 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,
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;
- int numberOfDisparities;
- int SADWindowSize;
- int preFilterCap;
- int uniquenessRatio;
- int P1, P2;
- int speckleWindowSize;
- int speckleRange;
- int disp12MaxDiff;
- bool fullDP;
+ CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
+
+ CV_PROP_RW int minDisparity;
+ CV_PROP_RW int numberOfDisparities;
+ CV_PROP_RW int SADWindowSize;
+ CV_PROP_RW int preFilterCap;
+ CV_PROP_RW int uniquenessRatio;
+ CV_PROP_RW int P1;
+ CV_PROP_RW int P2;
+ CV_PROP_RW int speckleWindowSize;
+ CV_PROP_RW int speckleRange;
+ CV_PROP_RW int disp12MaxDiff;
+ CV_PROP_RW bool fullDP;
protected:
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 );
+CV_EXPORTS_W 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 );
+CV_EXPORTS_W 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 );
+CV_EXPORTS_W 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 );
+CV_EXPORTS_W void reprojectImageTo3D( const Mat& disparity,
+ CV_OUT Mat& _3dImage, const Mat& Q,
+ bool handleMissingValues=false );
}
std::copy(imagePoints2[i].begin(), imagePoints2[i].end(), imgPtData2 + j);
}
}
+
static Mat prepareCameraMatrix(Mat& cameraMatrix0, int rtype)
{
CvMat _cameraMatrix = cameraMatrix, _distCoeffs = distCoeffs;
CvMat _rvecM = rvecM, _tvecM = tvecM;
- double reprojErr = cvCalibrateCamera2(
- &_objPt, &_imgPt, &_npoints, imageSize, &_cameraMatrix,
- &_distCoeffs, &_rvecM, &_tvecM, flags );
+ double reprojErr = cvCalibrateCamera2(&_objPt, &_imgPt, &_npoints, imageSize,
+ &_cameraMatrix, &_distCoeffs, &_rvecM,
+ &_tvecM, flags );
rvecs.resize(nimages);
tvecs.resize(nimages);
for( i = 0; i < nimages; i++ )
return reprojErr;
}
+
void cv::calibrationMatrixValues( const Mat& cameraMatrix, Size imageSize,
double apertureWidth, double apertureHeight,
double& fovx, double& fovy, double& focalLength,
&matR, &matT, &matE, &matF, criteria, flags );
}
+
void cv::stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
const Mat& cameraMatrix2, const Mat& distCoeffs2,
Size imageSize, const Mat& R, const Mat& T,
}
-float cv::rectify3( const Mat& cameraMatrix1, const Mat& distCoeffs1,
+float cv::rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1,
const Mat& cameraMatrix2, const Mat& distCoeffs2,
const Mat& cameraMatrix3, const Mat& distCoeffs3,
const vector<vector<Point2f> >& imgpt1,
int method, double param1, double param2,
vector<uchar>* mask )
{
- CV_Assert(points1.isContinuous() && points2.isContinuous() &&
- points1.type() == points2.type() &&
- ((points1.rows == 1 && points1.channels() == 2) ||
- points1.cols*points1.channels() == 2) &&
- ((points2.rows == 1 && points2.channels() == 2) ||
- points2.cols*points2.channels() == 2));
+ CV_Assert(points1.checkVector(2) >= 0 && points2.checkVector(2) >= 0 &&
+ (points1.depth() == CV_32F || points1.depth() == CV_32S) &&
+ points1.depth() == points2.depth());
Mat F(3, 3, CV_64F);
CvMat _pt1 = Mat(points1), _pt2 = Mat(points2);
void cv::computeCorrespondEpilines( const Mat& points, int whichImage,
const Mat& F, vector<Vec3f>& lines )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 &&
+ (points.depth() == CV_32F || points.depth() == CV_32S));
lines.resize(points.cols*points.rows*points.channels()/2);
CvMat _points = points, _lines = Mat(lines), matF = F;
void cv::convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst )
{
- CV_Assert(src.isContinuous() &&
- (src.depth() == CV_32S || src.depth() == CV_32F) &&
- ((src.rows == 1 && src.channels() == 2) ||
- src.cols*src.channels() == 2));
+ CV_Assert(src.checkVector(2) >= 0 &&
+ (src.depth() == CV_32F || src.depth() == CV_32S));
dst.resize(src.cols*src.rows*src.channels()/2);
CvMat _src = src, _dst = Mat(dst);
void cv::convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst )
{
- CV_Assert(src.isContinuous() &&
- (src.depth() == CV_32S || src.depth() == CV_32F) &&
- ((src.rows == 1 && src.channels() == 3) ||
- src.cols*src.channels() == 3));
+ CV_Assert(src.checkVector(3) >= 0 &&
+ (src.depth() == CV_32F || src.depth() == CV_32S));
dst.resize(src.cols*src.rows*src.channels()/3);
CvMat _src = Mat(src), _dst = Mat(dst);
exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency();
\endcode
*/
-CV_EXPORTS double getTickFrequency();
+CV_EXPORTS_W double getTickFrequency();
/*!
Returns the number of CPU ticks.
most of the hardware acceleration is disabled and thus the function will returns false,
until you call cv::useOptimized(true)}
*/
-CV_EXPORTS bool checkHardwareSupport(int feature);
+CV_EXPORTS_W bool checkHardwareSupport(int feature);
/*!
Allocates memory buffer
\note{Since optimization may imply using special data structures, it may be unsafe
to call this function anywhere in the code. Instead, call it somewhere at the top level.}
*/
-CV_EXPORTS void setUseOptimized(bool onoff);
+CV_EXPORTS_W void setUseOptimized(bool onoff);
/*!
Returns the current optimization status
The function returns the current optimization status, which is controlled by cv::setUseOptimized().
*/
-CV_EXPORTS bool useOptimized();
+CV_EXPORTS_W bool useOptimized();
/*!
The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree()
//! copies the matrix content to "m".
// It calls m.create(this->size(), this->type()).
void copyTo( Mat& m ) const;
+ template<typename _Tp> void copyTo( vector<_Tp>& v ) const;
//! copies those matrix elements to "m" that are marked with non-zero mask elements.
void copyTo( Mat& m, const Mat& mask ) const;
//! converts matrix to another datatype with optional scalng. See cvConvertScale.
bool empty() const;
//! returns the total number of matrix elements
size_t total() const;
+
+ //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise
+ int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
//! returns pointer to i0-th submatrix along the dimension #0
uchar* ptr(int i0=0);
CV_EXPORTS void insertImageCOI(const Mat& coiimg, CvArr* arr, int coi=-1);
//! adds one matrix to another (dst = src1 + src2)
-CV_EXPORTS void add(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask);
+CV_EXPORTS_W void add(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask CV_WRAP_DEFAULT(Mat()));
//! subtracts one matrix from another (dst = src1 - src2)
-CV_EXPORTS void subtract(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask);
+CV_EXPORTS_W void subtract(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask CV_WRAP_DEFAULT(Mat()));
//! adds one matrix to another (dst = src1 + src2)
CV_EXPORTS void add(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
//! subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS void subtract(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
//! adds scalar to a matrix (dst = src1 + src2)
-CV_EXPORTS void add(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void add(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! subtracts scalar from a matrix (dst = src1 - src2)
-CV_EXPORTS void subtract(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void subtract(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! subtracts matrix from scalar (dst = src1 - src2)
-CV_EXPORTS void subtract(const Scalar& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void subtract(const Scalar& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
-CV_EXPORTS void multiply(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
+CV_EXPORTS_W void multiply(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
//! computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
-CV_EXPORTS void divide(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
+CV_EXPORTS_W void divide(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, double scale=1);
//! computes element-wise weighted reciprocal of an array (dst = scale/src2)
-CV_EXPORTS void divide(double scale, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void divide(double scale, const Mat& src2, CV_OUT Mat& dst);
//! adds scaled array to another one (dst = alpha*src1 + src2)
-CV_EXPORTS void scaleAdd(const Mat& src1, double alpha, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void scaleAdd(const Mat& src1, double alpha, const Mat& src2, CV_OUT Mat& dst);
//! computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
-CV_EXPORTS void addWeighted(const Mat& src1, double alpha, const Mat& src2,
+CV_EXPORTS_W void addWeighted(const Mat& src1, double alpha, const Mat& src2,
double beta, double gamma, CV_OUT Mat& dst);
//! scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)
-CV_EXPORTS void convertScaleAbs(const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0);
+CV_EXPORTS_W void convertScaleAbs(const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0);
//! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
-CV_EXPORTS void LUT(const Mat& src, const Mat& lut, CV_OUT Mat& dst);
+CV_EXPORTS_W void LUT(const Mat& src, const Mat& lut, CV_OUT Mat& dst);
//! computes sum of array elements
-CV_EXPORTS Scalar sum(const Mat& src);
+CV_EXPORTS_W Scalar sum(const Mat& src);
//! computes the number of nonzero array elements
-CV_EXPORTS int countNonZero( const Mat& src );
+CV_EXPORTS_W int countNonZero( const Mat& src );
//! computes mean value of array elements
CV_EXPORTS Scalar mean(const Mat& src);
//! computes mean value of selected array elements
-CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask);
+CV_EXPORTS_W Scalar mean(const Mat& src, const Mat& mask CV_WRAP_DEFAULT(Mat()));
//! computes mean value and standard deviation of all or selected array elements
-CV_EXPORTS void meanStdDev(const Mat& src, CV_OUT Scalar& mean, CV_OUT Scalar& stddev, const Mat& mask=Mat());
+CV_EXPORTS_W void meanStdDev(const Mat& src, CV_OUT Scalar& mean, CV_OUT Scalar& stddev, const Mat& mask=Mat());
//! computes norm of array
-CV_EXPORTS double norm(const Mat& src, int normType=NORM_L2);
+CV_EXPORTS double norm(const Mat& src1, int normType=NORM_L2);
//! computes norm of the difference between two arrays
CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType=NORM_L2);
//! computes norm of the selected array part
-CV_EXPORTS double norm(const Mat& src, int normType, const Mat& mask);
+CV_EXPORTS_W double norm(const Mat& src1, int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
//! computes norm of selected part of the difference between two arrays
-CV_EXPORTS double norm(const Mat& src1, const Mat& src2,
- int normType, const Mat& mask);
+CV_EXPORTS_W double norm(const Mat& src1, const Mat& src2,
+ int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
//! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
-CV_EXPORTS void normalize( const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0,
+CV_EXPORTS_W void normalize( const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0,
int norm_type=NORM_L2, int rtype=-1, const Mat& mask=Mat());
//! finds global minimum and maximum array elements and returns their values and their locations
-CV_EXPORTS void minMaxLoc(const Mat& src, CV_OUT double* minVal,
+CV_EXPORTS_W void minMaxLoc(const Mat& src, CV_OUT double* minVal,
CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0,
CV_OUT Point* maxLoc=0, const Mat& mask=Mat());
-CV_EXPORTS void minMaxIdx(const Mat& src, double* minVal,
- double* maxVal,
- CV_OUT CV_CARRAY(src.dims) int* minIdx=0,
- CV_OUT CV_CARRAY(src.dims) int* maxIdx=0,
- const Mat& mask=Mat());
+CV_EXPORTS void minMaxIdx(const Mat& src, double* minVal, double* maxVal,
+ int* minIdx=0, int* maxIdx=0, const Mat& mask=Mat());
//! transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
-CV_EXPORTS void reduce(const Mat& src, CV_OUT Mat& dst, int dim, int rtype, int dtype=-1);
+CV_EXPORTS_W void reduce(const Mat& src, CV_OUT Mat& dst, int dim, int rtype, int dtype=-1);
//! makes multi-channel array out of several single-channel arrays
-CV_EXPORTS void merge(CV_CARRAY(count) const Mat* mv, size_t count, CV_OUT Mat& dst);
+CV_EXPORTS void merge(const Mat* mv, size_t count, CV_OUT Mat& dst);
//! copies each plane of a multi-channel array to a dedicated array
-CV_EXPORTS void split(const Mat& src, CV_OUT CV_CARRAY(src.channels()) Mat* mvbegin);
+CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
+
+CV_WRAP static inline void merge(const vector<Mat>& mv, Mat& dst)
+{ merge(&mv[0], mv.size(), dst); }
+CV_WRAP static inline void split(const Mat& m, vector<Mat>& mv)
+{
+ mv.resize(m.channels());
+ if(m.channels() > 0)
+ split(m, &mv[0]);
+}
+
//! copies selected channels from the input arrays to the selected channels of the output arrays
-CV_EXPORTS void mixChannels(CV_CARRAY(nsrcs) const Mat* src, size_t nsrcs, CV_CARRAY(ndsts) Mat* dst, size_t ndsts,
- CV_CARRAY(npairs*2) const int* fromTo, size_t npairs);
+CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
+ const int* fromTo, size_t npairs);
+
+static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
+ const int* fromTo, int npairs)
+{
+ mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
+}
+
+
//! reverses the order of the rows, columns or both in a matrix
-CV_EXPORTS void flip(const Mat& src, CV_OUT Mat& dst, int flipCode);
+CV_EXPORTS_W void flip(const Mat& src, CV_OUT Mat& dst, int flipCode);
//! replicates the input matrix the specified number of times in the horizontal and/or vertical direction
-CV_EXPORTS void repeat(const Mat& src, int ny, int nx, CV_OUT Mat& dst);
+CV_EXPORTS_W void repeat(const Mat& src, int ny, int nx, CV_OUT Mat& dst);
static inline Mat repeat(const Mat& src, int ny, int nx)
{
if( nx == 1 && ny == 1 ) return src;
}
//! computes bitwise conjunction of the two arrays (dst = src1 & src2)
-CV_EXPORTS void bitwise_and(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_and(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes bitwise disjunction of the two arrays (dst = src1 | src2)
-CV_EXPORTS void bitwise_or(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_or(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
-CV_EXPORTS void bitwise_xor(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_xor(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes bitwise conjunction of an array and scalar (dst = src1 & src2)
-CV_EXPORTS void bitwise_and(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_and(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes bitwise disjunction of an array and scalar (dst = src1 | src2)
-CV_EXPORTS void bitwise_or(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_or(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! computes bitwise exclusive-or of an array and scalar (dst = src1 ^ src2)
-CV_EXPORTS void bitwise_xor(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
+CV_EXPORTS_W void bitwise_xor(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst, const Mat& mask=Mat());
//! inverts each bit of array (dst = ~src)
-CV_EXPORTS void bitwise_not(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void bitwise_not(const Mat& src, CV_OUT Mat& dst);
//! computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
-CV_EXPORTS void absdiff(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void absdiff(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
//! computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))
-CV_EXPORTS void absdiff(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void absdiff(const Mat& src1, const Scalar& src2, CV_OUT Mat& dst);
//! set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
-CV_EXPORTS void inRange(const Mat& src, const Mat& lowerb,
+CV_EXPORTS_W void inRange(const Mat& src, const Mat& lowerb,
const Mat& upperb, CV_OUT Mat& dst);
//! set mask elements for those array elements which are within the fixed bounding box (dst = lowerb <= src && src < upperb)
-CV_EXPORTS void inRange(const Mat& src, const Scalar& lowerb,
+CV_EXPORTS_W void inRange(const Mat& src, const Scalar& lowerb,
const Scalar& upperb, CV_OUT Mat& dst);
//! compares elements of two arrays (dst = src1 <cmpop> src2)
-CV_EXPORTS void compare(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int cmpop);
+CV_EXPORTS_W void compare(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int cmpop);
//! compares elements of array with scalar (dst = src1 <cmpop> src2)
-CV_EXPORTS void compare(const Mat& src1, double s, CV_OUT Mat& dst, int cmpop);
+CV_EXPORTS_W void compare(const Mat& src1, double s, CV_OUT Mat& dst, int cmpop);
//! computes per-element minimum of two arrays (dst = min(src1, src2))
-CV_EXPORTS void min(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void min(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
//! computes per-element minimum of array and scalar (dst = min(src1, src2))
-CV_EXPORTS void min(const Mat& src1, double src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void min(const Mat& src1, double src2, CV_OUT Mat& dst);
//! computes per-element maximum of two arrays (dst = max(src1, src2))
-CV_EXPORTS void max(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void max(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
//! computes per-element maximum of array and scalar (dst = max(src1, src2))
-CV_EXPORTS void max(const Mat& src1, double src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void max(const Mat& src1, double src2, CV_OUT Mat& dst);
//! computes square root of each matrix element (dst = src**0.5)
-CV_EXPORTS void sqrt(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void sqrt(const Mat& src, CV_OUT Mat& dst);
//! raises the input matrix elements to the specified power (b = a**power)
-CV_EXPORTS void pow(const Mat& src, double power, CV_OUT Mat& dst);
+CV_EXPORTS_W void pow(const Mat& src, double power, CV_OUT Mat& dst);
//! computes exponent of each matrix element (dst = e**src)
-CV_EXPORTS void exp(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void exp(const Mat& src, CV_OUT Mat& dst);
//! computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
-CV_EXPORTS void log(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void log(const Mat& src, CV_OUT Mat& dst);
//! computes cube root of the argument
-CV_EXPORTS float cubeRoot(float val);
+CV_EXPORTS_W float cubeRoot(float val);
//! computes the angle in degrees (0..360) of the vector (x,y)
-CV_EXPORTS float fastAtan2(float y, float x);
+CV_EXPORTS_W float fastAtan2(float y, float x);
//! converts polar coordinates to Cartesian
-CV_EXPORTS void polarToCart(const Mat& magnitude, const Mat& angle,
+CV_EXPORTS_W void polarToCart(const Mat& magnitude, const Mat& angle,
CV_OUT Mat& x, CV_OUT Mat& y, bool angleInDegrees=false);
//! converts Cartesian coordinates to polar
-CV_EXPORTS void cartToPolar(const Mat& x, const Mat& y,
+CV_EXPORTS_W void cartToPolar(const Mat& x, const Mat& y,
CV_OUT Mat& magnitude, CV_OUT Mat& angle,
bool angleInDegrees=false);
//! computes angle (angle(i)) of each (x(i), y(i)) vector
-CV_EXPORTS void phase(const Mat& x, const Mat& y, CV_OUT Mat& angle,
- bool angleInDegrees=false);
+CV_EXPORTS_W void phase(const Mat& x, const Mat& y, CV_OUT Mat& angle,
+ bool angleInDegrees=false);
//! computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
-CV_EXPORTS void magnitude(const Mat& x, const Mat& y, CV_OUT Mat& magnitude);
+CV_EXPORTS_W void magnitude(const Mat& x, const Mat& y, CV_OUT Mat& magnitude);
//! checks that each matrix element is within the specified range.
-CV_EXPORTS bool checkRange(const Mat& a, bool quiet=true, CV_OUT Point* pt=0,
- double minVal=-DBL_MAX, double maxVal=DBL_MAX);
+CV_EXPORTS_W bool checkRange(const Mat& a, bool quiet=true, CV_OUT Point* pt=0,
+ double minVal=-DBL_MAX, double maxVal=DBL_MAX);
//! implements generalized matrix product algorithm GEMM from BLAS
-CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
- const Mat& src3, double gamma, CV_OUT Mat& dst, int flags=0);
+CV_EXPORTS_W void gemm(const Mat& src1, const Mat& src2, double alpha,
+ const Mat& src3, double gamma, CV_OUT Mat& dst, int flags=0);
//! multiplies matrix by its transposition from the left or from the right
-CV_EXPORTS void mulTransposed( const Mat& src, CV_OUT Mat& dst, bool aTa,
- const Mat& delta=Mat(),
- double scale=1, int rtype=-1 );
+CV_EXPORTS_W void mulTransposed( const Mat& src, CV_OUT Mat& dst, bool aTa,
+ const Mat& delta=Mat(),
+ double scale=1, int rtype=-1 );
//! transposes the matrix
-CV_EXPORTS void transpose(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void transpose(const Mat& src, CV_OUT Mat& dst);
//! performs affine transformation of each element of multi-channel input matrix
-CV_EXPORTS void transform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
+CV_EXPORTS_W void transform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
//! performs perspective transformation of each element of multi-channel input matrix
-CV_EXPORTS void perspectiveTransform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
+CV_EXPORTS_W void perspectiveTransform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
//! extends the symmetrical matrix from the lower half or from the upper half
-CV_EXPORTS void completeSymm(Mat& mtx, bool lowerToUpper=false);
+CV_EXPORTS_W void completeSymm(Mat& mtx, bool lowerToUpper=false);
//! initializes scaled identity matrix
-CV_EXPORTS void setIdentity(Mat& mtx, const Scalar& s=Scalar(1));
+CV_EXPORTS_W void setIdentity(Mat& mtx, const Scalar& s=Scalar(1));
//! computes determinant of a square matrix
-CV_EXPORTS double determinant(const Mat& mtx);
+CV_EXPORTS_W double determinant(const Mat& mtx);
//! computes trace of a matrix
-CV_EXPORTS Scalar trace(const Mat& mtx);
+CV_EXPORTS_W Scalar trace(const Mat& mtx);
//! computes inverse or pseudo-inverse matrix
-CV_EXPORTS double invert(const Mat& src, CV_OUT Mat& dst, int flags=DECOMP_LU);
+CV_EXPORTS_W double invert(const Mat& src, CV_OUT Mat& dst, int flags=DECOMP_LU);
//! solves linear system or a least-square problem
-CV_EXPORTS bool solve(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int flags=DECOMP_LU);
+CV_EXPORTS_W bool solve(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int flags=DECOMP_LU);
//! sorts independently each matrix row or each matrix column
-CV_EXPORTS void sort(const Mat& src, CV_OUT Mat& dst, int flags);
+CV_EXPORTS_W void sort(const Mat& src, CV_OUT Mat& dst, int flags);
//! sorts independently each matrix row or each matrix column
-CV_EXPORTS void sortIdx(const Mat& src, CV_OUT Mat& dst, int flags);
+CV_EXPORTS_W void sortIdx(const Mat& src, CV_OUT Mat& dst, int flags);
//! finds real roots of a cubic polynomial
-CV_EXPORTS int solveCubic(const Mat& coeffs, CV_OUT Mat& roots);
+CV_EXPORTS_W int solveCubic(const Mat& coeffs, CV_OUT Mat& roots);
//! finds real and complex roots of a polynomial
-CV_EXPORTS double solvePoly(const Mat& coeffs, CV_OUT Mat& roots, int maxIters=300);
+CV_EXPORTS_W double solvePoly(const Mat& coeffs, CV_OUT Mat& roots, int maxIters=300);
//! finds eigenvalues of a symmetric matrix
CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, int lowindex=-1,
int highindex=-1);
CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, CV_OUT Mat& eigenvectors,
int lowindex=-1, int highindex=-1);
//! computes covariation matrix of a set of samples
-CV_EXPORTS void calcCovarMatrix( CV_CARRAY(nsamples) const Mat* samples, int nsamples,
- CV_OUT Mat& covar, CV_OUT Mat& mean,
+CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
int flags, int ctype=CV_64F);
//! computes covariation matrix of a set of samples
-CV_EXPORTS void calcCovarMatrix( const Mat& samples, CV_OUT Mat& covar, CV_OUT Mat& mean,
+CV_EXPORTS_W void calcCovarMatrix( const Mat& samples, CV_OUT Mat& covar, CV_OUT Mat& mean,
int flags, int ctype=CV_64F);
/*!
}
\endcode
*/
-class CV_EXPORTS PCA
+class CV_EXPORTS_W PCA
{
public:
//! default constructor
- PCA();
+ CV_WRAP PCA();
//! the constructor that performs PCA
- PCA(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
+ CV_WRAP PCA(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
//! operator that performs PCA. The previously stored data, if any, is released
- PCA& operator()(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
+ CV_WRAP_AS(compute) PCA& operator()(const Mat& data, const Mat& mean, int flags, int maxComponents=0);
//! projects vector from the original space to the principal components subspace
Mat project(const Mat& vec) const;
//! projects vector from the original space to the principal components subspace
- void project(const Mat& vec, CV_OUT Mat& result) const;
+ CV_WRAP void project(const Mat& vec, CV_OUT Mat& result) const;
//! reconstructs the original vector from the projection
Mat backProject(const Mat& vec) const;
//! reconstructs the original vector from the projection
- void backProject(const Mat& vec, CV_OUT Mat& result) const;
+ CV_WRAP void backProject(const Mat& vec, CV_OUT Mat& result) const;
- Mat eigenvectors; //!< eigenvectors of the covariation matrix
- Mat eigenvalues; //!< eigenvalues of the covariation matrix
- Mat mean; //!< mean value subtracted before the projection and added after the back projection
+ CV_PROP Mat eigenvectors; //!< eigenvectors of the covariation matrix
+ CV_PROP Mat eigenvalues; //!< eigenvalues of the covariation matrix
+ CV_PROP Mat mean; //!< mean value subtracted before the projection and added after the back projection
};
/*!
SVD& operator ()( const Mat& src, int flags=0 );
//! decomposes matrix and stores the results to user-provided matrices
- static void compute( const Mat& src, CV_OUT Mat& w, CV_OUT Mat& u, CV_OUT Mat& vt, int flags=0 );
+ CV_WRAP_AS(SVDecomp) static void compute( const Mat& src, CV_OUT Mat& w, CV_OUT Mat& u, CV_OUT Mat& vt, int flags=0 );
//! computes singular values of a matrix
- static void compute( const Mat& src, CV_OUT Mat& w, int flags=0 );
+ CV_WRAP_AS(SVDecomp) static void compute( const Mat& src, CV_OUT Mat& w, int flags=0 );
//! performs back substitution
- static void backSubst( const Mat& w, const Mat& u, const Mat& vt,
+ CV_WRAP_AS(SVBackSubst) static void backSubst( const Mat& w, const Mat& u, const Mat& vt,
const Mat& rhs, CV_OUT Mat& dst );
template<typename _Tp, int m, int n, int nm> static void compute( const Matx<_Tp, m, n>& a,
};
//! computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
-CV_EXPORTS double Mahalanobis(const Mat& v1, const Mat& v2, const Mat& icovar);
+CV_EXPORTS_W double Mahalanobis(const Mat& v1, const Mat& v2, const Mat& icovar);
//! a synonym for Mahalanobis
static inline double Mahalonobis(const Mat& v1, const Mat& v2, const Mat& icovar)
{ return Mahalanobis(v1, v2, icovar); }
//! performs forward or inverse 1D or 2D Discrete Fourier Transformation
-CV_EXPORTS void dft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
+CV_EXPORTS_W void dft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
//! performs inverse 1D or 2D Discrete Fourier Transformation
-CV_EXPORTS void idft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
+CV_EXPORTS_W void idft(const Mat& src, CV_OUT Mat& dst, int flags=0, int nonzeroRows=0);
//! performs forward or inverse 1D or 2D Discrete Cosine Transformation
-CV_EXPORTS void dct(const Mat& src, CV_OUT Mat& dst, int flags=0);
+CV_EXPORTS_W void dct(const Mat& src, CV_OUT Mat& dst, int flags=0);
//! performs inverse 1D or 2D Discrete Cosine Transformation
-CV_EXPORTS void idct(const Mat& src, CV_OUT Mat& dst, int flags=0);
+CV_EXPORTS_W void idct(const Mat& src, CV_OUT Mat& dst, int flags=0);
//! computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
-CV_EXPORTS void mulSpectrums(const Mat& a, const Mat& b, CV_OUT Mat& c,
+CV_EXPORTS_W void mulSpectrums(const Mat& a, const Mat& b, CV_OUT Mat& c,
int flags, bool conjB=false);
//! computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
-CV_EXPORTS int getOptimalDFTSize(int vecsize);
+CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
/*!
Various k-Means flags
KMEANS_USE_INITIAL_LABELS=1 // Uses the user-provided labels for K-Means initialization
};
//! clusters the input data using k-Means algorithm
-CV_EXPORTS double kmeans( const Mat& data, int K, CV_OUT Mat& bestLabels,
+CV_EXPORTS_W double kmeans( const Mat& data, int K, CV_OUT Mat& bestLabels,
TermCriteria criteria, int attempts,
int flags, CV_OUT Mat* centers=0 );
template<typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
//! fills array with uniformly-distributed random numbers from the range [low, high)
-static inline void randu(CV_OUT Mat& dst, const Scalar& low, const Scalar& high)
+CV_WRAP static inline void randu(CV_OUT Mat& dst, const Scalar& low, const Scalar& high)
{ theRNG().fill(dst, RNG::UNIFORM, low, high); }
//! fills array with normally-distributed random numbers with the specified mean and the standard deviation
-static inline void randn(CV_OUT Mat& dst, const Scalar& mean, const Scalar& stddev)
+CV_WRAP static inline void randn(CV_OUT Mat& dst, const Scalar& mean, const Scalar& stddev)
{ theRNG().fill(dst, RNG::NORMAL, mean, stddev); }
//! shuffles the input array elements
-CV_EXPORTS void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0);
+CV_EXPORTS_W void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0);
//! draws the line segment (pt1, pt2) in the image
-CV_EXPORTS void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
+CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
int thickness=1, int lineType=8, int shift=0);
//! draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
-CV_EXPORTS void rectangle(Mat& img, Point pt1, Point pt2,
+CV_EXPORTS_W void rectangle(Mat& img, Point pt1, Point pt2,
const Scalar& color, int thickness=1,
int lineType=8, int shift=0);
int lineType=8, int shift=0);
//! draws the circle outline or a solid circle in the image
-CV_EXPORTS void circle(Mat& img, Point center, int radius,
+CV_EXPORTS_W void circle(Mat& img, Point center, int radius,
const Scalar& color, int thickness=1,
int lineType=8, int shift=0);
//! draws an elliptic arc, ellipse sector or a rotated ellipse in the image
-CV_EXPORTS void ellipse(Mat& img, Point center, Size axes,
+CV_EXPORTS_W void ellipse(Mat& img, Point center, Size axes,
double angle, double startAngle, double endAngle,
const Scalar& color, int thickness=1,
int lineType=8, int shift=0);
//! draws a rotated ellipse in the image
-CV_EXPORTS void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
+CV_EXPORTS_W void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
int thickness=1, int lineType=8);
//! draws a filled convex polygon in the image
-CV_EXPORTS void fillConvexPoly(Mat& img, CV_CARRAY(npts) const Point* pts, int npts,
+CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts,
const Scalar& color, int lineType=8,
int shift=0);
//! fills an area bounded by one or more polygons
-CV_EXPORTS void fillPoly(Mat& img, CV_CARRAY(ncontours.npts) const Point** pts,
- CV_CARRAY(ncontours) const int* npts, int ncontours,
+CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
+ const int* npts, int ncontours,
const Scalar& color, int lineType=8, int shift=0,
Point offset=Point() );
//! draws one or more polygonal curves
-CV_EXPORTS void polylines(Mat& img, CV_CARRAY(ncontours.npts) const Point** pts, CV_CARRAY(ncontours) const int* npts,
+CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
int ncontours, bool isClosed, const Scalar& color,
int thickness=1, int lineType=8, int shift=0 );
//! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
-CV_EXPORTS bool clipLine(Size imgSize, Point& pt1, Point& pt2);
+CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
//! clips the line segment by the rectangle imgRect
-CV_EXPORTS bool clipLine(Rect imgRect, Point& pt1, Point& pt2);
+CV_EXPORTS_W bool clipLine(Rect imgRect, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
/*!
Line iterator class
};
//! converts elliptic arc to a polygonal curve
-CV_EXPORTS void ellipse2Poly( Point center, Size axes, int angle,
+CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
int arcStart, int arcEnd, int delta,
CV_OUT vector<Point>& pts );
};
//! renders text string in the image
-CV_EXPORTS void putText( Mat& img, const string& text, Point org,
+CV_EXPORTS_W void putText( Mat& img, const string& text, Point org,
int fontFace, double fontScale, Scalar color,
int thickness=1, int linetype=8,
bool bottomLeftOrigin=false );
//! returns bounding box of the text string
-CV_EXPORTS Size getTextSize(const string& text, int fontFace,
+CV_EXPORTS_W Size getTextSize(const string& text, int fontFace,
double fontScale, int thickness,
CV_OUT int* baseLine);
CV_Assert(dist[0] <= dist[1] && dist[1] <= dist[2]);
\endcode
*/
-class CV_EXPORTS KDTree
+class CV_EXPORTS_W KDTree
{
public:
/*!
};
//! the default constructor
- KDTree();
+ CV_WRAP KDTree();
//! the full constructor that builds the search tree
- KDTree(const Mat& _points, bool copyAndReorderPoints=false);
+ CV_WRAP KDTree(const Mat& _points, bool copyAndReorderPoints=false);
//! builds the search tree
- void build(const Mat& _points, bool copyAndReorderPoints=false);
+ CV_WRAP void build(const Mat& _points, bool copyAndReorderPoints=false);
//! finds the K nearest neighbors of "vec" while looking at Emax (at most) leaves
- int findNearest(const float* vec, int K, int Emax, int* neighborsIdx,
+ int findNearest(const float* vec,
+ int K, int Emax, int* neighborsIdx,
Mat* neighbors=0, float* dist=0) const;
//! finds the K nearest neighbors while looking at Emax (at most) leaves
int findNearest(const float* vec, int K, int Emax,
//! return a vector with the specified index
const float* getPoint(int ptidx) const;
//! returns the search space dimensionality
- int dims() const;
+ CV_WRAP int dims() const;
vector<Node> nodes; //!< all the tree nodes
- Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set.
- int maxDepth; //!< maximum depth of the search tree. Do not modify it
- int normType; //!< type of the distance (cv::NORM_L1 or cv::NORM_L2) used for search. Initially set to cv::NORM_L2, but you can modify it
+ CV_PROP Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set.
+ CV_PROP int maxDepth; //!< maximum depth of the search tree. Do not modify it
+ CV_PROP_RW int normType; //!< type of the distance (cv::NORM_L1 or cv::NORM_L2) used for search. Initially set to cv::NORM_L2, but you can modify it
};
//////////////////////////////////////// XML & YAML I/O ////////////////////////////////////
lbp_val |= ((int)*it) << k;
\endcode
*/
-class CV_EXPORTS FileStorage
+class CV_EXPORTS_W FileStorage
{
public:
//! file storage mode
INSIDE_MAP=4
};
//! the default constructor
- FileStorage();
+ CV_WRAP FileStorage();
//! the full constructor that opens file storage for reading or writing
- FileStorage(const string& filename, int flags);
+ CV_WRAP FileStorage(const string& filename, int flags);
//! the constructor that takes pointer to the C FileStorage structure
FileStorage(CvFileStorage* fs);
//! the destructor. calls release()
virtual ~FileStorage();
//! opens file storage for reading or writing. The previous storage is closed with release()
- virtual bool open(const string& filename, int flags);
+ CV_WRAP virtual bool open(const string& filename, int flags);
//! returns true if the object is associated with currently opened file.
- virtual bool isOpened() const;
+ CV_WRAP virtual bool isOpened() const;
//! closes the file and releases all the memory buffers
- virtual void release();
+ CV_WRAP virtual void release();
//! returns the first element of the top-level mapping
- FileNode getFirstTopLevelNode() const;
+ CV_WRAP FileNode getFirstTopLevelNode() const;
//! returns the top-level mapping. YAML supports multiple streams
- FileNode root(int streamidx=0) const;
+ CV_WRAP FileNode root(int streamidx=0) const;
//! returns the specified element of the top-level mapping
- FileNode operator[](const string& nodename) const;
+ CV_WRAP FileNode operator[](const string& nodename) const;
//! returns the specified element of the top-level mapping
- FileNode operator[](const char* nodename) const;
+ CV_WRAP FileNode operator[](const char* nodename) const;
//! returns pointer to the underlying C FileStorage structure
CvFileStorage* operator *() { return fs; }
void writeObj( const string& name, const void* obj );
//! returns the normalized object name for the specified file name
- static string getDefaultObjectName(const string& filename);
+ CV_WRAP static string getDefaultObjectName(const string& filename);
Ptr<CvFileStorage> fs; //!< the underlying C FileStorage structure
string elname; //!< the currently written element
Note that file nodes are only used for navigating file storages opened for reading.
When a file storage is opened for writing, no data is stored in memory after it is written.
*/
-class CV_EXPORTS FileNode
+class CV_EXPORTS_W FileNode
{
public:
//! type of the file storage node
NAMED=64 //!< the node has a name (i.e. it is element of a mapping)
};
//! the default constructor
- FileNode();
+ CV_WRAP FileNode();
//! the full constructor wrapping CvFileNode structure.
FileNode(const CvFileStorage* fs, const CvFileNode* node);
//! the copy constructor
//! returns element of a mapping node
FileNode operator[](const string& nodename) const;
//! returns element of a mapping node
- FileNode operator[](const char* nodename) const;
+ CV_WRAP FileNode operator[](const char* nodename) const;
//! returns element of a sequence node
- FileNode operator[](int i) const;
+ CV_WRAP FileNode operator[](int i) const;
//! returns type of the node
- int type() const;
+ CV_WRAP int type() const;
- int rawDataSize(const string& fmt) const;
+ CV_WRAP int rawDataSize(const string& fmt) const;
//! returns true if the node is empty
- bool empty() const;
+ CV_WRAP bool empty() const;
//! returns true if the node is a "none" object
- bool isNone() const;
+ CV_WRAP bool isNone() const;
//! returns true if the node is a sequence
- bool isSeq() const;
+ CV_WRAP bool isSeq() const;
//! returns true if the node is a mapping
- bool isMap() const;
+ CV_WRAP bool isMap() const;
//! returns true if the node is an integer
- bool isInt() const;
+ CV_WRAP bool isInt() const;
//! returns true if the node is a floating-point number
- bool isReal() const;
+ CV_WRAP bool isReal() const;
//! returns true if the node is a text string
- bool isString() const;
+ CV_WRAP bool isString() const;
//! returns true if the node has a name
- bool isNamed() const;
+ CV_WRAP bool isNamed() const;
//! returns the node name or an empty string if the node is nameless
- string name() const;
+ CV_WRAP string name() const;
//! returns the number of elements in the node, if it is a sequence or mapping, or 1 otherwise.
- size_t size() const;
+ CV_WRAP size_t size() const;
//! returns the node content as an integer. If the node stores floating-point number, it is rounded.
- operator int() const;
+ CV_WRAP operator int() const;
//! returns the node content as float
- operator float() const;
+ CV_WRAP operator float() const;
//! returns the node content as double
- operator double() const;
+ CV_WRAP operator double() const;
//! returns the node content as text string
- operator string() const;
+ CV_WRAP operator string() const;
//! returns pointer to the underlying file node
CvFileNode* operator *();
return it;
}
-template<typename _Tp> inline Mat::operator vector<_Tp>() const
+
+template<typename _Tp> inline void Mat::copyTo(vector<_Tp>& v) const
{
- if( empty() )
- return vector<_Tp>();
- CV_Assert( dims >= 1 && DataType<_Tp>::channels == channels());
- vector<_Tp> v(total());
- Mat temp(dims, size.p, type(), &v[0]);
+ int n = checkVector(DataType<_Tp>::channels);
+ if( empty() || n == 0 )
+ {
+ v.clear();
+ return;
+ }
+ CV_Assert( n > 0 );
+ v.resize(n);
+ Mat temp(dims, size.p, DataType<_Tp>::type, &v[0]);
convertTo(temp, DataType<_Tp>::type);
+}
+
+template<typename _Tp> inline Mat::operator vector<_Tp>() const
+{
+ vector<_Tp> v;
+ copyTo(v);
return v;
}
template<typename _Tp> inline Mat_<_Tp>::operator vector<_Tp>() const
{
- return this->Mat::operator vector<_Tp>();
+ vector<_Tp> v;
+ copyTo(v);
+ return v;
}
template<typename _Tp> template<int n> inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>() const
CV_Assert(n % DataType<_Tp>::channels == 0);
return this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
}
-
+
template<typename T1, typename T2, typename Op> inline void
process( const Mat_<T1>& m1, Mat_<T2>& m2, Op op )
{
}
/////////////////////////////// Miscellaneous operations //////////////////////////////
-
-static inline void merge(const vector<Mat>& mv, Mat& dst)
-{ merge(&mv[0], mv.size(), dst); }
-
-static inline void split(const Mat& m, vector<Mat>& mv)
-{
- mv.resize(m.channels());
- if(m.channels() > 0)
- split(m, &mv[0]);
-}
template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
{ split(src, (vector<Mat>&)mv ); }
-static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
- const int* fromTo, int npairs)
-{
- mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
-}
-
//////////////////////////////////////////////////////////////
template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols)
//////////////////////////////////////// XML & YAML I/O ////////////////////////////////////
-CV_EXPORTS void write( FileStorage& fs, const string& name, int value );
-CV_EXPORTS void write( FileStorage& fs, const string& name, float value );
-CV_EXPORTS void write( FileStorage& fs, const string& name, double value );
-CV_EXPORTS void write( FileStorage& fs, const string& name, const string& value );
+CV_EXPORTS_W void write( FileStorage& fs, const string& name, int value );
+CV_EXPORTS_W void write( FileStorage& fs, const string& name, float value );
+CV_EXPORTS_W void write( FileStorage& fs, const string& name, double value );
+CV_EXPORTS_W void write( FileStorage& fs, const string& name, const string& value );
template<typename _Tp> inline void write(FileStorage& fs, const _Tp& value)
{ write(fs, string(), value); }
return fs;
}
-CV_EXPORTS void write( FileStorage& fs, const string& name, const Mat& value );
+CV_EXPORTS_W void write( FileStorage& fs, const string& name, const Mat& value );
CV_EXPORTS void write( FileStorage& fs, const string& name, const SparseMat& value );
template<typename _Tp> static inline FileStorage& operator << (FileStorage& fs, const _Tp& value)
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? string(node.node->data.str.ptr) : string("");
}
-CV_EXPORTS void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
+CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
CV_EXPORTS void read(const FileNode& node, SparseMat& mat, const SparseMat& default_mat=SparseMat() );
inline FileNode::operator int() const
/* special informative macros for wrapper generators */
#define CV_CARRAY(counter)
#define CV_CUSTOM_CARRAY(args)
-#define CV_METHOD
-#define CV_NO_WRAP
+#define CV_EXPORTS_W CV_EXPORTS
+#define CV_EXPORTS_AS(synonym) CV_EXPORTS
+#define CV_EXPORTS_AS_MAP CV_EXPORTS
+#define CV_IN_OUT
#define CV_OUT
+#define CV_PROP
+#define CV_PROP_RW
+#define CV_WRAP
#define CV_WRAP_AS(synonym)
+#define CV_WRAP_DEFAULT(value)
/* CvArr* is used to pass arbitrary
* array-like data structures
binarySOpC1_<CmpGE<double> >, 0},
};
- dst.create(src1.rows, src1.cols, CV_8U);
- CV_Assert(src1.channels() == 1);
int depth = src1.depth();
bool invflag = false;
if( src1.dims > 2 )
{
- dst.create(src1.dims, src1.size, CV_8U);
+ dst.create(src1.dims, src1.size, CV_8UC(src1.channels()));
const Mat* arrays[] = {&src1, &dst, 0};
Mat planes[2];
NAryMatIterator it(arrays, planes);
return;
}
+ dst.create(src1.rows, src1.cols, CV_8UC(src1.channels()));
func( src1, dst, value );
if( invflag )
bitwise_not(dst, dst);
if( rows == 1 )
flags |= CONTINUOUS_FLAG;
- if( refcount )
- CV_XADD(refcount, 1);
if( rows <= 0 || cols <= 0 )
{
release();
}
+int Mat::checkVector(int _elemChannels, int _depth, bool _requireContinuous) const
+{
+ return (depth() == _depth || _depth <= 0) &&
+ (isContinuous() || !_requireContinuous) &&
+ ((dims == 2 && (((rows == 1 || cols == 1) && channels() == _elemChannels) || (cols == _elemChannels))) ||
+ (dims == 3 && channels() == 1 && size.p[2] == _elemChannels && (size.p[0] == 1 || size.p[1] == 1) &&
+ (isContinuous() || step.p[1] == step.p[2]*size.p[2])))
+ ? (int)(total()*channels()/_elemChannels) : -1;
+}
+
/*************************************************************************************************\
Matrix Operations
\*************************************************************************************************/
};
//! writes vector of keypoints to the file storage
-CV_EXPORTS void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints);
+CV_EXPORTS_W void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints);
//! reads vector of keypoints from the specified file storage node
-CV_EXPORTS void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);
+CV_EXPORTS_W void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);
/*!
SIFT implementation.
The class implements SURF algorithm by H. Bay et al.
*/
-class CV_EXPORTS SURF : public CvSURFParams
+class CV_EXPORTS_W SURF : public CvSURFParams
{
public:
//! the default constructor
- SURF();
+ CV_WRAP SURF();
//! the full constructor taking all the necessary parameters
- SURF(double _hessianThreshold, int _nOctaves=4,
+ CV_WRAP SURF(double _hessianThreshold, int _nOctaves=4,
int _nOctaveLayers=2, bool _extended=false);
//! returns the descriptor size in float's (64 or 128)
- int descriptorSize() const;
+ CV_WRAP int descriptorSize() const;
//! finds the keypoints using fast hessian detector used in SURF
CV_WRAP_AS(detect) void operator()(const Mat& img, const Mat& mask,
CV_OUT vector<KeyPoint>& keypoints) const;
It returns the regions, each of those is encoded as a contour.
*/
-class CV_EXPORTS MSER : public CvMSERParams
+class CV_EXPORTS_W MSER : public CvMSERParams
{
public:
//! the default constructor
- MSER();
+ CV_WRAP MSER();
//! the full constructor
- MSER( int _delta, int _min_area, int _max_area,
+ CV_WRAP MSER( int _delta, int _min_area, int _max_area,
double _max_variation, double _min_diversity,
int _max_evolution, double _area_threshold,
double _min_margin, int _edge_blur_size );
The class implements the keypoint detector introduced by K. Konolige.
*/
-class CV_EXPORTS StarDetector : public CvStarDetectorParams
+class CV_EXPORTS_W StarDetector : public CvStarDetectorParams
{
public:
//! the default constructor
- StarDetector();
+ CV_WRAP StarDetector();
//! the full constructor
- StarDetector(int _maxSize, int _responseThreshold,
+ CV_WRAP StarDetector(int _maxSize, int _responseThreshold,
int _lineThresholdProjected,
int _lineThresholdBinarized,
int _suppressNonmaxSize);
double _lambdaMin=0.6, double _lambdaMax=1.5,
double _thetaMin=-CV_PI, double _thetaMax=CV_PI,
double _phiMin=-CV_PI, double _phiMax=CV_PI );
- CV_WRAP_AS(generate) void operator()(const Mat& image, Point2f pt, Mat& patch, Size patchSize, RNG& rng) const;
- CV_WRAP_AS(generate) void operator()(const Mat& image, const Mat& transform, Mat& patch,
+ void operator()(const Mat& image, Point2f pt, Mat& patch, Size patchSize, RNG& rng) const;
+ void operator()(const Mat& image, const Mat& transform, Mat& patch,
Size patchSize, RNG& rng) const;
void warpWholeImage(const Mat& image, Mat& matT, Mat& buf,
CV_OUT Mat& warped, int border, RNG& rng) const;
LDetector();
LDetector(int _radius, int _threshold, int _nOctaves,
int _nViews, double _baseFeatureSize, double _clusteringDistance);
- CV_WRAP_AS(detect) void operator()(const Mat& image,
+ void operator()(const Mat& image,
CV_OUT vector<KeyPoint>& keypoints,
int maxCount=0, bool scaleCoords=true) const;
- CV_WRAP_AS(detect) void operator()(const vector<Mat>& pyr,
+ void operator()(const vector<Mat>& pyr,
CV_OUT vector<KeyPoint>& keypoints,
int maxCount=0, bool scaleCoords=true) const;
void getMostStable2D(const Mat& image, CV_OUT vector<KeyPoint>& keypoints,
void read(const FileNode& node);
void write(FileStorage& fs, const String& name=String()) const;
-
CV_WRAP_AS(detect) bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT vector<Point2f>& corners) const;
- CV_WRAP_AS(detect) bool operator()(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
+ bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT vector<Point2f>& corners) const;
+ bool operator()(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
CV_OUT Mat& H, CV_OUT vector<Point2f>& corners,
CV_OUT vector<int>* pairs=0) const;
enum { WINDOW_AUTOSIZE=1 };
-CV_EXPORTS void namedWindow( const string& winname, int flags CV_DEFAULT(WINDOW_AUTOSIZE) );
-CV_EXPORTS void destroyWindow( const string& winname );
-CV_EXPORTS int startWindowThread();
+CV_EXPORTS_W void namedWindow( const string& winname, int flags CV_DEFAULT(WINDOW_AUTOSIZE) );
+CV_EXPORTS_W void destroyWindow( const string& winname );
+CV_EXPORTS_W int startWindowThread();
-CV_EXPORTS void setWindowProperty(const string& winname, int prop_id, double prop_value);//YV
-CV_EXPORTS double getWindowProperty(const string& winname, int prop_id);//YV
+CV_EXPORTS_W void setWindowProperty(const string& winname, int prop_id, double prop_value);//YV
+CV_EXPORTS_W double getWindowProperty(const string& winname, int prop_id);//YV
//Only for Qt
CV_EXPORTS int createButton( const string& bar_name, ButtonCallback on_change , void* userdata CV_DEFAULT(NULL), int type CV_DEFAULT(CV_PUSH_BUTTON), bool initial_button_state CV_DEFAULT(0));
//-------------------------
-CV_EXPORTS void imshow( const string& winname, const Mat& mat );
+CV_EXPORTS_W void imshow( const string& winname, const Mat& mat );
typedef void (CV_CDECL *TrackbarCallback)(int pos, void* userdata);
-CV_EXPORTS int createTrackbar( const string& trackbarname, const string& winname,
+CV_EXPORTS_W int createTrackbar( const string& trackbarname, const string& winname,
int* value, int count,
TrackbarCallback onChange CV_DEFAULT(0),
void* userdata CV_DEFAULT(0));
-CV_EXPORTS int getTrackbarPos( const string& trackbarname, const string& winname );
-CV_EXPORTS void setTrackbarPos( const string& trackbarname, const string& winname, int pos );
+CV_EXPORTS_W int getTrackbarPos( const string& trackbarname, const string& winname );
+CV_EXPORTS_W void setTrackbarPos( const string& trackbarname, const string& winname, int pos );
typedef void (*MouseCallback )(int event, int x, int y, int flags, void* param);
//! assigns callback for mouse events
-CV_EXPORTS void setMouseCallback( const string& windowName, MouseCallback onMouse, void* param=0);
+CV_EXPORTS_W void setMouseCallback( const string& windowName, MouseCallback onMouse, void* param=0);
-CV_EXPORTS Mat imread( const string& filename, int flags=1 );
-CV_EXPORTS bool imwrite( const string& filename, const Mat& img,
+CV_EXPORTS_W Mat imread( const string& filename, int flags=1 );
+CV_EXPORTS_W bool imwrite( const string& filename, const Mat& img,
const vector<int>& params=vector<int>());
-CV_EXPORTS Mat imdecode( const Mat& buf, int flags );
-CV_EXPORTS bool imencode( const string& ext, const Mat& img,
+CV_EXPORTS_W Mat imdecode( const Mat& buf, int flags );
+CV_EXPORTS_W bool imencode( const string& ext, const Mat& img,
CV_OUT vector<uchar>& buf,
const vector<int>& params=vector<int>());
-CV_EXPORTS int waitKey(int delay=0);
+CV_EXPORTS_W int waitKey(int delay=0);
#ifndef CV_NO_VIDEO_CAPTURE_CPP_API
template<> void CV_EXPORTS Ptr<CvCapture>::delete_obj();
template<> void CV_EXPORTS Ptr<CvVideoWriter>::delete_obj();
-class CV_EXPORTS VideoCapture
+class CV_EXPORTS_W VideoCapture
{
public:
- VideoCapture();
- VideoCapture(const string& filename);
- VideoCapture(int device);
+ CV_WRAP VideoCapture();
+ CV_WRAP VideoCapture(const string& filename);
+ CV_WRAP VideoCapture(int device);
virtual ~VideoCapture();
- virtual bool open(const string& filename);
- virtual bool open(int device);
- virtual bool isOpened() const;
- virtual void release();
+ CV_WRAP virtual bool open(const string& filename);
+ CV_WRAP virtual bool open(int device);
+ CV_WRAP virtual bool isOpened() const;
+ CV_WRAP virtual void release();
- virtual bool grab();
- virtual bool retrieve(CV_OUT Mat& image, int channel=0);
- virtual VideoCapture& operator >> (Mat& image);
+ CV_WRAP virtual bool grab();
+ CV_WRAP virtual bool retrieve(CV_OUT Mat& image, int channel=0);
+ CV_WRAP_AS(read) virtual VideoCapture& operator >> (CV_OUT Mat& image);
- virtual bool set(int propId, double value);
- virtual double get(int propId);
+ CV_WRAP virtual bool set(int propId, double value);
+ CV_WRAP virtual double get(int propId);
protected:
Ptr<CvCapture> cap;
};
-class CV_EXPORTS VideoWriter
+class CV_EXPORTS_W VideoWriter
{
public:
- VideoWriter();
- VideoWriter(const string& filename, int fourcc, double fps,
+ CV_WRAP VideoWriter();
+ CV_WRAP VideoWriter(const string& filename, int fourcc, double fps,
Size frameSize, bool isColor=true);
virtual ~VideoWriter();
- virtual bool open(const string& filename, int fourcc, double fps,
+ CV_WRAP virtual bool open(const string& filename, int fourcc, double fps,
Size frameSize, bool isColor=true);
- virtual bool isOpened() const;
- virtual VideoWriter& operator << (const Mat& image);
+ CV_WRAP virtual bool isOpened() const;
+ CV_WRAP_AS(write) virtual VideoWriter& operator << (const Mat& image);
protected:
Ptr<CvVideoWriter> writer;
BORDER_TRANSPARENT, BORDER_DEFAULT=BORDER_REFLECT_101, BORDER_ISOLATED=16 };
//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
-CV_EXPORTS int borderInterpolate( int p, int len, int borderType );
+CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType );
/*!
The Base Class for 1D or Row-wise Filters
int _columnBorderType=-1, const Scalar& _borderValue=Scalar());
//! returns the Gaussian kernel with the specified parameters
-CV_EXPORTS Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
+CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
//! returns the Gaussian filter engine
CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
double sigma1, double sigma2=0,
int borderType=BORDER_DEFAULT);
//! initializes kernels of the generalized Sobel operator
-CV_EXPORTS void getDerivKernels( CV_OUT Mat& kx, CV_OUT Mat& ky,
+CV_EXPORTS_W void getDerivKernels( CV_OUT Mat& kx, CV_OUT Mat& ky,
int dx, int dy, int ksize,
bool normalize=false, int ktype=CV_32F );
//! returns filter engine for the generalized Sobel operator
//! shape of the structuring element
enum { MORPH_RECT=0, MORPH_CROSS=1, MORPH_ELLIPSE=2 };
//! returns structuring element of the specified shape and size
-CV_EXPORTS Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1));
+CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1));
template<> CV_EXPORTS void Ptr<IplConvKernel>::delete_obj();
//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
-CV_EXPORTS void copyMakeBorder( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void copyMakeBorder( const Mat& src, CV_OUT Mat& dst,
int top, int bottom, int left, int right,
int borderType, const Scalar& value=Scalar() );
//! smooths the image using median filter.
-CV_EXPORTS void medianBlur( const Mat& src, CV_OUT Mat& dst, int ksize );
+CV_EXPORTS_W void medianBlur( const Mat& src, CV_OUT Mat& dst, int ksize );
//! smooths the image using Gaussian filter.
-CV_EXPORTS void GaussianBlur( const Mat& src, CV_OUT Mat& dst, Size ksize,
+CV_EXPORTS_W void GaussianBlur( const Mat& src, CV_OUT Mat& dst, Size ksize,
double sigma1, double sigma2=0,
int borderType=BORDER_DEFAULT );
//! smooths the image using bilateral filter
-CV_EXPORTS void bilateralFilter( const Mat& src, CV_OUT Mat& dst, int d,
+CV_EXPORTS_W void bilateralFilter( const Mat& src, CV_OUT Mat& dst, int d,
double sigmaColor, double sigmaSpace,
int borderType=BORDER_DEFAULT );
//! smooths the image using the box filter. Each pixel is processed in O(1) time
-CV_EXPORTS void boxFilter( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void boxFilter( const Mat& src, CV_OUT Mat& dst, int ddepth,
Size ksize, Point anchor=Point(-1,-1),
bool normalize=true,
int borderType=BORDER_DEFAULT );
//! a synonym for normalized box filter
-static inline void blur( const Mat& src, CV_OUT Mat& dst,
+CV_WRAP static inline void blur( const Mat& src, CV_OUT Mat& dst,
Size ksize, Point anchor=Point(-1,-1),
int borderType=BORDER_DEFAULT )
{
}
//! applies non-separable 2D linear filter to the image
-CV_EXPORTS void filter2D( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void filter2D( const Mat& src, CV_OUT Mat& dst, int ddepth,
const Mat& kernel, Point anchor=Point(-1,-1),
double delta=0, int borderType=BORDER_DEFAULT );
//! applies separable 2D linear filter to the image
-CV_EXPORTS void sepFilter2D( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void sepFilter2D( const Mat& src, CV_OUT Mat& dst, int ddepth,
const Mat& kernelX, const Mat& kernelY,
Point anchor=Point(-1,-1),
double delta=0, int borderType=BORDER_DEFAULT );
//! applies generalized Sobel operator to the image
-CV_EXPORTS void Sobel( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void Sobel( const Mat& src, CV_OUT Mat& dst, int ddepth,
int dx, int dy, int ksize=3,
double scale=1, double delta=0,
int borderType=BORDER_DEFAULT );
//! applies the vertical or horizontal Scharr operator to the image
-CV_EXPORTS void Scharr( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void Scharr( const Mat& src, CV_OUT Mat& dst, int ddepth,
int dx, int dy, double scale=1, double delta=0,
int borderType=BORDER_DEFAULT );
//! applies Laplacian operator to the image
-CV_EXPORTS void Laplacian( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void Laplacian( const Mat& src, CV_OUT Mat& dst, int ddepth,
int ksize=1, double scale=1, double delta=0,
int borderType=BORDER_DEFAULT );
//! applies Canny edge detector and produces the edge map.
-CV_EXPORTS void Canny( const Mat& image, CV_OUT Mat& edges,
+CV_EXPORTS_W void Canny( const Mat& image, CV_OUT Mat& edges,
double threshold1, double threshold2,
int apertureSize=3, bool L2gradient=false );
//! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
-CV_EXPORTS void cornerMinEigenVal( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void cornerMinEigenVal( const Mat& src, CV_OUT Mat& dst,
int blockSize, int ksize=3,
int borderType=BORDER_DEFAULT );
//! computes Harris cornerness criteria at each image pixel
-CV_EXPORTS void cornerHarris( const Mat& src, CV_OUT Mat& dst, int blockSize,
+CV_EXPORTS_W void cornerHarris( const Mat& src, CV_OUT Mat& dst, int blockSize,
int ksize, double k,
int borderType=BORDER_DEFAULT );
//! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.
-CV_EXPORTS void cornerEigenValsAndVecs( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void cornerEigenValsAndVecs( const Mat& src, CV_OUT Mat& dst,
int blockSize, int ksize,
int borderType=BORDER_DEFAULT );
//! computes another complex cornerness criteria at each pixel
-CV_EXPORTS void preCornerDetect( const Mat& src, CV_OUT Mat& dst, int ksize,
+CV_EXPORTS_W void preCornerDetect( const Mat& src, CV_OUT Mat& dst, int ksize,
int borderType=BORDER_DEFAULT );
//! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
int minRadius=0, int maxRadius=0 );
//! erodes the image (applies the local minimum operator)
-CV_EXPORTS void erode( const Mat& src, CV_OUT Mat& dst, const Mat& kernel,
+CV_EXPORTS_W void erode( const Mat& src, CV_OUT Mat& dst, const Mat& kernel,
Point anchor=Point(-1,-1), int iterations=1,
int borderType=BORDER_CONSTANT,
const Scalar& borderValue=morphologyDefaultBorderValue() );
//! dilates the image (applies the local maximum operator)
-CV_EXPORTS void dilate( const Mat& src, CV_OUT Mat& dst, const Mat& kernel,
+CV_EXPORTS_W void dilate( const Mat& src, CV_OUT Mat& dst, const Mat& kernel,
Point anchor=Point(-1,-1), int iterations=1,
int borderType=BORDER_CONSTANT,
const Scalar& borderValue=morphologyDefaultBorderValue() );
//! applies an advanced morphological operation to the image
-CV_EXPORTS void morphologyEx( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void morphologyEx( const Mat& src, CV_OUT Mat& dst,
int op, const Mat& kernel,
Point anchor=Point(-1,-1), int iterations=1,
int borderType=BORDER_CONSTANT,
};
//! resizes the image
-CV_EXPORTS void resize( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void resize( const Mat& src, CV_OUT Mat& dst,
Size dsize, double fx=0, double fy=0,
int interpolation=INTER_LINEAR );
//! warps the image using affine transformation
-CV_EXPORTS void warpAffine( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void warpAffine( const Mat& src, CV_OUT Mat& dst,
const Mat& M, Size dsize,
int flags=INTER_LINEAR,
int borderMode=BORDER_CONSTANT,
const Scalar& borderValue=Scalar());
//! warps the image using perspective transformation
-CV_EXPORTS void warpPerspective( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void warpPerspective( const Mat& src, CV_OUT Mat& dst,
const Mat& M, Size dsize,
int flags=INTER_LINEAR,
int borderMode=BORDER_CONSTANT,
INTER_TAB_SIZE2=INTER_TAB_SIZE*INTER_TAB_SIZE };
//! warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
-CV_EXPORTS void remap( const Mat& src, CV_OUT Mat& dst, const Mat& map1, const Mat& map2,
+CV_EXPORTS_W void remap( const Mat& src, CV_OUT Mat& dst, const Mat& map1, const Mat& map2,
int interpolation, int borderMode=BORDER_CONSTANT,
const Scalar& borderValue=Scalar());
//! converts maps for remap from floating-point to fixed-point format or backwards
-CV_EXPORTS void convertMaps( const Mat& map1, const Mat& map2,
+CV_EXPORTS_W void convertMaps( const Mat& map1, const Mat& map2,
CV_OUT Mat& dstmap1, CV_OUT Mat& dstmap2,
int dstmap1type, bool nninterpolation=false );
//! returns 2x3 affine transformation matrix for the planar rotation.
-CV_EXPORTS Mat getRotationMatrix2D( Point2f center, double angle, double scale );
+CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale );
//! returns 3x3 perspective transformation for the corresponding 4 point pairs.
CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );
//! returns 2x3 affine transformation for the corresponding 3 point pairs.
CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
//! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
-CV_EXPORTS void invertAffineTransform( const Mat& M, CV_OUT Mat& iM );
+CV_EXPORTS_W void invertAffineTransform( const Mat& M, CV_OUT Mat& iM );
//! extracts rectangle from the image at sub-pixel location
-CV_EXPORTS void getRectSubPix( const Mat& image, Size patchSize,
+CV_EXPORTS_W void getRectSubPix( const Mat& image, Size patchSize,
Point2f center, CV_OUT Mat& patch, int patchType=-1 );
//! computes the integral image
-CV_EXPORTS void integral( const Mat& src, CV_OUT Mat& sum, int sdepth=-1 );
+CV_EXPORTS_W void integral( const Mat& src, CV_OUT Mat& sum, int sdepth=-1 );
//! computes the integral image and integral for the squared image
-CV_EXPORTS void integral( const Mat& src, CV_OUT Mat& sum, CV_OUT Mat& sqsum, int sdepth=-1 );
+CV_EXPORTS_AS(integral2) void integral( const Mat& src, CV_OUT Mat& sum, CV_OUT Mat& sqsum, int sdepth=-1 );
//! computes the integral image, integral for the squared image and the tilted integral image
-CV_EXPORTS void integral( const Mat& src, CV_OUT Mat& sum, CV_OUT Mat& sqsum, CV_OUT Mat& tilted, int sdepth=-1 );
+CV_EXPORTS_AS(integral3) void integral( const Mat& src, CV_OUT Mat& sum, CV_OUT Mat& sqsum, CV_OUT Mat& tilted, int sdepth=-1 );
//! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
-CV_EXPORTS void accumulate( const Mat& src, CV_OUT Mat& dst, const Mat& mask=Mat() );
+CV_EXPORTS_W void accumulate( const Mat& src, CV_OUT Mat& dst, const Mat& mask=Mat() );
//! adds squared src image to the accumulator (dst += src*src).
-CV_EXPORTS void accumulateSquare( const Mat& src, CV_OUT Mat& dst, const Mat& mask=Mat() );
+CV_EXPORTS_W void accumulateSquare( const Mat& src, CV_OUT Mat& dst, const Mat& mask=Mat() );
//! adds product of the 2 images to the accumulator (dst += src1*src2).
-CV_EXPORTS void accumulateProduct( const Mat& src1, const Mat& src2,
+CV_EXPORTS_W void accumulateProduct( const Mat& src1, const Mat& src2,
CV_OUT Mat& dst, const Mat& mask=Mat() );
//! updates the running average (dst = dst*(1-alpha) + src*alpha)
-CV_EXPORTS void accumulateWeighted( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void accumulateWeighted( const Mat& src, CV_OUT Mat& dst,
double alpha, const Mat& mask=Mat() );
//! type of the threshold operation
THRESH_TOZERO_INV=4, THRESH_MASK=7, THRESH_OTSU=8 };
//! applies fixed threshold to the image
-CV_EXPORTS double threshold( const Mat& src, CV_OUT Mat& dst, double thresh, double maxval, int type );
+CV_EXPORTS_W double threshold( const Mat& src, CV_OUT Mat& dst, double thresh, double maxval, int type );
//! adaptive threshold algorithm
enum { ADAPTIVE_THRESH_MEAN_C=0, ADAPTIVE_THRESH_GAUSSIAN_C=1 };
//! applies variable (adaptive) threshold to the image
-CV_EXPORTS void adaptiveThreshold( const Mat& src, CV_OUT Mat& dst, double maxValue,
+CV_EXPORTS_W void adaptiveThreshold( const Mat& src, CV_OUT Mat& dst, double maxValue,
int adaptiveMethod, int thresholdType,
int blockSize, double C );
//! smooths and downsamples the image
-CV_EXPORTS void pyrDown( const Mat& src, CV_OUT Mat& dst, const Size& dstsize=Size());
+CV_EXPORTS_W void pyrDown( const Mat& src, CV_OUT Mat& dst, const Size& dstsize=Size());
//! upsamples and smoothes the image
-CV_EXPORTS void pyrUp( const Mat& src, CV_OUT Mat& dst, const Size& dstsize=Size());
+CV_EXPORTS_W void pyrUp( const Mat& src, CV_OUT Mat& dst, const Size& dstsize=Size());
//! builds the gaussian pyramid using pyrDown() as a basic operation
CV_EXPORTS void buildPyramid( const Mat& src, CV_OUT vector<Mat>& dst, int maxlevel );
//! corrects lens distortion for the given camera matrix and distortion coefficients
-CV_EXPORTS void undistort( const Mat& src, CV_OUT Mat& dst, const Mat& cameraMatrix,
+CV_EXPORTS_W void undistort( const Mat& src, CV_OUT Mat& dst, const Mat& cameraMatrix,
const Mat& distCoeffs, const Mat& newCameraMatrix=Mat() );
//! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
-CV_EXPORTS void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs,
+CV_EXPORTS_W void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs,
const Mat& R, const Mat& newCameraMatrix,
Size size, int m1type, CV_OUT Mat& map1, CV_OUT Mat& map2 );
};
//! initializes maps for cv::remap() for wide-angle
-CV_EXPORTS float initWideAngleProjMap( const Mat& cameraMatrix, const Mat& distCoeffs,
+CV_EXPORTS_W float initWideAngleProjMap( const Mat& cameraMatrix, const Mat& distCoeffs,
Size imageSize, int destImageWidth,
int m1type, CV_OUT Mat& map1, CV_OUT Mat& map2,
int projType=PROJ_SPHERICAL_EQRECT, double alpha=0);
//! returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
-CV_EXPORTS Mat getDefaultNewCameraMatrix( const Mat& cameraMatrix, Size imgsize=Size(),
+CV_EXPORTS_W Mat getDefaultNewCameraMatrix( const Mat& cameraMatrix, Size imgsize=Size(),
bool centerPrincipalPoint=false );
//! returns points' coordinates after lens distortion correction
CV_EXPORTS void undistortPoints( const Mat& src, CV_OUT vector<Point2f>& dst,
const Mat& cameraMatrix, const Mat& distCoeffs,
const Mat& R=Mat(), const Mat& P=Mat());
//! returns points' coordinates after lens distortion correction
-CV_EXPORTS void undistortPoints( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void undistortPoints( const Mat& src, CV_OUT Mat& dst,
const Mat& cameraMatrix, const Mat& distCoeffs,
const Mat& R=Mat(), const Mat& P=Mat());
template<> CV_EXPORTS void Ptr<CvHistogram>::delete_obj();
//! computes the joint dense histogram for a set of images.
-CV_EXPORTS void calcHist( CV_CARRAY(nimages) const Mat* images, int nimages,
- CV_CARRAY(dims) const int* channels, const Mat& mask,
- CV_OUT Mat& hist, int dims, CV_CARRAY(dims) const int* histSize,
- CV_CUSTOM_CARRAY((dims,histSize,uniform)) const float** ranges,
- bool uniform=true, bool accumulate=false );
+CV_EXPORTS void calcHist( const Mat* images, int nimages,
+ const int* channels, const Mat& mask,
+ Mat& hist, int dims, const int* histSize,
+ const float** ranges, bool uniform=true, bool accumulate=false );
//! computes the joint sparse histogram for a set of images.
-CV_EXPORTS void calcHist( CV_CARRAY(nimages) const Mat* images, int nimages,
- CV_CARRAY(dims) const int* channels, const Mat& mask,
- CV_OUT SparseMat& hist, int dims, CV_CARRAY(dims) const int* histSize,
- CV_CUSTOM_CARRAY((dims,histSize,uniform)) const float** ranges,
+CV_EXPORTS void calcHist( const Mat* images, int nimages,
+ const int* channels, const Mat& mask,
+ SparseMat& hist, int dims,
+ const int* histSize, const float** ranges,
bool uniform=true, bool accumulate=false );
//! computes back projection for the set of images
-CV_EXPORTS void calcBackProject( CV_CARRAY(nimages) const Mat* images, int nimages,
- CV_CARRAY(hist.dims) const int* channels, const Mat& hist,
- CV_OUT Mat& backProject,
- CV_CUSTOM_CARRAY(hist) const float** ranges,
+CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
+ const int* channels, const Mat& hist,
+ Mat& backProject, const float** ranges,
double scale=1, bool uniform=true );
//! computes back projection for the set of images
-CV_EXPORTS void calcBackProject( CV_CARRAY(nimages) const Mat* images, int nimages,
- CV_CARRAY(hist.dims()) const int* channels,
- const SparseMat& hist, CV_OUT Mat& backProject,
- CV_CUSTOM_CARRAY(hist) const float** ranges,
+CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
+ const int* channels, const SparseMat& hist,
+ Mat& backProject, const float** ranges,
double scale=1, bool uniform=true );
//! compares two histograms stored in dense arrays
-CV_EXPORTS double compareHist( const Mat& H1, const Mat& H2, int method );
+CV_EXPORTS_W double compareHist( const Mat& H1, const Mat& H2, int method );
//! compares two histograms stored in sparse arrays
CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
//! normalizes the grayscale image brightness and contrast by normalizing its histogram
-CV_EXPORTS void equalizeHist( const Mat& src, CV_OUT Mat& dst );
+CV_EXPORTS_W void equalizeHist( const Mat& src, CV_OUT Mat& dst );
//! segments the image using watershed algorithm
-CV_EXPORTS void watershed( const Mat& image, Mat& markers );
+CV_EXPORTS_W void watershed( const Mat& image, Mat& markers );
//! filters image using meanshift algorithm
-CV_EXPORTS void pyrMeanShiftFiltering( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void pyrMeanShiftFiltering( const Mat& src, CV_OUT Mat& dst,
double sp, double sr, int maxLevel=1,
TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );
};
//! segments the image using GrabCut algorithm
-CV_EXPORTS void grabCut( const Mat& img, Mat& mask, Rect rect,
+CV_EXPORTS_W void grabCut( const Mat& img, Mat& mask, Rect rect,
Mat& bgdModel, Mat& fgdModel,
int iterCount, int mode = GC_EVAL );
};
//! restores the damaged image areas using one of the available intpainting algorithms
-CV_EXPORTS void inpaint( const Mat& src, const Mat& inpaintMask,
+CV_EXPORTS_W void inpaint( const Mat& src, const Mat& inpaintMask,
CV_OUT Mat& dst, double inpaintRange, int flags );
//! builds the discrete Voronoi diagram
-CV_EXPORTS void distanceTransform( const Mat& src, CV_OUT Mat& dst, Mat& labels,
- int distanceType, int maskSize );
+CV_EXPORTS_AS(distanceTransformWithLabels)
+ void distanceTransform( const Mat& src, CV_OUT Mat& dst, Mat& labels,
+ int distanceType, int maskSize );
//! computes the distance transform map
-CV_EXPORTS void distanceTransform( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void distanceTransform( const Mat& src, CV_OUT Mat& dst,
int distanceType, int maskSize );
enum { FLOODFILL_FIXED_RANGE = 1 << 16,
FLOODFILL_MASK_ONLY = 1 << 17 };
//! fills the semi-uniform image region starting from the specified seed point
-CV_EXPORTS int floodFill( Mat& image,
+CV_EXPORTS_W int floodFill( Mat& image,
Point seedPoint, Scalar newVal, Rect* rect=0,
Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
int flags=4 );
//! fills the semi-uniform image region and/or the mask starting from the specified seed point
-CV_EXPORTS int floodFill( Mat& image, Mat& mask,
+CV_EXPORTS_AS(floodFillMask) int floodFill( Mat& image, Mat& mask,
Point seedPoint, Scalar newVal, Rect* rect=0,
Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
int flags=4 );
//! converts image from one color space to another
-CV_EXPORTS void cvtColor( const Mat& src, CV_OUT Mat& dst, int code, int dstCn=0 );
+CV_EXPORTS_W void cvtColor( const Mat& src, CV_OUT Mat& dst, int code, int dstCn=0 );
//! raster image moments
class CV_EXPORTS Moments
};
//! computes moments of the rasterized shape or a vector of points
-CV_EXPORTS Moments moments( const Mat& array, bool binaryImage=false );
+CV_EXPORTS_W Moments moments( const Mat& array, bool binaryImage=false );
//! computes 7 Hu invariants from the moments
CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 };
//! computes the proximity map for the raster template and the image where the template is searched for
-CV_EXPORTS void matchTemplate( const Mat& image, const Mat& templ, CV_OUT Mat& result, int method );
+CV_EXPORTS_W void matchTemplate( const Mat& image, const Mat& templ, CV_OUT Mat& result, int method );
//! mode of the contour retrieval algorithm
enum
CV_OUT vector<Point2f>& approxCurve,
double epsilon, bool closed );
//! computes the contour perimeter (closed=true) or a curve length
-CV_EXPORTS double arcLength( const Mat& curve, bool closed );
+CV_EXPORTS_W double arcLength( const Mat& curve, bool closed );
//! computes the bounding rectangle for a contour
-CV_EXPORTS Rect boundingRect( const Mat& points );
+CV_EXPORTS_W Rect boundingRect( const Mat& points );
//! computes the contour area
-CV_EXPORTS double contourArea( const Mat& contour, bool oriented=false );
+CV_EXPORTS_W double contourArea( const Mat& contour, bool oriented=false );
//! computes the minimal rotated rectangle for a set of points
-CV_EXPORTS RotatedRect minAreaRect( const Mat& points );
+CV_EXPORTS_W RotatedRect minAreaRect( const Mat& points );
//! computes the minimal enclosing circle for a set of points
-CV_EXPORTS void minEnclosingCircle( const Mat& points,
+CV_EXPORTS_W void minEnclosingCircle( const Mat& points,
Point2f& center, float& radius );
//! matches two contours using one of the available algorithms
-CV_EXPORTS double matchShapes( const Mat& contour1,
+CV_EXPORTS_W double matchShapes( const Mat& contour1,
const Mat& contour2,
int method, double parameter );
//! computes convex hull for a set of 2D points.
CV_EXPORTS void convexHull( const Mat& points, CV_OUT vector<Point2f>& hull, bool clockwise=false );
//! returns true iff the contour is convex. Does not support contours with self-intersection
-CV_EXPORTS bool isContourConvex( const Mat& contour );
+CV_EXPORTS_W bool isContourConvex( const Mat& contour );
//! fits ellipse to the set of 2D points
-CV_EXPORTS RotatedRect fitEllipse( const Mat& points );
+CV_EXPORTS_W RotatedRect fitEllipse( const Mat& points );
//! fits line to the set of 2D points using M-estimator algorithm
CV_EXPORTS void fitLine( const Mat& points, CV_OUT Vec4f& line, int distType,
- double param, double reps, double aeps );
+ double param, double reps, double aeps );
//! fits line to the set of 3D points using M-estimator algorithm
CV_EXPORTS void fitLine( const Mat& points, CV_OUT Vec6f& line, int distType,
- double param, double reps, double aeps );
+ double param, double reps, double aeps );
//! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
-CV_EXPORTS double pointPolygonTest( const Mat& contour,
+CV_EXPORTS_W double pointPolygonTest( const Mat& contour,
Point2f pt, bool measureDist );
//! estimates the best-fit affine transformation that maps one 2D point set to another or one image to another.
-CV_EXPORTS Mat estimateRigidTransform( const Mat& A, const Mat& B,
+CV_EXPORTS_W Mat estimateRigidTransform( const Mat& A, const Mat& B,
bool fullAffine );
//! computes the best-fit affine transformation that maps one 3D point set to another (RANSAC algorithm is used)
CV_EXPORTS int estimateAffine3D(const Mat& from, const Mat& to, CV_OUT Mat& dst,
- vector<uchar>& outliers,
+ CV_OUT vector<uchar>& outliers,
double param1 = 3.0, double param2 = 0.99);
}
-maxLevel : maxLevel, thickness, lineType, offset );
}
+
void cv::approxPolyDP( const Mat& curve, vector<Point>& approxCurve,
double epsilon, bool closed )
{
- CV_Assert(curve.isContinuous() && curve.depth() == CV_32S &&
- ((curve.rows == 1 && curve.channels() == 2) ||
- curve.cols*curve.channels() == 2));
+ CV_Assert(curve.checkVector(2, CV_32S) >= 0);
CvMat _curve = curve;
MemStorage storage(cvCreateMemStorage());
Seq<Point> seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed));
void cv::approxPolyDP( const Mat& curve, vector<Point2f>& approxCurve,
double epsilon, bool closed )
{
- CV_Assert(curve.isContinuous() && curve.depth() == CV_32F &&
- ((curve.rows == 1 && curve.channels() == 2) ||
- curve.cols*curve.channels() == 2));
+ CV_Assert(curve.checkVector(2, CV_32F) >= 0);
CvMat _curve = curve;
MemStorage storage(cvCreateMemStorage());
Seq<Point2f> seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed));
double cv::arcLength( const Mat& curve, bool closed )
{
- CV_Assert(curve.isContinuous() &&
- (curve.depth() == CV_32S || curve.depth() == CV_32F) &&
- ((curve.rows == 1 && curve.channels() == 2) ||
- curve.cols*curve.channels() == 2));
+ CV_Assert(curve.checkVector(2) >= 0 && (curve.depth() == CV_32F || curve.depth() == CV_32S));
CvMat _curve = curve;
return cvArcLength(&_curve, CV_WHOLE_SEQ, closed);
}
cv::Rect cv::boundingRect( const Mat& points )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
return cvBoundingRect(&_points, 0);
}
double cv::contourArea( const Mat& contour, bool oriented )
{
- CV_Assert(contour.isContinuous() &&
- (contour.depth() == CV_32S || contour.depth() == CV_32F) &&
- ((contour.rows == 1 && contour.channels() == 2) ||
- contour.cols*contour.channels() == 2));
+ CV_Assert(contour.checkVector(2) >= 0 && (contour.depth() == CV_32F || contour.depth() == CV_32S));
CvMat _contour = contour;
return cvContourArea(&_contour, CV_WHOLE_SEQ, oriented);
}
cv::RotatedRect cv::minAreaRect( const Mat& points )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
return cvMinAreaRect2(&_points, 0);
}
void cv::minEnclosingCircle( const Mat& points,
Point2f& center, float& radius )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
cvMinEnclosingCircle( &_points, (CvPoint2D32f*)¢er, &radius );
}
const Mat& contour2,
int method, double parameter )
{
- CV_Assert(contour1.isContinuous() && contour2.isContinuous() &&
- (contour1.depth() == CV_32S || contour1.depth() == CV_32F) &&
- contour1.depth() == contour2.depth() &&
- ((contour1.rows == 1 && contour1.channels() == 2 &&
- contour2.rows == 1 && contour2.channels() == 2) ||
- (contour1.cols*contour1.channels() == 2 &&
- contour2.cols*contour2.channels() == 2)));
+ CV_Assert(contour1.checkVector(2) >= 0 && contour2.checkVector(2) >= 0 &&
+ (contour1.depth() == CV_32F || contour1.depth() == CV_32S) &&
+ contour1.depth() == contour2.depth());
CvMat c1 = Mat(contour1), c2 = Mat(contour2);
return cvMatchShapes(&c1, &c2, method, parameter);
void cv::convexHull( const Mat& points, vector<int>& hull, bool clockwise )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
hull.resize(points.cols*points.rows*points.channels()/2);
CvMat _points = Mat(points), _hull=Mat(hull);
cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 0);
void cv::convexHull( const Mat& points,
vector<Point>& hull, bool clockwise )
{
- CV_Assert(points.isContinuous() && points.depth() == CV_32S &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2, CV_32S) >= 0);
hull.resize(points.cols*points.rows*points.channels()/2);
CvMat _points = Mat(points), _hull=Mat(hull);
cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 1);
void cv::convexHull( const Mat& points,
vector<Point2f>& hull, bool clockwise )
{
- CV_Assert(points.isContinuous() && points.depth() == CV_32F &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2, CV_32F) >= 0);
hull.resize(points.cols*points.rows*points.channels()/2);
CvMat _points = Mat(points), _hull=Mat(hull);
cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 1);
bool cv::isContourConvex( const Mat& contour )
{
- CV_Assert(contour.isContinuous() &&
- (contour.depth() == CV_32S || contour.depth() == CV_32F) &&
- ((contour.rows == 1 && contour.channels() == 2) ||
- contour.cols*contour.channels() == 2));
+ CV_Assert(contour.checkVector(2) >= 0 &&
+ (contour.depth() == CV_32F || contour.depth() == CV_32S));
CvMat c = Mat(contour);
return cvCheckContourConvexity(&c) > 0;
}
cv::RotatedRect cv::fitEllipse( const Mat& points )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 &&
+ (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
return cvFitEllipse2(&_points);
}
void cv::fitLine( const Mat& points, Vec4f& line, int distType,
double param, double reps, double aeps )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 2) ||
- points.cols*points.channels() == 2));
+ CV_Assert(points.checkVector(2) >= 0 &&
+ (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
cvFitLine(&_points, distType, param, reps, aeps, &line[0]);
}
void cv::fitLine( const Mat& points, Vec6f& line, int distType,
double param, double reps, double aeps )
{
- CV_Assert(points.isContinuous() &&
- (points.depth() == CV_32S || points.depth() == CV_32F) &&
- ((points.rows == 1 && points.channels() == 3) ||
- points.cols*points.channels() == 3));
+ CV_Assert(points.checkVector(3) >= 0 &&
+ (points.depth() == CV_32F || points.depth() == CV_32S));
CvMat _points = points;
cvFitLine(&_points, distType, param, reps, aeps, &line[0]);
}
double cv::pointPolygonTest( const Mat& contour,
Point2f pt, bool measureDist )
{
- CV_Assert(contour.isContinuous() &&
- (contour.depth() == CV_32S || contour.depth() == CV_32F) &&
- ((contour.rows == 1 && contour.channels() == 2) ||
- contour.cols*contour.channels() == 2));
+ CV_Assert(contour.checkVector(2) >= 0 &&
+ (contour.depth() == CV_32F || contour.depth() == CV_32S));
CvMat c = Mat(contour);
return cvPointPolygonTest( &c, pt, measureDist );
}
#define CV_TRAIN_ERROR 0
#define CV_TEST_ERROR 1
-class CV_EXPORTS CvStatModel
+class CV_EXPORTS_AS(StatModel) CvStatModel
{
public:
CvStatModel();
virtual void clear();
- virtual void save( const char* filename, const char* name=0 ) const;
- virtual void load( const char* filename, const char* name=0 );
+ CV_WRAP virtual void save( const char* filename, const char* name=0 ) const;
+ CV_WRAP virtual void load( const char* filename, const char* name=0 );
virtual void write( CvFileStorage* storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node );
double step;
};
-class CV_EXPORTS CvNormalBayesClassifier : public CvStatModel
+class CV_EXPORTS_AS(NormalBayesClassifier) CvNormalBayesClassifier : public CvStatModel
{
public:
- CvNormalBayesClassifier();
+ CV_WRAP CvNormalBayesClassifier();
virtual ~CvNormalBayesClassifier();
- CV_NO_WRAP CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses,
+ CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses,
const CvMat* _var_idx=0, const CvMat* _sample_idx=0 );
- CV_NO_WRAP virtual bool train( const CvMat* _train_data, const CvMat* _responses,
+ virtual bool train( const CvMat* _train_data, const CvMat* _responses,
const CvMat* _var_idx = 0, const CvMat* _sample_idx=0, bool update=false );
- CV_NO_WRAP virtual float predict( const CvMat* _samples, CvMat* results=0 ) const;
- virtual void clear();
+ virtual float predict( const CvMat* _samples, CV_OUT CvMat* results=0 ) const;
+ CV_WRAP virtual void clear();
- CvNormalBayesClassifier( const cv::Mat& _train_data, const cv::Mat& _responses,
+#ifndef SWIG
+ CV_WRAP CvNormalBayesClassifier( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _var_idx=cv::Mat(), const cv::Mat& _sample_idx=cv::Mat() );
- virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _var_idx = cv::Mat(), const cv::Mat& _sample_idx=cv::Mat(),
bool update=false );
- virtual float predict( const cv::Mat& _samples, cv::Mat* results=0 ) const;
+ CV_WRAP virtual float predict( const cv::Mat& _samples, cv::Mat* results=0 ) const;
+#endif
virtual void write( CvFileStorage* storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node );
\****************************************************************************************/
// k Nearest Neighbors
-class CV_EXPORTS CvKNearest : public CvStatModel
+class CV_EXPORTS_AS(KNearest) CvKNearest : public CvStatModel
{
public:
- CvKNearest();
+ CV_WRAP CvKNearest();
virtual ~CvKNearest();
CvKNearest( const CvMat* _train_data, const CvMat* _responses,
const CvMat* _sample_idx=0, bool is_regression=false,
int _max_k=32, bool _update_base=false );
- virtual float find_nearest( const CvMat* _samples, int k, CvMat* results=0,
- const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const;
+ virtual float find_nearest( const CvMat* _samples, int k, CV_OUT CvMat* results=0,
+ const float** neighbors=0, CV_OUT CvMat* neighbor_responses=0, CV_OUT CvMat* dist=0 ) const;
#ifndef SWIG
- CvKNearest( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP CvKNearest( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _sample_idx=cv::Mat(), bool _is_regression=false, int max_k=32 );
- virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _sample_idx=cv::Mat(), bool is_regression=false,
int _max_k=32, bool _update_base=false );
- virtual float find_nearest( const cv::Mat& _samples, int k, cv::Mat* results=0,
+ CV_WRAP virtual float find_nearest( const cv::Mat& _samples, int k, cv::Mat* results=0,
const float** neighbors=0,
cv::Mat* neighbor_responses=0,
cv::Mat* dist=0 ) const;
\****************************************************************************************/
// SVM training parameters
-struct CV_EXPORTS CvSVMParams
+struct CV_EXPORTS_AS_MAP CvSVMParams
{
CvSVMParams();
CvSVMParams( int _svm_type, int _kernel_type,
// SVM model
-class CV_EXPORTS CvSVM : public CvStatModel
+class CV_EXPORTS_AS(SVM) CvSVM : public CvStatModel
{
public:
// SVM type
// SVM params type
enum { C=0, GAMMA=1, P=2, NU=3, COEF=4, DEGREE=5 };
- CvSVM();
+ CV_WRAP CvSVM();
virtual ~CvSVM();
CvSVM( const CvMat* _train_data, const CvMat* _responses,
virtual float predict( const CvMat* _sample, bool returnDFVal=false ) const;
#ifndef SWIG
- CvSVM( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP CvSVM( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _var_idx=cv::Mat(), const cv::Mat& _sample_idx=cv::Mat(),
CvSVMParams _params=CvSVMParams() );
- virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _var_idx=cv::Mat(), const cv::Mat& _sample_idx=cv::Mat(),
CvSVMParams _params=CvSVMParams() );
- virtual bool train_auto( const cv::Mat& _train_data, const cv::Mat& _responses,
+ CV_WRAP virtual bool train_auto( const cv::Mat& _train_data, const cv::Mat& _responses,
const cv::Mat& _var_idx, const cv::Mat& _sample_idx, CvSVMParams _params,
int k_fold = 10,
CvParamGrid C_grid = get_default_grid(CvSVM::C),
CvParamGrid nu_grid = get_default_grid(CvSVM::NU),
CvParamGrid coef_grid = get_default_grid(CvSVM::COEF),
CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) );
- virtual float predict( const cv::Mat& _sample, bool returnDFVal=false ) const;
+ CV_WRAP virtual float predict( const cv::Mat& _sample, bool returnDFVal=false ) const;
#endif
- virtual int get_support_vector_count() const;
+ CV_WRAP virtual int get_support_vector_count() const;
virtual const float* get_support_vector(int i) const;
- virtual CvSVMParams get_params() const { return params; };
- virtual void clear();
+ CV_WRAP virtual CvSVMParams get_params() const { return params; };
+ CV_WRAP virtual void clear();
static CvParamGrid get_default_grid( int param_id );
virtual void write( CvFileStorage* storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node );
- int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
+ CV_WRAP int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
protected:
* Expectation - Maximization *
\****************************************************************************************/
-struct CV_EXPORTS CvEMParams
+struct CV_EXPORTS_AS_MAP CvEMParams
{
CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/),
start_step(0/*CvEM::START_AUTO_STEP*/), probs(0), weights(0), means(0), covs(0)
};
-class CV_EXPORTS CvEM : public CvStatModel
+class CV_EXPORTS_AS(EM) CvEM : public CvStatModel
{
public:
// Type of covariation matrices
// The initial step
enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 };
- CvEM();
+ CV_WRAP CvEM();
CvEM( const CvMat* samples, const CvMat* sample_idx=0,
CvEMParams params=CvEMParams(), CvMat* labels=0 );
- //CvEM (CvEMParams params, CvMat * means, CvMat ** covs, CvMat * weights, CvMat * probs, CvMat * log_weight_div_det, CvMat * inv_eigen_values, CvMat** cov_rotate_mats);
+ //CvEM (CvEMParams params, CvMat * means, CvMat ** covs, CvMat * weights,
+ // CvMat * probs, CvMat * log_weight_div_det, CvMat * inv_eigen_values, CvMat** cov_rotate_mats);
virtual ~CvEM();
virtual bool train( const CvMat* samples, const CvMat* sample_idx=0,
CvEMParams params=CvEMParams(), CvMat* labels=0 );
- virtual float predict( const CvMat* sample, CvMat* probs ) const;
+ virtual float predict( const CvMat* sample, CV_OUT CvMat* probs ) const;
#ifndef SWIG
- CvEM( const cv::Mat& samples, const cv::Mat& sample_idx=cv::Mat(),
+ CV_WRAP CvEM( const cv::Mat& samples, const cv::Mat& sample_idx=cv::Mat(),
CvEMParams params=CvEMParams(), cv::Mat* labels=0 );
- virtual bool train( const cv::Mat& samples, const cv::Mat& sample_idx=cv::Mat(),
+ CV_WRAP virtual bool train( const cv::Mat& samples, const cv::Mat& sample_idx=cv::Mat(),
CvEMParams params=CvEMParams(), cv::Mat* labels=0 );
- virtual float predict( const cv::Mat& sample, cv::Mat* probs ) const;
+ CV_WRAP virtual float predict( const cv::Mat& sample, cv::Mat* probs ) const;
#endif
- virtual void clear();
+ CV_WRAP virtual void clear();
- int get_nclusters() const;
- const CvMat* get_means() const;
- const CvMat** get_covs() const;
- const CvMat* get_weights() const;
- const CvMat* get_probs() const;
+ CV_WRAP int get_nclusters() const;
+ CV_WRAP const CvMat* get_means() const;
+ CV_WRAP const CvMat** get_covs() const;
+ CV_WRAP const CvMat* get_weights() const;
+ CV_WRAP const CvMat* get_probs() const;
- inline double get_log_likelihood () const { return log_likelihood; };
+ CV_WRAP inline double get_log_likelihood () const { return log_likelihood; };
// inline const CvMat * get_log_weight_div_det () const { return log_weight_div_det; };
// inline const CvMat * get_inv_eigen_values () const { return inv_eigen_values; };
};
-struct CV_EXPORTS CvDTreeParams
+struct CV_EXPORTS_AS_MAP CvDTreeParams
{
int max_categories;
int max_depth;
struct ForestTreeBestSplitFinder;
}
-class CV_EXPORTS CvDTree : public CvStatModel
+class CV_EXPORTS_AS(DTree) CvDTree : public CvStatModel
{
public:
- CvDTree();
+ CV_WRAP CvDTree();
virtual ~CvDTree();
virtual bool train( const CvMat* _train_data, int _tflag,
bool preprocessed_input=false ) const;
#ifndef SWIG
- virtual bool train( const cv::Mat& _train_data, int _tflag,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, int _tflag,
const cv::Mat& _responses, const cv::Mat& _var_idx=cv::Mat(),
const cv::Mat& _sample_idx=cv::Mat(), const cv::Mat& _var_type=cv::Mat(),
const cv::Mat& _missing_mask=cv::Mat(),
CvDTreeParams params=CvDTreeParams() );
- virtual CvDTreeNode* predict( const cv::Mat& _sample, const cv::Mat& _missing_data_mask=cv::Mat(),
+ CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& _sample, const cv::Mat& _missing_data_mask=cv::Mat(),
bool preprocessed_input=false ) const;
#endif
- virtual const CvMat* get_var_importance();
- virtual void clear();
+ CV_WRAP virtual const CvMat* get_var_importance();
+ CV_WRAP virtual void clear();
virtual void read( CvFileStorage* fs, CvFileNode* node );
virtual void write( CvFileStorage* fs, const char* name ) const;
};
-struct CV_EXPORTS CvRTParams : public CvDTreeParams
+struct CV_EXPORTS_AS_MAP CvRTParams : public CvDTreeParams
{
//Parameters for the forest
bool calc_var_importance; // true <=> RF processes variable importance
};
-class CV_EXPORTS CvRTrees : public CvStatModel
+class CV_EXPORTS_AS(RTrees) CvRTrees : public CvStatModel
{
public:
- CvRTrees();
+ CV_WRAP CvRTrees();
virtual ~CvRTrees();
virtual bool train( const CvMat* _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0,
virtual float predict_prob( const CvMat* sample, const CvMat* missing = 0 ) const;
#ifndef SWIG
- virtual bool train( const cv::Mat& _train_data, int _tflag,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, int _tflag,
const cv::Mat& _responses, const cv::Mat& _var_idx=cv::Mat(),
const cv::Mat& _sample_idx=cv::Mat(), const cv::Mat& _var_type=cv::Mat(),
const cv::Mat& _missing_mask=cv::Mat(),
CvRTParams params=CvRTParams() );
- virtual float predict( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
- virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
+ CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
+ CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
#endif
- virtual void clear();
+ CV_WRAP virtual void clear();
- virtual const CvMat* get_var_importance();
+ CV_WRAP virtual const CvMat* get_var_importance();
virtual float get_proximity( const CvMat* sample1, const CvMat* sample2,
const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const;
virtual void split_node_data( CvDTreeNode* n );
};
-class CV_EXPORTS CvERTrees : public CvRTrees
+class CV_EXPORTS_AS(ERTrees) CvERTrees : public CvRTrees
{
public:
- CvERTrees();
+ CV_WRAP CvERTrees();
virtual ~CvERTrees();
virtual bool train( const CvMat* _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0,
const CvMat* _missing_mask=0,
CvRTParams params=CvRTParams());
#ifndef SWIG
- virtual bool train( const cv::Mat& _train_data, int _tflag,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, int _tflag,
const cv::Mat& _responses, const cv::Mat& _var_idx=cv::Mat(),
const cv::Mat& _sample_idx=cv::Mat(), const cv::Mat& _var_type=cv::Mat(),
const cv::Mat& _missing_mask=cv::Mat(),
* Boosted tree classifier *
\****************************************************************************************/
-struct CV_EXPORTS CvBoostParams : public CvDTreeParams
+struct CV_EXPORTS_AS_MAP CvBoostParams : public CvDTreeParams
{
int boost_type;
int weak_count;
};
-class CV_EXPORTS CvBoost : public CvStatModel
+class CV_EXPORTS_AS(Boost) CvBoost : public CvStatModel
{
public:
// Boosting type
// Splitting criteria
enum { DEFAULT=0, GINI=1, MISCLASS=3, SQERR=4 };
- CvBoost();
+ CV_WRAP CvBoost();
virtual ~CvBoost();
CvBoost( const CvMat* _train_data, int _tflag,
bool raw_mode=false, bool return_sum=false ) const;
#ifndef SWIG
- CvBoost( const cv::Mat& _train_data, int _tflag,
+ CV_WRAP CvBoost( const cv::Mat& _train_data, int _tflag,
const cv::Mat& _responses, const cv::Mat& _var_idx=cv::Mat(),
const cv::Mat& _sample_idx=cv::Mat(), const cv::Mat& _var_type=cv::Mat(),
const cv::Mat& _missing_mask=cv::Mat(),
CvBoostParams params=CvBoostParams() );
- virtual bool train( const cv::Mat& _train_data, int _tflag,
+ CV_WRAP virtual bool train( const cv::Mat& _train_data, int _tflag,
const cv::Mat& _responses, const cv::Mat& _var_idx=cv::Mat(),
const cv::Mat& _sample_idx=cv::Mat(), const cv::Mat& _var_type=cv::Mat(),
const cv::Mat& _missing_mask=cv::Mat(),
CvBoostParams params=CvBoostParams(),
bool update=false );
- virtual float predict( const cv::Mat& _sample, const cv::Mat& _missing=cv::Mat(),
+ CV_WRAP virtual float predict( const cv::Mat& _sample, const cv::Mat& _missing=cv::Mat(),
cv::Mat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
bool raw_mode=false, bool return_sum=false ) const;
#endif
virtual float calc_error( CvMLData* _data, int type , std::vector<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
- virtual void prune( CvSlice slice );
+ CV_WRAP virtual void prune( CvSlice slice );
- virtual void clear();
+ CV_WRAP virtual void clear();
virtual void write( CvFileStorage* storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node );
// Each tree prediction is multiplied on shrinkage value.
-struct CV_EXPORTS CvGBTreesParams : public CvDTreeParams
+struct CV_EXPORTS_AS_MAP CvGBTreesParams : public CvDTreeParams
{
int weak_count;
int loss_function_type;
-class CV_EXPORTS CvGBTrees : public CvStatModel
+class CV_EXPORTS_AS(GBTrees) CvGBTrees : public CvStatModel
{
public:
// OUTPUT
// RESULT
*/
- CvGBTrees();
+ CV_WRAP CvGBTrees();
/*
// OUTPUT
// RESULT
*/
- CvGBTrees( const CvMat* _train_data, int _tflag,
+ CV_WRAP CvGBTrees( const CvMat* _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0,
const CvMat* _sample_idx=0, const CvMat* _var_type=0,
const CvMat* _missing_mask=0,
// RESULT
// Error state.
*/
- virtual bool train( const CvMat* _train_data, int _tflag,
+ CV_WRAP virtual bool train( const CvMat* _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0,
const CvMat* _sample_idx=0, const CvMat* _var_type=0,
const CvMat* _missing_mask=0,
// RESULT
// Predicted value.
*/
- virtual float predict( const CvMat* _sample, const CvMat* _missing=0,
+ CV_WRAP virtual float predict( const CvMat* _sample, const CvMat* _missing=0,
CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
int k=-1 ) const;
// delta = 0.0
// RESULT
*/
- virtual void clear();
+ CV_WRAP virtual void clear();
/*
// Compute error on the train/test set.
/////////////////////////////////// Multi-Layer Perceptrons //////////////////////////////
-struct CV_EXPORTS CvANN_MLP_TrainParams
+struct CV_EXPORTS_AS_MAP CvANN_MLP_TrainParams
{
CvANN_MLP_TrainParams();
CvANN_MLP_TrainParams( CvTermCriteria term_crit, int train_method,
};
-class CV_EXPORTS CvANN_MLP : public CvStatModel
+class CV_EXPORTS_AS(ANN_MLP) CvANN_MLP : public CvStatModel
{
public:
- CvANN_MLP();
+ CV_WRAP CvANN_MLP();
CvANN_MLP( const CvMat* _layer_sizes,
int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
const CvMat* _sample_weights, const CvMat* _sample_idx=0,
CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(),
int flags=0 );
- virtual float predict( const CvMat* _inputs, CvMat* _outputs ) const;
+ virtual float predict( const CvMat* _inputs, CV_OUT CvMat* _outputs ) const;
#ifndef SWIG
- CvANN_MLP( const cv::Mat& _layer_sizes,
+ CV_WRAP CvANN_MLP( const cv::Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
- virtual void create( const cv::Mat& _layer_sizes,
+ CV_WRAP virtual void create( const cv::Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
- virtual int train( const cv::Mat& _inputs, const cv::Mat& _outputs,
+ CV_WRAP virtual int train( const cv::Mat& _inputs, const cv::Mat& _outputs,
const cv::Mat& _sample_weights, const cv::Mat& _sample_idx=cv::Mat(),
CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(),
int flags=0 );
- virtual float predict( const cv::Mat& _inputs, cv::Mat& _outputs ) const;
+ CV_WRAP virtual float predict( const cv::Mat& _inputs, cv::Mat& _outputs ) const;
#endif
- virtual void clear();
+ CV_WRAP virtual void clear();
// possible activation functions
enum { IDENTITY = 0, SIGMOID_SYM = 1, GAUSSIAN = 2 };
CvRNG rng;
};
-#if 0
-/****************************************************************************************\
-* Convolutional Neural Network *
-\****************************************************************************************/
-typedef struct CvCNNLayer CvCNNLayer;
-typedef struct CvCNNetwork CvCNNetwork;
-
-#define CV_CNN_LEARN_RATE_DECREASE_HYPERBOLICALLY 1
-#define CV_CNN_LEARN_RATE_DECREASE_SQRT_INV 2
-#define CV_CNN_LEARN_RATE_DECREASE_LOG_INV 3
-
-#define CV_CNN_GRAD_ESTIM_RANDOM 0
-#define CV_CNN_GRAD_ESTIM_BY_WORST_IMG 1
-
-#define ICV_CNN_LAYER 0x55550000
-#define ICV_CNN_CONVOLUTION_LAYER 0x00001111
-#define ICV_CNN_SUBSAMPLING_LAYER 0x00002222
-#define ICV_CNN_FULLCONNECT_LAYER 0x00003333
-
-#define ICV_IS_CNN_LAYER( layer ) \
- ( ((layer) != NULL) && ((((CvCNNLayer*)(layer))->flags & CV_MAGIC_MASK)\
- == ICV_CNN_LAYER ))
-
-#define ICV_IS_CNN_CONVOLUTION_LAYER( layer ) \
- ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
- & ~CV_MAGIC_MASK) == ICV_CNN_CONVOLUTION_LAYER )
-
-#define ICV_IS_CNN_SUBSAMPLING_LAYER( layer ) \
- ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
- & ~CV_MAGIC_MASK) == ICV_CNN_SUBSAMPLING_LAYER )
-
-#define ICV_IS_CNN_FULLCONNECT_LAYER( layer ) \
- ( (ICV_IS_CNN_LAYER( layer )) && (((CvCNNLayer*) (layer))->flags \
- & ~CV_MAGIC_MASK) == ICV_CNN_FULLCONNECT_LAYER )
-
-typedef void (CV_CDECL *CvCNNLayerForward)
- ( CvCNNLayer* layer, const CvMat* input, CvMat* output );
-
-typedef void (CV_CDECL *CvCNNLayerBackward)
- ( CvCNNLayer* layer, int t, const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX );
-
-typedef void (CV_CDECL *CvCNNLayerRelease)
- (CvCNNLayer** layer);
-
-typedef void (CV_CDECL *CvCNNetworkAddLayer)
- (CvCNNetwork* network, CvCNNLayer* layer);
-
-typedef void (CV_CDECL *CvCNNetworkRelease)
- (CvCNNetwork** network);
-
-#define CV_CNN_LAYER_FIELDS() \
- /* Indicator of the layer's type */ \
- int flags; \
- \
- /* Number of input images */ \
- int n_input_planes; \
- /* Height of each input image */ \
- int input_height; \
- /* Width of each input image */ \
- int input_width; \
- \
- /* Number of output images */ \
- int n_output_planes; \
- /* Height of each output image */ \
- int output_height; \
- /* Width of each output image */ \
- int output_width; \
- \
- /* Learning rate at the first iteration */ \
- float init_learn_rate; \
- /* Dynamics of learning rate decreasing */ \
- int learn_rate_decrease_type; \
- /* Trainable weights of the layer (including bias) */ \
- /* i-th row is a set of weights of the i-th output plane */ \
- CvMat* weights; \
- \
- CvCNNLayerForward forward; \
- CvCNNLayerBackward backward; \
- CvCNNLayerRelease release; \
- /* Pointers to the previous and next layers in the network */ \
- CvCNNLayer* prev_layer; \
- CvCNNLayer* next_layer
-
-typedef struct CvCNNLayer
-{
- CV_CNN_LAYER_FIELDS();
-}CvCNNLayer;
-
-typedef struct CvCNNConvolutionLayer
-{
- CV_CNN_LAYER_FIELDS();
- // Kernel size (height and width) for convolution.
- int K;
- // connections matrix, (i,j)-th element is 1 iff there is a connection between
- // i-th plane of the current layer and j-th plane of the previous layer;
- // (i,j)-th element is equal to 0 otherwise
- CvMat *connect_mask;
- // value of the learning rate for updating weights at the first iteration
-}CvCNNConvolutionLayer;
-
-typedef struct CvCNNSubSamplingLayer
-{
- CV_CNN_LAYER_FIELDS();
- // ratio between the heights (or widths - ratios are supposed to be equal)
- // of the input and output planes
- int sub_samp_scale;
- // amplitude of sigmoid activation function
- float a;
- // scale parameter of sigmoid activation function
- float s;
- // exp2ssumWX = exp(2<s>*(bias+w*(x1+...+x4))), where x1,...x4 are some elements of X
- // - is the vector used in computing of the activation function in backward
- CvMat* exp2ssumWX;
- // (x1+x2+x3+x4), where x1,...x4 are some elements of X
- // - is the vector used in computing of the activation function in backward
- CvMat* sumX;
-}CvCNNSubSamplingLayer;
-
-// Structure of the last layer.
-typedef struct CvCNNFullConnectLayer
-{
- CV_CNN_LAYER_FIELDS();
- // amplitude of sigmoid activation function
- float a;
- // scale parameter of sigmoid activation function
- float s;
- // exp2ssumWX = exp(2*<s>*(W*X)) - is the vector used in computing of the
- // activation function and it's derivative by the formulae
- // activ.func. = <a>(exp(2<s>WX)-1)/(exp(2<s>WX)+1) == <a> - 2<a>/(<exp2ssumWX> + 1)
- // (activ.func.)' = 4<a><s>exp(2<s>WX)/(exp(2<s>WX)+1)^2
- CvMat* exp2ssumWX;
-}CvCNNFullConnectLayer;
-
-typedef struct CvCNNetwork
-{
- int n_layers;
- CvCNNLayer* layers;
- CvCNNetworkAddLayer add_layer;
- CvCNNetworkRelease release;
-}CvCNNetwork;
-
-typedef struct CvCNNStatModel
-{
- CV_STAT_MODEL_FIELDS();
- CvCNNetwork* network;
- // etalons are allocated as rows, the i-th etalon has label cls_labeles[i]
- CvMat* etalons;
- // classes labels
- CvMat* cls_labels;
-}CvCNNStatModel;
-
-typedef struct CvCNNStatModelParams
-{
- CV_STAT_MODEL_PARAM_FIELDS();
- // network must be created by the functions cvCreateCNNetwork and <add_layer>
- CvCNNetwork* network;
- CvMat* etalons;
- // termination criteria
- int max_iter;
- int start_iter;
- int grad_estim_type;
-}CvCNNStatModelParams;
-
-CVAPI(CvCNNLayer*) cvCreateCNNConvolutionLayer(
- int n_input_planes, int input_height, int input_width,
- int n_output_planes, int K,
- float init_learn_rate, int learn_rate_decrease_type,
- CvMat* connect_mask CV_DEFAULT(0), CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNLayer*) cvCreateCNNSubSamplingLayer(
- int n_input_planes, int input_height, int input_width,
- int sub_samp_scale, float a, float s,
- float init_learn_rate, int learn_rate_decrease_type, CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNLayer*) cvCreateCNNFullConnectLayer(
- int n_inputs, int n_outputs, float a, float s,
- float init_learn_rate, int learning_type, CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNetwork*) cvCreateCNNetwork( CvCNNLayer* first_layer );
-
-CVAPI(CvStatModel*) cvTrainCNNClassifier(
- const CvMat* train_data, int tflag,
- const CvMat* responses,
- const CvStatModelParams* params,
- const CvMat* CV_DEFAULT(0),
- const CvMat* sample_idx CV_DEFAULT(0),
- const CvMat* CV_DEFAULT(0), const CvMat* CV_DEFAULT(0) );
-
-/****************************************************************************************\
-* Estimate classifiers algorithms *
-\****************************************************************************************/
-typedef const CvMat* (CV_CDECL *CvStatModelEstimateGetMat)
- ( const CvStatModel* estimateModel );
-
-typedef int (CV_CDECL *CvStatModelEstimateNextStep)
- ( CvStatModel* estimateModel );
-
-typedef void (CV_CDECL *CvStatModelEstimateCheckClassifier)
- ( CvStatModel* estimateModel,
- const CvStatModel* model,
- const CvMat* features,
- int sample_t_flag,
- const CvMat* responses );
-
-typedef void (CV_CDECL *CvStatModelEstimateCheckClassifierEasy)
- ( CvStatModel* estimateModel,
- const CvStatModel* model );
-
-typedef float (CV_CDECL *CvStatModelEstimateGetCurrentResult)
- ( const CvStatModel* estimateModel,
- float* correlation );
-
-typedef void (CV_CDECL *CvStatModelEstimateReset)
- ( CvStatModel* estimateModel );
-
-//-------------------------------- Cross-validation --------------------------------------
-#define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS() \
- CV_STAT_MODEL_PARAM_FIELDS(); \
- int k_fold; \
- int is_regression; \
- CvRNG* rng
-
-typedef struct CvCrossValidationParams
-{
- CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS();
-} CvCrossValidationParams;
-
-#define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS() \
- CvStatModelEstimateGetMat getTrainIdxMat; \
- CvStatModelEstimateGetMat getCheckIdxMat; \
- CvStatModelEstimateNextStep nextStep; \
- CvStatModelEstimateCheckClassifier check; \
- CvStatModelEstimateGetCurrentResult getResult; \
- CvStatModelEstimateReset reset; \
- int is_regression; \
- int folds_all; \
- int samples_all; \
- int* sampleIdxAll; \
- int* folds; \
- int max_fold_size; \
- int current_fold; \
- int is_checked; \
- CvMat* sampleIdxTrain; \
- CvMat* sampleIdxEval; \
- CvMat* predict_results; \
- int correct_results; \
- int all_results; \
- double sq_error; \
- double sum_correct; \
- double sum_predict; \
- double sum_cc; \
- double sum_pp; \
- double sum_cp
-
-typedef struct CvCrossValidationModel
-{
- CV_STAT_MODEL_FIELDS();
- CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS();
-} CvCrossValidationModel;
-
-CVAPI(CvStatModel*)
-cvCreateCrossValidationEstimateModel
- ( int samples_all,
- const CvStatModelParams* estimateParams CV_DEFAULT(0),
- const CvMat* sampleIdx CV_DEFAULT(0) );
-
-CVAPI(float)
-cvCrossValidation( const CvMat* trueData,
- int tflag,
- const CvMat* trueClasses,
- CvStatModel* (*createClassifier)( const CvMat*,
- int,
- const CvMat*,
- const CvStatModelParams*,
- const CvMat*,
- const CvMat*,
- const CvMat*,
- const CvMat* ),
- const CvStatModelParams* estimateParams CV_DEFAULT(0),
- const CvStatModelParams* trainParams CV_DEFAULT(0),
- const CvMat* compIdx CV_DEFAULT(0),
- const CvMat* sampleIdx CV_DEFAULT(0),
- CvStatModel** pCrValModel CV_DEFAULT(0),
- const CvMat* typeMask CV_DEFAULT(0),
- const CvMat* missedMeasurementMask CV_DEFAULT(0) );
-#endif
-
/****************************************************************************************\
* Auxilary functions declarations *
\****************************************************************************************/
typedef CvBoost Boost;
typedef CvANN_MLP_TrainParams ANN_MLP_TrainParams;
typedef CvANN_MLP NeuralNet_MLP;
-typedef CvGBTreesParams GradientBoostingTreesParams;
+typedef CvGBTreesParams GradientBoostingTreeParams;
typedef CvGBTrees GradientBoostingTrees;
}
void CvBoost::write_params( CvFileStorage* fs ) const
{
- CV_FUNCNAME( "CvBoost::write_params" );
-
- __BEGIN__;
-
const char* boost_type_str =
params.boost_type == DISCRETE ? "DiscreteAdaboost" :
params.boost_type == REAL ? "RealAdaboost" :
cvWriteReal( fs, "weight_trimming_rate", params.weight_trim_rate );
data->write_params( fs );
-
- __END__;
}
///////////////////////////// Object Detection ////////////////////////////
-CV_EXPORTS void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
-CV_EXPORTS void groupRectangles(vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
class CV_EXPORTS FeatureEvaluator
{
template<> CV_EXPORTS void Ptr<CvHaarClassifierCascade>::delete_obj();
-class CV_EXPORTS CascadeClassifier
+class CV_EXPORTS_W CascadeClassifier
{
public:
struct CV_EXPORTS DTreeNode
enum { DO_CANNY_PRUNING = 1, SCALE_IMAGE = 2,
FIND_BIGGEST_OBJECT = 4, DO_ROUGH_SEARCH = 8 };
- CascadeClassifier();
- CascadeClassifier(const string& filename);
+ CV_WRAP CascadeClassifier();
+ CV_WRAP CascadeClassifier(const string& filename);
~CascadeClassifier();
- bool empty() const;
- bool load(const string& filename);
+ CV_WRAP bool empty() const;
+ CV_WRAP bool load(const string& filename);
bool read(const FileNode& node);
- void detectMultiScale( const Mat& image,
+ CV_WRAP void detectMultiScale( const Mat& image,
CV_OUT vector<Rect>& objects,
double scaleFactor=1.1,
int minNeighbors=3, int flags=0,
//////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
-struct CV_EXPORTS HOGDescriptor
+struct CV_EXPORTS_W HOGDescriptor
{
public:
enum { L2Hys=0 };
- HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),
+ CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),
cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1),
histogramNormType(L2Hys), L2HysThreshold(0.2), gammaCorrection(true)
{}
- HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride,
+ CV_WRAP HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride,
Size _cellSize, int _nbins, int _derivAperture=1, double _winSigma=-1,
int _histogramNormType=L2Hys, double _L2HysThreshold=0.2, bool _gammaCorrection=false)
: winSize(_winSize), blockSize(_blockSize), blockStride(_blockStride), cellSize(_cellSize),
gammaCorrection(_gammaCorrection)
{}
- HOGDescriptor(const String& filename)
+ CV_WRAP HOGDescriptor(const String& filename)
{
load(filename);
}
virtual ~HOGDescriptor() {}
- size_t getDescriptorSize() const;
- bool checkDetectorSize() const;
- double getWinSigma() const;
+ CV_WRAP size_t getDescriptorSize() const;
+ CV_WRAP bool checkDetectorSize() const;
+ CV_WRAP double getWinSigma() const;
- virtual void setSVMDetector(const vector<float>& _svmdetector);
+ CV_WRAP virtual void setSVMDetector(const vector<float>& _svmdetector);
virtual bool read(FileNode& fn);
virtual void write(FileStorage& fs, const String& objname) const;
- virtual bool load(const String& filename, const String& objname=String());
- virtual void save(const String& filename, const String& objname=String()) const;
+ CV_WRAP virtual bool load(const String& filename, const String& objname=String());
+ CV_WRAP virtual void save(const String& filename, const String& objname=String()) const;
virtual void copyTo(HOGDescriptor& c) const;
- virtual void compute(const Mat& img,
+ CV_WRAP virtual void compute(const Mat& img,
CV_OUT vector<float>& descriptors,
Size winStride=Size(), Size padding=Size(),
const vector<Point>& locations=vector<Point>()) const;
- virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,
+
CV_WRAP virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,
double hitThreshold=0, Size winStride=Size(),
Size padding=Size(),
const vector<Point>& searchLocations=vector<Point>()) const;
- virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,
+ CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,
double hitThreshold=0, Size winStride=Size(),
Size padding=Size(), double scale=1.05,
int groupThreshold=2) const;
- virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
+ CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
Size paddingTL=Size(), Size paddingBR=Size()) const;
static vector<float> getDefaultPeopleDetector();
- Size winSize;
- Size blockSize;
- Size blockStride;
- Size cellSize;
- int nbins;
- int derivAperture;
- double winSigma;
- int histogramNormType;
- double L2HysThreshold;
- bool gammaCorrection;
- vector<float> svmDetector;
+ CV_PROP Size winSize;
+ CV_PROP Size blockSize;
+ CV_PROP Size blockStride;
+ CV_PROP Size cellSize;
+ CV_PROP int nbins;
+ CV_PROP int derivAperture;
+ CV_PROP double winSigma;
+ CV_PROP int histogramNormType;
+ CV_PROP double L2HysThreshold;
+ CV_PROP bool gammaCorrection;
+ CV_PROP vector<float> svmDetector;
};
The class is only used to define the common interface for
the whole family of background/foreground segmentation algorithms.
*/
-class CV_EXPORTS BackgroundSubtractor
+class CV_EXPORTS_W BackgroundSubtractor
{
public:
//! the virtual destructor
virtual ~BackgroundSubtractor();
//! the update operator that takes the next video frame and returns the current foreground mask as 8-bit binary image.
- virtual CV_WRAP_AS(apply) void operator()(const Mat& image, CV_OUT Mat& fgmask,
+ CV_WRAP_AS(apply) virtual void operator()(const Mat& image, CV_OUT Mat& fgmask,
double learningRate=0);
};
http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
*/
-class CV_EXPORTS BackgroundSubtractorMOG : public BackgroundSubtractor
+class CV_EXPORTS_W BackgroundSubtractorMOG : public BackgroundSubtractor
{
public:
//! the default constructor
- BackgroundSubtractorMOG();
+ CV_WRAP BackgroundSubtractorMOG();
//! the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength
- BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0);
+ CV_WRAP BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0);
//! the destructor
virtual ~BackgroundSubtractorMOG();
//! the update operator
{
//! updates motion history image using the current silhouette
-CV_EXPORTS void updateMotionHistory( const Mat& silhouette, Mat& mhi,
+CV_EXPORTS_W 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, CV_OUT Mat& mask,
- CV_OUT Mat& orientation,
- double delta1, double delta2,
- int apertureSize=3 );
+CV_EXPORTS_W void calcMotionGradient( const Mat& mhi, CV_OUT Mat& mask,
+ CV_OUT 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 );
+CV_EXPORTS_W 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, CV_OUT Rect& window,
- TermCriteria criteria );
+CV_EXPORTS_W RotatedRect CamShift( const Mat& probImage, CV_OUT Rect& window,
+ TermCriteria criteria );
//! updates the object tracking window using meanshift algorithm
-CV_EXPORTS int meanShift( const Mat& probImage, CV_OUT Rect& window,
- TermCriteria criteria );
+CV_EXPORTS_W int meanShift( const Mat& probImage, CV_OUT Rect& window,
+ TermCriteria criteria );
/*!
Kalman filter.
However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and
KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.
*/
-class CV_EXPORTS KalmanFilter
+class CV_EXPORTS_W KalmanFilter
{
public:
//! the default constructor
- KalmanFilter();
+ CV_WRAP 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);
+ CV_WRAP 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());
+ CV_WRAP const Mat& predict(const Mat& control=Mat());
//! updates the predicted state from the measurement
- const Mat& correct(const Mat& measurement);
+ CV_WRAP 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))
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,
+CV_EXPORTS_W void calcOpticalFlowPyrLK( const Mat& prevImg, const Mat& nextImg,
const vector<Point2f>& prevPts, CV_OUT vector<Point2f>& nextPts,
CV_OUT vector<uchar>& status, CV_OUT vector<float>& err,
Size winSize=Size(15,15), int maxLevel=3,
int flags=0 );
//! computes dense optical flow using Farneback algorithm
-CV_EXPORTS void calcOpticalFlowFarneback( const Mat& prev, const Mat& next,
+CV_EXPORTS_W void calcOpticalFlowFarneback( const Mat& prev, const Mat& next,
CV_OUT Mat& flow, double pyr_scale, int levels, int winsize,
int iterations, int poly_n, double poly_sigma, int flags );
projects / platform / upstream / opencv.git / commitdiff