diff --git a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp index 4215736438..b202799a8b 100644 --- a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp @@ -429,10 +429,10 @@ namespace cv { //! 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 @@ -442,9 +442,9 @@ 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. @@ -454,7 +454,7 @@ CV_EXPORTS Mat findHomography( const Mat& srcPoints, 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 ); @@ -462,60 +462,60 @@ CV_EXPORTS Mat findHomography( const Mat& srcPoints, 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& imagePoints ); + CV_OUT vector& 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& imagePoints, - Mat& dpdrot, Mat& dpdt, Mat& dpdf, - Mat& dpdc, Mat& dpddist, + CV_OUT vector& 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 >& objectPoints, @@ -528,14 +528,14 @@ enum { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2, //! finds checkerboard pattern of the specified size in the image CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize, - vector& corners, + CV_OUT vector& 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 { @@ -559,78 +559,83 @@ enum //! finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. CV_EXPORTS double calibrateCamera( const vector >& objectPoints, - const vector >& imagePoints, - Size imageSize, - Mat& cameraMatrix, Mat& distCoeffs, - vector& rvecs, vector& tvecs, - int flags=0 ); + const vector >& imagePoints, + Size imageSize, + CV_IN_OUT Mat& cameraMatrix, + CV_IN_OUT Mat& distCoeffs, + CV_OUT vector& rvecs, CV_OUT vector& 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 >& objectPoints, - const vector >& imagePoints1, - const vector >& 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 >& imagePoints1, + const vector >& 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 >& imgpt1, - const vector >& 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 >& imgpt1, + const vector >& 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& dst ); +CV_EXPORTS void convertPointsHomogeneous( const Mat& src, CV_OUT vector& 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& dst ); +CV_EXPORTS void convertPointsHomogeneous( const Mat& src, CV_OUT vector& dst ); //! the algorithm for finding fundamental matrix enum @@ -643,18 +648,18 @@ enum //! finds fundamental matrix from a set of corresponding 2D points CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2, - vector& mask, int method=FM_RANSAC, - double param1=3., double param2=0.99 ); + CV_OUT vector& 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& lines ); + int whichImage, const Mat& F, + CV_OUT vector& lines ); template<> CV_EXPORTS void Ptr::delete_obj(); @@ -663,20 +668,20 @@ template<> CV_EXPORTS void Ptr::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 state; @@ -688,16 +693,16 @@ public: 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<(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 ); } diff --git a/modules/calib3d/src/calibration.cpp b/modules/calib3d/src/calibration.cpp index e4fa225fae..079884fb7f 100644 --- a/modules/calib3d/src/calibration.cpp +++ b/modules/calib3d/src/calibration.cpp @@ -3097,6 +3097,7 @@ static void collectCalibrationData( const vector >& objectPoints std::copy(imagePoints2[i].begin(), imagePoints2[i].end(), imgPtData2 + j); } } + static Mat prepareCameraMatrix(Mat& cameraMatrix0, int rtype) { @@ -3293,9 +3294,9 @@ double cv::calibrateCamera( const vector >& objectPoints, 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++ ) @@ -3306,6 +3307,7 @@ double cv::calibrateCamera( const vector >& objectPoints, return reprojErr; } + void cv::calibrationMatrixValues( const Mat& cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, @@ -3349,6 +3351,7 @@ double cv::stereoCalibrate( const vector >& objectPoints, &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, @@ -3539,7 +3542,7 @@ static void adjust3rdMatrix(const vector >& imgpt1_0, } -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 >& imgpt1, diff --git a/modules/calib3d/src/fundam.cpp b/modules/calib3d/src/fundam.cpp index ece3889214..7f1a8e481e 100644 --- a/modules/calib3d/src/fundam.cpp +++ b/modules/calib3d/src/fundam.cpp @@ -1074,12 +1074,9 @@ static Mat _findFundamentalMat( const Mat& points1, const Mat& points2, int method, double param1, double param2, vector* 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); @@ -1127,10 +1124,8 @@ cv::Mat cv::findFundamentalMat( const Mat& points1, const Mat& points2, void cv::computeCorrespondEpilines( const Mat& points, int whichImage, const Mat& F, vector& 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; @@ -1139,10 +1134,8 @@ void cv::computeCorrespondEpilines( const Mat& points, int whichImage, void cv::convertPointsHomogeneous( const Mat& src, vector& 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); @@ -1151,10 +1144,8 @@ void cv::convertPointsHomogeneous( const Mat& src, vector& dst ) void cv::convertPointsHomogeneous( const Mat& src, vector& 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); diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 5dc1c03ee9..00bde78fa6 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/modules/core/include/opencv2/core/core.hpp @@ -238,7 +238,7 @@ CV_EXPORTS int64 getTickCount(); exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency(); \endcode */ -CV_EXPORTS double getTickFrequency(); +CV_EXPORTS_W double getTickFrequency(); /*! Returns the number of CPU ticks. @@ -268,7 +268,7 @@ CV_EXPORTS int64 getCPUTickCount(); 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 @@ -330,14 +330,14 @@ static inline size_t alignSize(size_t sz, int n) \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() @@ -1561,6 +1561,7 @@ public: //! copies the matrix content to "m". // It calls m.create(this->size(), this->type()). void copyTo( Mat& m ) const; + template 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. @@ -1678,6 +1679,9 @@ public: 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); @@ -1884,86 +1888,101 @@ CV_EXPORTS void extractImageCOI(const CvArr* arr, CV_OUT Mat& coiimg, int coi=-1 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_castabs(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& mv, Mat& dst) +{ merge(&mv[0], mv.size(), dst); } +CV_WRAP static inline void split(const Mat& m, vector& 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& src, vector& 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; @@ -1971,103 +1990,103 @@ static inline Mat repeat(const Mat& src, int ny, int nx) } //! 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 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 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); @@ -2075,11 +2094,10 @@ CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, int lowindex=-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); /*! @@ -2136,27 +2154,27 @@ CV_EXPORTS void calcCovarMatrix( const Mat& samples, CV_OUT Mat& covar, CV_OUT M } \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 }; /*! @@ -2184,11 +2202,11 @@ public: 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 static void compute( const Matx<_Tp, m, n>& a, @@ -2207,24 +2225,24 @@ public: }; //! 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 @@ -2236,7 +2254,7 @@ enum 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 ); @@ -2247,22 +2265,22 @@ CV_EXPORTS RNG& theRNG(); template 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); @@ -2272,41 +2290,41 @@ CV_EXPORTS void rectangle(Mat& img, Rect rec, 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 @@ -2338,7 +2356,7 @@ public: }; //! 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& pts ); @@ -2356,13 +2374,13 @@ enum }; //! 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); @@ -3535,7 +3553,7 @@ public: CV_Assert(dist[0] <= dist[1] && dist[1] <= dist[2]); \endcode */ -class CV_EXPORTS KDTree +class CV_EXPORTS_W KDTree { public: /*! @@ -3555,13 +3573,14 @@ 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, @@ -3577,12 +3596,12 @@ public: //! 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 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 //////////////////////////////////// @@ -3686,7 +3705,7 @@ class CV_EXPORTS FileNode; lbp_val |= ((int)*it) << k; \endcode */ -class CV_EXPORTS FileStorage +class CV_EXPORTS_W FileStorage { public: //! file storage mode @@ -3704,29 +3723,29 @@ public: 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; } @@ -3738,7 +3757,7 @@ public: 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 fs; //!< the underlying C FileStorage structure string elname; //!< the currently written element @@ -3758,7 +3777,7 @@ class CV_EXPORTS FileNodeIterator; 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 @@ -3780,7 +3799,7 @@ public: 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 @@ -3788,41 +3807,41 @@ public: //! 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 *(); diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp index 5db98529cd..c4c70084e5 100644 --- a/modules/core/include/opencv2/core/mat.hpp +++ b/modules/core/include/opencv2/core/mat.hpp @@ -608,14 +608,25 @@ template inline MatIterator_<_Tp> Mat::end() return it; } -template inline Mat::operator vector<_Tp>() const + +template 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 inline Mat::operator vector<_Tp>() const +{ + vector<_Tp> v; + copyTo(v); return v; } @@ -1011,7 +1022,9 @@ template inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1, template inline Mat_<_Tp>::operator vector<_Tp>() const { - return this->Mat::operator vector<_Tp>(); + vector<_Tp> v; + copyTo(v); + return v; } template template inline Mat_<_Tp>::operator Vec::channel_type, n>() const @@ -1025,7 +1038,7 @@ template template inline Mat_<_Tp>::operator Matx::channels == 0); return this->Mat::operator Matx::channel_type, m, n>(); } - + template inline void process( const Mat_& m1, Mat_& m2, Op op ) { @@ -1522,26 +1535,10 @@ operator ^= (const Mat_<_Tp>& a, const Scalar& s) } /////////////////////////////// Miscellaneous operations ////////////////////////////// - -static inline void merge(const vector& mv, Mat& dst) -{ merge(&mv[0], mv.size(), dst); } - -static inline void split(const Mat& m, vector& mv) -{ - mv.resize(m.channels()); - if(m.channels() > 0) - split(m, &mv[0]); -} template void split(const Mat& src, vector >& mv) { split(src, (vector&)mv ); } -static inline void mixChannels(const vector& src, vector& dst, - const int* fromTo, int npairs) -{ - mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs); -} - ////////////////////////////////////////////////////////////// template inline MatExpr Mat_<_Tp>::zeros(int rows, int cols) diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp index 8341022b35..83fe94a9be 100644 --- a/modules/core/include/opencv2/core/operations.hpp +++ b/modules/core/include/opencv2/core/operations.hpp @@ -2494,10 +2494,10 @@ template<> CV_EXPORTS void Ptr::delete_obj(); //////////////////////////////////////// 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 inline void write(FileStorage& fs, const _Tp& value) { write(fs, string(), value); } @@ -2691,7 +2691,7 @@ operator << ( FileStorage& fs, const vector<_Tp>& vec ) 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 static inline FileStorage& operator << (FileStorage& fs, const _Tp& value) @@ -2792,7 +2792,7 @@ static inline void read(const FileNode& node, string& value, const string& defau 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 diff --git a/modules/core/include/opencv2/core/types_c.h b/modules/core/include/opencv2/core/types_c.h index 986cdabcf3..d3374e33ef 100644 --- a/modules/core/include/opencv2/core/types_c.h +++ b/modules/core/include/opencv2/core/types_c.h @@ -160,10 +160,16 @@ typedef signed char schar; /* 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 diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index 9476c46325..d1c30e2891 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -1530,8 +1530,6 @@ void compare( const Mat& src1, double value, Mat& dst, int cmpOp ) binarySOpC1_ >, 0}, }; - dst.create(src1.rows, src1.cols, CV_8U); - CV_Assert(src1.channels() == 1); int depth = src1.depth(); bool invflag = false; @@ -1562,7 +1560,7 @@ void compare( const Mat& src1, double value, Mat& dst, int cmpOp ) 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); @@ -1576,6 +1574,7 @@ void compare( const Mat& src1, double value, Mat& dst, int cmpOp ) return; } + dst.create(src1.rows, src1.cols, CV_8UC(src1.channels())); func( src1, dst, value ); if( invflag ) bitwise_not(dst, dst); diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index 7de62d8175..11641d02e5 100644 --- a/modules/core/src/matrix.cpp +++ b/modules/core/src/matrix.cpp @@ -268,8 +268,6 @@ Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) if( rows == 1 ) flags |= CONTINUOUS_FLAG; - if( refcount ) - CV_XADD(refcount, 1); if( rows <= 0 || cols <= 0 ) { release(); @@ -737,6 +735,16 @@ Mat Mat::reshape(int new_cn, int new_rows) const } +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 \*************************************************************************************************/ diff --git a/modules/features2d/include/opencv2/features2d/features2d.hpp b/modules/features2d/include/opencv2/features2d/features2d.hpp index e97ab96ad8..8b9e8f41d8 100644 --- a/modules/features2d/include/opencv2/features2d/features2d.hpp +++ b/modules/features2d/include/opencv2/features2d/features2d.hpp @@ -254,9 +254,9 @@ public: }; //! writes vector of keypoints to the file storage -CV_EXPORTS void write(FileStorage& fs, const string& name, const vector& keypoints); +CV_EXPORTS_W void write(FileStorage& fs, const string& name, const vector& keypoints); //! reads vector of keypoints from the specified file storage node -CV_EXPORTS void read(const FileNode& node, CV_OUT vector& keypoints); +CV_EXPORTS_W void read(const FileNode& node, CV_OUT vector& keypoints); /*! SIFT implementation. @@ -347,17 +347,17 @@ protected: 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& keypoints) const; @@ -377,13 +377,13 @@ public: 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 ); @@ -397,13 +397,13 @@ public: 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); @@ -428,8 +428,8 @@ public: 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; @@ -453,10 +453,10 @@ public: 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& keypoints, int maxCount=0, bool scaleCoords=true) const; - CV_WRAP_AS(detect) void operator()(const vector& pyr, + void operator()(const vector& pyr, CV_OUT vector& keypoints, int maxCount=0, bool scaleCoords=true) const; void getMostStable2D(const Mat& image, CV_OUT vector& keypoints, @@ -607,8 +607,8 @@ public: 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& corners) const; - CV_WRAP_AS(detect) bool operator()(const vector& pyr, const vector& keypoints, + bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT vector& corners) const; + bool operator()(const vector& pyr, const vector& keypoints, CV_OUT Mat& H, CV_OUT vector& corners, CV_OUT vector* pairs=0) const; diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp index 305610ac74..278683e966 100644 --- a/modules/highgui/include/opencv2/highgui/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui/highgui.hpp @@ -56,12 +56,12 @@ namespace cv 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 @@ -84,75 +84,75 @@ typedef void (CV_CDECL *ButtonCallback)(int state, void* userdata); 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& params=vector()); -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& buf, const vector& params=vector()); -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::delete_obj(); template<> void CV_EXPORTS Ptr::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 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 writer; diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp index 2c8e187ca0..ab0d54f296 100644 --- a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp @@ -65,7 +65,7 @@ enum { BORDER_REPLICATE=IPL_BORDER_REPLICATE, BORDER_CONSTANT=IPL_BORDER_CONSTAN 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 @@ -320,14 +320,14 @@ CV_EXPORTS Ptr createLinearFilter(int srcType, int dstType, 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 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 @@ -370,32 +370,32 @@ CV_EXPORTS Ptr createMorphologyFilter(int op, int type, const Mat& //! 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::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 ) { @@ -403,54 +403,54 @@ static inline void blur( const Mat& src, CV_OUT Mat& dst, } //! 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 @@ -481,19 +481,19 @@ CV_EXPORTS void HoughCircles( const Mat& image, CV_OUT vector& circles, 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, @@ -512,19 +512,19 @@ enum }; //! 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, @@ -535,44 +535,44 @@ enum { INTER_BITS=5, INTER_BITS2=INTER_BITS*2, 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 @@ -580,28 +580,28 @@ enum { THRESH_BINARY=0, THRESH_BINARY_INV=1, THRESH_TRUNC=2, THRESH_TOZERO=3, 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& 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 ); @@ -612,67 +612,64 @@ enum }; //! 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& 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::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) ); @@ -690,7 +687,7 @@ enum { GC_INIT_WITH_RECT = 0, }; //! 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 ); @@ -702,34 +699,35 @@ enum }; //! 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 @@ -754,7 +752,7 @@ public: }; //! 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] ); @@ -763,7 +761,7 @@ 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 @@ -808,18 +806,18 @@ CV_EXPORTS void approxPolyDP( const Mat& curve, CV_OUT vector& 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. @@ -830,28 +828,28 @@ CV_EXPORTS void convexHull( const Mat& points, CV_OUT vector& hull, bool CV_EXPORTS void convexHull( const Mat& points, CV_OUT vector& 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& outliers, + CV_OUT vector& outliers, double param1 = 3.0, double param2 = 0.99); } diff --git a/modules/imgproc/src/contours.cpp b/modules/imgproc/src/contours.cpp index 182f2c7815..7a3690c5be 100644 --- a/modules/imgproc/src/contours.cpp +++ b/modules/imgproc/src/contours.cpp @@ -1627,12 +1627,11 @@ void cv::drawContours( Mat& image, const vector >& contours, -maxLevel : maxLevel, thickness, lineType, offset ); } + void cv::approxPolyDP( const Mat& curve, vector& 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 seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed)); @@ -1642,9 +1641,7 @@ void cv::approxPolyDP( const Mat& curve, vector& approxCurve, void cv::approxPolyDP( const Mat& curve, vector& 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 seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed)); @@ -1653,10 +1650,7 @@ void cv::approxPolyDP( const Mat& curve, vector& approxCurve, 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); } @@ -1664,10 +1658,7 @@ double cv::arcLength( const Mat& curve, bool 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); } @@ -1675,10 +1666,7 @@ cv::Rect cv::boundingRect( const Mat& points ) 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); } @@ -1686,10 +1674,7 @@ double cv::contourArea( const Mat& contour, bool 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); } @@ -1698,10 +1683,7 @@ cv::RotatedRect cv::minAreaRect( const Mat& points ) 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 ); } @@ -1711,13 +1693,9 @@ double cv::matchShapes( const Mat& contour1, 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); @@ -1726,10 +1704,7 @@ double cv::matchShapes( const Mat& contour1, void cv::convexHull( const Mat& points, vector& 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); @@ -1740,9 +1715,7 @@ void cv::convexHull( const Mat& points, vector& hull, bool clockwise ) void cv::convexHull( const Mat& points, vector& 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); @@ -1753,9 +1726,7 @@ void cv::convexHull( const Mat& points, void cv::convexHull( const Mat& points, vector& 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); @@ -1764,20 +1735,16 @@ void cv::convexHull( const Mat& points, 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); } @@ -1786,10 +1753,8 @@ cv::RotatedRect cv::fitEllipse( const Mat& 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]); } @@ -1798,10 +1763,8 @@ void cv::fitLine( const Mat& points, Vec4f& line, int distType, 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]); } @@ -1809,10 +1772,8 @@ void cv::fitLine( const Mat& points, Vec6f& line, int distType, 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 ); } diff --git a/modules/ml/include/opencv2/ml/ml.hpp b/modules/ml/include/opencv2/ml/ml.hpp index 3131d421a3..2f4eb7d933 100644 --- a/modules/ml/include/opencv2/ml/ml.hpp +++ b/modules/ml/include/opencv2/ml/ml.hpp @@ -188,7 +188,7 @@ CV_INLINE CvParamLattice cvDefaultParamLattice( void ) #define CV_TRAIN_ERROR 0 #define CV_TEST_ERROR 1 -class CV_EXPORTS CvStatModel +class CV_EXPORTS_AS(StatModel) CvStatModel { public: CvStatModel(); @@ -196,8 +196,8 @@ public: 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 ); @@ -241,27 +241,29 @@ struct CV_EXPORTS CvParamGrid 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 ); @@ -285,11 +287,11 @@ protected: \****************************************************************************************/ // 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, @@ -299,18 +301,18 @@ public: 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; @@ -343,7 +345,7 @@ protected: \****************************************************************************************/ // SVM training parameters -struct CV_EXPORTS CvSVMParams +struct CV_EXPORTS_AS_MAP CvSVMParams { CvSVMParams(); CvSVMParams( int _svm_type, int _kernel_type, @@ -506,7 +508,7 @@ struct CvSVMDecisionFunc // SVM model -class CV_EXPORTS CvSVM : public CvStatModel +class CV_EXPORTS_AS(SVM) CvSVM : public CvStatModel { public: // SVM type @@ -518,7 +520,7 @@ public: // 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, @@ -542,15 +544,15 @@ public: 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), @@ -559,19 +561,19 @@ public: 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: @@ -607,7 +609,7 @@ 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) @@ -634,7 +636,7 @@ struct CV_EXPORTS CvEMParams }; -class CV_EXPORTS CvEM : public CvStatModel +class CV_EXPORTS_AS(EM) CvEM : public CvStatModel { public: // Type of covariation matrices @@ -643,37 +645,38 @@ public: // 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; }; @@ -769,7 +772,7 @@ struct CvDTreeNode }; -struct CV_EXPORTS CvDTreeParams +struct CV_EXPORTS_AS_MAP CvDTreeParams { int max_categories; int max_depth; @@ -912,10 +915,10 @@ namespace cv 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, @@ -934,18 +937,18 @@ public: 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; @@ -1044,7 +1047,7 @@ protected: }; -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 @@ -1074,10 +1077,10 @@ struct CV_EXPORTS CvRTParams : public CvDTreeParams }; -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, @@ -1090,18 +1093,18 @@ public: 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; @@ -1173,10 +1176,10 @@ protected: 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, @@ -1184,7 +1187,7 @@ public: 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(), @@ -1200,7 +1203,7 @@ protected: * Boosted tree classifier * \****************************************************************************************/ -struct CV_EXPORTS CvBoostParams : public CvDTreeParams +struct CV_EXPORTS_AS_MAP CvBoostParams : public CvDTreeParams { int boost_type; int weak_count; @@ -1262,7 +1265,7 @@ protected: }; -class CV_EXPORTS CvBoost : public CvStatModel +class CV_EXPORTS_AS(Boost) CvBoost : public CvStatModel { public: // Boosting type @@ -1271,7 +1274,7 @@ public: // Splitting criteria enum { DEFAULT=0, GINI=1, MISCLASS=3, SQERR=4 }; - CvBoost(); + CV_WRAP CvBoost(); virtual ~CvBoost(); CvBoost( const CvMat* _train_data, int _tflag, @@ -1296,29 +1299,29 @@ public: 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 *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 ); @@ -1379,7 +1382,7 @@ protected: // 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; @@ -1439,7 +1442,7 @@ struct CV_EXPORTS CvGBTreesParams : public CvDTreeParams -class CV_EXPORTS CvGBTrees : public CvStatModel +class CV_EXPORTS_AS(GBTrees) CvGBTrees : public CvStatModel { public: @@ -1480,7 +1483,7 @@ public: // OUTPUT // RESULT */ - CvGBTrees(); + CV_WRAP CvGBTrees(); /* @@ -1520,7 +1523,7 @@ public: // 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, @@ -1572,7 +1575,7 @@ public: // 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, @@ -1628,7 +1631,7 @@ public: // 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; @@ -1646,7 +1649,7 @@ public: // delta = 0.0 // RESULT */ - virtual void clear(); + CV_WRAP virtual void clear(); /* // Compute error on the train/test set. @@ -1890,7 +1893,7 @@ protected: /////////////////////////////////// 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, @@ -1910,10 +1913,10 @@ struct CV_EXPORTS CvANN_MLP_TrainParams }; -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 ); @@ -1928,26 +1931,26 @@ public: 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 }; @@ -2003,293 +2006,6 @@ protected: 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*(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**(W*X)) - is the vector used in computing of the - // activation function and it's derivative by the formulae - // activ.func. = (exp(2WX)-1)/(exp(2WX)+1) == - 2/( + 1) - // (activ.func.)' = 4exp(2WX)/(exp(2WX)+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 - 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 * \****************************************************************************************/ @@ -2461,7 +2177,7 @@ typedef CvBoostTree BoostTree; typedef CvBoost Boost; typedef CvANN_MLP_TrainParams ANN_MLP_TrainParams; typedef CvANN_MLP NeuralNet_MLP; -typedef CvGBTreesParams GradientBoostingTreesParams; +typedef CvGBTreesParams GradientBoostingTreeParams; typedef CvGBTrees GradientBoostingTrees; } diff --git a/modules/ml/src/boost.cpp b/modules/ml/src/boost.cpp index 2cf9b7e697..675a6e4a3b 100644 --- a/modules/ml/src/boost.cpp +++ b/modules/ml/src/boost.cpp @@ -1894,10 +1894,6 @@ float CvBoost::calc_error( CvMLData* _data, int type, std::vector *resp ) 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" : @@ -1924,8 +1920,6 @@ void CvBoost::write_params( CvFileStorage* fs ) const cvWriteReal( fs, "weight_trimming_rate", params.weight_trim_rate ); data->write_params( fs ); - - __END__; } diff --git a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp index ae86b61781..6fbb51892f 100644 --- a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp +++ b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp @@ -270,8 +270,8 @@ namespace cv ///////////////////////////// Object Detection //////////////////////////// -CV_EXPORTS void groupRectangles(vector& rectList, int groupThreshold, double eps=0.2); -CV_EXPORTS void groupRectangles(vector& rectList, CV_OUT vector& weights, int groupThreshold, double eps=0.2); +CV_EXPORTS_W void groupRectangles(vector& rectList, int groupThreshold, double eps=0.2); +CV_EXPORTS_W void groupRectangles(vector& rectList, CV_OUT vector& weights, int groupThreshold, double eps=0.2); class CV_EXPORTS FeatureEvaluator { @@ -293,7 +293,7 @@ public: template<> CV_EXPORTS void Ptr::delete_obj(); -class CV_EXPORTS CascadeClassifier +class CV_EXPORTS_W CascadeClassifier { public: struct CV_EXPORTS DTreeNode @@ -320,14 +320,14 @@ public: 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& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, @@ -356,17 +356,17 @@ public: //////////////// 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), @@ -375,7 +375,7 @@ public: gammaCorrection(_gammaCorrection) {} - HOGDescriptor(const String& filename) + CV_WRAP HOGDescriptor(const String& filename) { load(filename); } @@ -387,47 +387,47 @@ public: 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& _svmdetector); + CV_WRAP virtual void setSVMDetector(const vector& _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& descriptors, Size winStride=Size(), Size padding=Size(), const vector& locations=vector()) const; - virtual void detect(const Mat& img, CV_OUT vector& foundLocations, + CV_WRAP virtual void detect(const Mat& img, CV_OUT vector& foundLocations, double hitThreshold=0, Size winStride=Size(), Size padding=Size(), const vector& searchLocations=vector()) const; - virtual void detectMultiScale(const Mat& img, CV_OUT vector& foundLocations, + CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT vector& 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 getDefaultPeopleDetector(); - Size winSize; - Size blockSize; - Size blockStride; - Size cellSize; - int nbins; - int derivAperture; - double winSigma; - int histogramNormType; - double L2HysThreshold; - bool gammaCorrection; - vector 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 svmDetector; }; diff --git a/modules/video/include/opencv2/video/background_segm.hpp b/modules/video/include/opencv2/video/background_segm.hpp index 174b24ac6f..18137b97fc 100644 --- a/modules/video/include/opencv2/video/background_segm.hpp +++ b/modules/video/include/opencv2/video/background_segm.hpp @@ -353,13 +353,13 @@ namespace cv 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); }; @@ -374,13 +374,13 @@ public: 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 diff --git a/modules/video/include/opencv2/video/tracking.hpp b/modules/video/include/opencv2/video/tracking.hpp index 33f94b78b2..017c861de5 100644 --- a/modules/video/include/opencv2/video/tracking.hpp +++ b/modules/video/include/opencv2/video/tracking.hpp @@ -244,28 +244,28 @@ namespace cv { //! 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. @@ -274,20 +274,20 @@ CV_EXPORTS int meanShift( const Mat& probImage, CV_OUT Rect& window, 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)) @@ -312,7 +312,7 @@ public: 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& prevPts, CV_OUT vector& nextPts, CV_OUT vector& status, CV_OUT vector& err, Size winSize=Size(15,15), int maxLevel=3, @@ -323,7 +323,7 @@ CV_EXPORTS void calcOpticalFlowPyrLK( const Mat& prevImg, const Mat& nextImg, 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 );