added more helper macros to the function declarations, to assist the Python wrapper generator. Fixed memleak in Mat::operator()(Range,Range) and the related functions (Mat::row, Mat::col etc.)

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<Point2f>& imagePoints );
+                               CV_OUT vector<Point2f>& imagePoints );
 
 //! projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters
 CV_EXPORTS void projectPoints( const Mat& objectPoints,
                                const Mat& rvec, const Mat& tvec,
                                const Mat& cameraMatrix,
                                const Mat& distCoeffs,
-                               vector<Point2f>& imagePoints,
-                               Mat& dpdrot, Mat& dpdt, Mat& dpdf,
-                               Mat& dpdc, Mat& dpddist,
+                               CV_OUT vector<Point2f>& imagePoints,
+                               CV_OUT Mat& dpdrot, CV_OUT Mat& dpdt, CV_OUT Mat& dpdf,
+                               CV_OUT Mat& dpdc, CV_OUT Mat& dpddist,
                                double aspectRatio=0 );
 
 //! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.
-CV_EXPORTS void solvePnP( const Mat& objectPoints,
-                          const Mat& imagePoints,
-                          const Mat& cameraMatrix,
-                          const Mat& distCoeffs,
-                          Mat& rvec, Mat& tvec,
-                          bool useExtrinsicGuess=false );
+CV_EXPORTS_W void solvePnP( const Mat& objectPoints,
+                            const Mat& imagePoints,
+                            const Mat& cameraMatrix,
+                            const Mat& distCoeffs,
+                            CV_OUT Mat& rvec, CV_OUT Mat& tvec,
+                            bool useExtrinsicGuess=false );
 
 //! initializes camera matrix from a few 3D points and the corresponding projections.
 CV_EXPORTS Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints,
@@ -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<Point2f>& corners,
+                                       CV_OUT vector<Point2f>& corners,
                                        int flags=CALIB_CB_ADAPTIVE_THRESH+
-                                            CALIB_CB_NORMALIZE_IMAGE );
+                                              CALIB_CB_NORMALIZE_IMAGE );
 
 //! draws the checkerboard pattern (found or partly found) in the image
-CV_EXPORTS void drawChessboardCorners( Mat& image, Size patternSize,
-                                       const Mat& corners,
-                                       bool patternWasFound );
+CV_EXPORTS_W void drawChessboardCorners( Mat& image, Size patternSize,
+                                         const Mat& corners,
+                                         bool patternWasFound );
 
 enum
 {
@@ -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<vector<Point3f> >& objectPoints,
-                                 const vector<vector<Point2f> >& imagePoints,
-                                 Size imageSize,
-                                 Mat& cameraMatrix, Mat& distCoeffs,
-                                 vector<Mat>& rvecs, vector<Mat>& tvecs,
-                                 int flags=0 );
+                                     const vector<vector<Point2f> >& imagePoints,
+                                     Size imageSize,
+                                     CV_IN_OUT Mat& cameraMatrix,
+                                     CV_IN_OUT Mat& distCoeffs,
+                                     CV_OUT vector<Mat>& rvecs, CV_OUT vector<Mat>& tvecs,
+                                     int flags=0 );
 
 //! computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
-CV_EXPORTS void calibrationMatrixValues( const Mat& cameraMatrix,
+CV_EXPORTS_W void calibrationMatrixValues( const Mat& cameraMatrix,
                                 Size imageSize,
                                 double apertureWidth,
                                 double apertureHeight,
-                                double& fovx,
-                                double& fovy,
-                                double& focalLength,
-                                Point2d& principalPoint,
-                                double& aspectRatio );
+                                CV_OUT double& fovx,
+                                CV_OUT double& fovy,
+                                CV_OUT double& focalLength,
+                                CV_OUT Point2d& principalPoint,
+                                CV_OUT double& aspectRatio );
 
 //! finds intrinsic and extrinsic parameters of a stereo camera
 CV_EXPORTS double stereoCalibrate( const vector<vector<Point3f> >& objectPoints,
-                                 const vector<vector<Point2f> >& imagePoints1,
-                                 const vector<vector<Point2f> >& imagePoints2,
-                                 Mat& cameraMatrix1, Mat& distCoeffs1,
-                                 Mat& cameraMatrix2, Mat& distCoeffs2,
-                                 Size imageSize, Mat& R, Mat& T,
-                                 Mat& E, Mat& F,
-                                 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
-                                    TermCriteria::EPS, 30, 1e-6),
-                                 int flags=CALIB_FIX_INTRINSIC );
+                                     const vector<vector<Point2f> >& imagePoints1,
+                                     const vector<vector<Point2f> >& imagePoints2,
+                                     CV_IN_OUT Mat& cameraMatrix1, CV_IN_OUT Mat& distCoeffs1,
+                                     CV_IN_OUT Mat& cameraMatrix2, CV_IN_OUT Mat& distCoeffs2,
+                                     Size imageSize, CV_OUT Mat& R, CV_OUT Mat& T,
+                                     CV_OUT Mat& E, CV_OUT Mat& F,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
+                                         TermCriteria::EPS, 30, 1e-6),
+                                     int flags=CALIB_FIX_INTRINSIC );
 
+    
 //! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
 CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
                                const Mat& cameraMatrix2, const Mat& distCoeffs2,
                                Size imageSize, const Mat& R, const Mat& T,
-                               Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
+                               CV_OUT Mat& R1, CV_OUT Mat& R2,
+                               CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& Q,
                                int flags=CALIB_ZERO_DISPARITY );
 
 //! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
-CV_EXPORTS void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
-                              const Mat& cameraMatrix2, const Mat& distCoeffs2,
-                              Size imageSize, const Mat& R, const Mat& T,
-                              Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q,
-                              double alpha, Size newImageSize=Size(),
-                              Rect* validPixROI1=0, Rect* validPixROI2=0,
-                              int flags=CALIB_ZERO_DISPARITY );
+CV_EXPORTS_W void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
+                                 const Mat& cameraMatrix2, const Mat& distCoeffs2,
+                                 Size imageSize, const Mat& R, const Mat& T,
+                                 CV_OUT Mat& R1, CV_OUT Mat& R2,
+                                 CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& Q,
+                                 double alpha, Size newImageSize=Size(),
+                                 CV_OUT Rect* validPixROI1=0, CV_OUT Rect* validPixROI2=0,
+                                 int flags=CALIB_ZERO_DISPARITY );
 
 //! computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
-CV_EXPORTS bool stereoRectifyUncalibrated( const Mat& points1,
-                                           const Mat& points2,
-                                           const Mat& F, Size imgSize,
-                                           Mat& H1, Mat& H2,
-                                           double threshold=5 );
-
-//! computes the rectification transformations for 3-head camera, where the heads are on the same line.
-CV_EXPORTS float rectify3( const Mat& cameraMatrix1, const Mat& distCoeffs1,
-                   const Mat& cameraMatrix2, const Mat& distCoeffs2,
-                   const Mat& cameraMatrix3, const Mat& distCoeffs3,
-                   const vector<vector<Point2f> >& imgpt1,
-                   const vector<vector<Point2f> >& imgpt3,
-                   Size imageSize, const Mat& R12, const Mat& T12, const Mat& R13, const Mat& T13,
-                   Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q,
-                   double alpha, Size newImgSize,
-                   Rect* roi1, Rect* roi2, int flags );
+CV_EXPORTS_W bool stereoRectifyUncalibrated( const Mat& points1, const Mat& points2,
+                                             const Mat& F, Size imgSize,
+                                             CV_OUT Mat& H1, CV_OUT Mat& H2,
+                                             double threshold=5 );
+
+//! computes the rectification transformations for 3-head camera, where all the heads are on the same line.
+CV_EXPORTS float rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1,
+                                      const Mat& cameraMatrix2, const Mat& distCoeffs2,
+                                      const Mat& cameraMatrix3, const Mat& distCoeffs3,
+                                      const vector<vector<Point2f> >& imgpt1,
+                                      const vector<vector<Point2f> >& imgpt3,
+                                      Size imageSize, const Mat& R12, const Mat& T12,
+                                      const Mat& R13, const Mat& T13,
+                                      CV_OUT Mat& R1, CV_OUT Mat& R2, CV_OUT Mat& R3,
+                                      CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& P3, CV_OUT Mat& Q,
+                                      double alpha, Size newImgSize,
+                                      CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags );
     
 //! returns the optimal new camera matrix
-CV_EXPORTS Mat getOptimalNewCameraMatrix( const Mat& cameraMatrix, const Mat& distCoeffs,
-                                          Size imageSize, double alpha, Size newImgSize=Size(),
-                                          Rect* validPixROI=0);
+CV_EXPORTS_W Mat getOptimalNewCameraMatrix( const Mat& cameraMatrix, const Mat& distCoeffs,
+                                            Size imageSize, double alpha, Size newImgSize=Size(),
+                                            CV_OUT Rect* validPixROI=0);
 
 //! converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
-CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst );
+CV_EXPORTS void convertPointsHomogeneous( const Mat& src, CV_OUT vector<Point3f>& dst );
 //! converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
-CV_EXPORTS void convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst );
+CV_EXPORTS void convertPointsHomogeneous( const Mat& src, CV_OUT vector<Point2f>& dst );
 
 //! the algorithm for finding fundamental matrix
 enum
@@ -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<uchar>& mask, int method=FM_RANSAC,
-                                   double param1=3., double param2=0.99 );
+                                     CV_OUT vector<uchar>& mask, int method=FM_RANSAC,
+                                     double param1=3., double param2=0.99 );
 
 //! finds fundamental matrix from a set of corresponding 2D points
-CV_EXPORTS Mat findFundamentalMat( const Mat& points1, const Mat& points2,
-                                   int method=FM_RANSAC,
-                                   double param1=3., double param2=0.99 );
+CV_EXPORTS_W Mat findFundamentalMat( const Mat& points1, const Mat& points2,
+                                     int method=FM_RANSAC,
+                                     double param1=3., double param2=0.99 );
 
 //! finds coordinates of epipolar lines corresponding the specified points
 CV_EXPORTS void computeCorrespondEpilines( const Mat& points1,
-                                           int whichImage, const Mat& F,
-                                           vector<Vec3f>& lines );
+                                             int whichImage, const Mat& F,
+                                             CV_OUT vector<Vec3f>& lines );
 
 template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
 
@@ -663,20 +668,20 @@ template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
  
  The class implements BM stereo correspondence algorithm by K. Konolige.
 */
-class CV_EXPORTS StereoBM
+class CV_EXPORTS_W StereoBM
 {
 public:
     enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1,
         BASIC_PRESET=0, FISH_EYE_PRESET=1, NARROW_PRESET=2 };
 
     //! the default constructor
-    StereoBM();
+    CV_WRAP StereoBM();
     //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size
-    StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);
+    CV_WRAP StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);
     //! the method that reinitializes the state. The previous content is destroyed
     void init(int preset, int ndisparities=0, int SADWindowSize=21);
     //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
-    void operator()( const Mat& left, const Mat& right, Mat& disparity, int disptype=CV_16S );
+    CV_WRAP_AS(compute) void operator()( const Mat& left, const Mat& right, Mat& disparity, int disptype=CV_16S );
 
     //! pointer to the underlying CvStereoBMState
     Ptr<CvStereoBMState> state;
@@ -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<<DISP_SHIFT) };
 
     //! the default constructor
-    StereoSGBM();
+    CV_WRAP StereoSGBM();
     
     //! the full constructor taking all the necessary algorithm parameters
-    StereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
+    CV_WRAP StereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
                int P1=0, int P2=0, int disp12MaxDiff=0,
                int preFilterCap=0, int uniquenessRatio=0,
                int speckleWindowSize=0, int speckleRange=0,
@@ -706,40 +711,41 @@ public:
     virtual ~StereoSGBM();
 
     //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair
-    virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
-
-    int minDisparity;
-    int numberOfDisparities;
-    int SADWindowSize;
-    int preFilterCap;
-    int uniquenessRatio;
-    int P1, P2;
-    int speckleWindowSize;
-    int speckleRange;
-    int disp12MaxDiff;
-    bool fullDP;
+    CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
+
+    CV_PROP_RW int minDisparity;
+    CV_PROP_RW int numberOfDisparities;
+    CV_PROP_RW int SADWindowSize;
+    CV_PROP_RW int preFilterCap;
+    CV_PROP_RW int uniquenessRatio;
+    CV_PROP_RW int P1;
+    CV_PROP_RW int P2;
+    CV_PROP_RW int speckleWindowSize;
+    CV_PROP_RW int speckleRange;
+    CV_PROP_RW int disp12MaxDiff;
+    CV_PROP_RW bool fullDP;
 
 protected:
     Mat buffer;
 };
 
 //! filters off speckles (small regions of incorrectly computed disparity)
-CV_EXPORTS void filterSpeckles( Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf );
+CV_EXPORTS_W void filterSpeckles( Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf );
 
 //! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
-CV_EXPORTS Rect getValidDisparityROI( Rect roi1, Rect roi2,
-                                int minDisparity, int numberOfDisparities,
-                                int SADWindowSize );
+CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2,
+                                        int minDisparity, int numberOfDisparities,
+                                        int SADWindowSize );
 
 //! validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
-CV_EXPORTS void validateDisparity( Mat& disparity, const Mat& cost,
-                                   int minDisparity, int numberOfDisparities,
-                                   int disp12MaxDisp=1 );
+CV_EXPORTS_W void validateDisparity( Mat& disparity, const Mat& cost,
+                                     int minDisparity, int numberOfDisparities,
+                                     int disp12MaxDisp=1 );
 
 //! reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
-CV_EXPORTS void reprojectImageTo3D( const Mat& disparity,
-                                    Mat& _3dImage, const Mat& Q,
-                                    bool handleMissingValues=false );
+CV_EXPORTS_W void reprojectImageTo3D( const Mat& disparity,
+                                      CV_OUT Mat& _3dImage, const Mat& Q,
+                                      bool handleMissingValues=false );
     
 }
 

modules/calib3d/src/calibration.cpp

@@ -3097,6 +3097,7 @@ static void collectCalibrationData( const vector<vector<Point3f> >& 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<vector<Point3f> >& 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<vector<Point3f> >& 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<vector<Point3f> >& 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<vector<Point2f> >& 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<vector<Point2f> >& imgpt1,

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<uchar>* mask )
 {
-    CV_Assert(points1.isContinuous() && points2.isContinuous() &&
-              points1.type() == points2.type() &&
-              ((points1.rows == 1 && points1.channels() == 2) ||
-               points1.cols*points1.channels() == 2) &&
-              ((points2.rows == 1 && points2.channels() == 2) ||
-               points2.cols*points2.channels() == 2));
+    CV_Assert(points1.checkVector(2) >= 0 && points2.checkVector(2) >= 0 &&
+              (points1.depth() == CV_32F || points1.depth() == CV_32S) &&
+              points1.depth() == points2.depth());
     
     Mat F(3, 3, CV_64F);
     CvMat _pt1 = Mat(points1), _pt2 = Mat(points2);
@@ -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<Vec3f>& lines )
 {
-    CV_Assert(points.isContinuous() &&
-              (points.depth() == CV_32S || points.depth() == CV_32F) &&
-              ((points.rows == 1 && points.channels() == 2) ||
-               points.cols*points.channels() == 2));
+    CV_Assert(points.checkVector(2) >= 0 &&
+              (points.depth() == CV_32F || points.depth() == CV_32S));
     
     lines.resize(points.cols*points.rows*points.channels()/2);
     CvMat _points = points, _lines = Mat(lines), matF = F;
@@ -1139,10 +1134,8 @@ void cv::computeCorrespondEpilines( const Mat& points, int whichImage,
 
 void cv::convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst )
 {
-    CV_Assert(src.isContinuous() &&
-              (src.depth() == CV_32S || src.depth() == CV_32F) &&
-              ((src.rows == 1 && src.channels() == 2) ||
-               src.cols*src.channels() == 2));
+    CV_Assert(src.checkVector(2) >= 0 &&
+              (src.depth() == CV_32F || src.depth() == CV_32S));
     
     dst.resize(src.cols*src.rows*src.channels()/2);
     CvMat _src = src, _dst = Mat(dst);
@@ -1151,10 +1144,8 @@ void cv::convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst )
 
 void cv::convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst )
 {
-    CV_Assert(src.isContinuous() &&
-              (src.depth() == CV_32S || src.depth() == CV_32F) &&
-              ((src.rows == 1 && src.channels() == 3) ||
-               src.cols*src.channels() == 3));
+    CV_Assert(src.checkVector(3) >= 0 &&
+              (src.depth() == CV_32F || src.depth() == CV_32S));
     
     dst.resize(src.cols*src.rows*src.channels()/3);
     CvMat _src = Mat(src), _dst = Mat(dst);

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<typename _Tp> void copyTo( vector<_Tp>& v ) const;
     //! copies those matrix elements to "m" that are marked with non-zero mask elements.
     void copyTo( Mat& m, const Mat& mask ) const;
     //! converts matrix to another datatype with optional scalng. See cvConvertScale.
@@ -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_cast<uchar>abs(src(i)*alpha+beta)
-CV_EXPORTS void convertScaleAbs(const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0);
+CV_EXPORTS_W void convertScaleAbs(const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0);
 //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
-CV_EXPORTS void LUT(const Mat& src, const Mat& lut, CV_OUT Mat& dst);
+CV_EXPORTS_W void LUT(const Mat& src, const Mat& lut, CV_OUT Mat& dst);
 
 //! computes sum of array elements
-CV_EXPORTS Scalar sum(const Mat& src);
+CV_EXPORTS_W Scalar sum(const Mat& src);
 //! computes the number of nonzero array elements
-CV_EXPORTS int countNonZero( const Mat& src );
+CV_EXPORTS_W int countNonZero( const Mat& src );
 
 //! computes mean value of array elements
 CV_EXPORTS Scalar mean(const Mat& src);
 //! computes mean value of selected array elements
-CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask);
+CV_EXPORTS_W Scalar mean(const Mat& src, const Mat& mask CV_WRAP_DEFAULT(Mat()));
 //! computes mean value and standard deviation of all or selected array elements
-CV_EXPORTS void meanStdDev(const Mat& src, CV_OUT Scalar& mean, CV_OUT Scalar& stddev, const Mat& mask=Mat());
+CV_EXPORTS_W void meanStdDev(const Mat& src, CV_OUT Scalar& mean, CV_OUT Scalar& stddev, const Mat& mask=Mat());
 //! computes norm of array
-CV_EXPORTS double norm(const Mat& src, int normType=NORM_L2);
+CV_EXPORTS double norm(const Mat& src1, int normType=NORM_L2);
 //! computes norm of the difference between two arrays
 CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType=NORM_L2);
 //! computes norm of the selected array part
-CV_EXPORTS double norm(const Mat& src, int normType, const Mat& mask);
+CV_EXPORTS_W double norm(const Mat& src1, int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
 //! computes norm of selected part of the difference between two arrays
-CV_EXPORTS double norm(const Mat& src1, const Mat& src2,
-                       int normType, const Mat& mask);
+CV_EXPORTS_W double norm(const Mat& src1, const Mat& src2,
+                       int normType, const Mat& mask CV_WRAP_DEFAULT(Mat()));
 //! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values 
-CV_EXPORTS void normalize( const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0,
+CV_EXPORTS_W void normalize( const Mat& src, CV_OUT Mat& dst, double alpha=1, double beta=0,
                            int norm_type=NORM_L2, int rtype=-1, const Mat& mask=Mat());
 
 //! finds global minimum and maximum array elements and returns their values and their locations
-CV_EXPORTS void minMaxLoc(const Mat& src, CV_OUT double* minVal,
+CV_EXPORTS_W void minMaxLoc(const Mat& src, CV_OUT double* minVal,
                           CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0,
                           CV_OUT Point* maxLoc=0, const Mat& mask=Mat());
-CV_EXPORTS void minMaxIdx(const Mat& src, double* minVal,
-                          double* maxVal,
-                          CV_OUT CV_CARRAY(src.dims) int* minIdx=0,
-                          CV_OUT CV_CARRAY(src.dims) int* maxIdx=0,
-                          const Mat& mask=Mat());
+CV_EXPORTS void minMaxIdx(const Mat& src, double* minVal, double* maxVal,
+                          int* minIdx=0, int* maxIdx=0, const Mat& mask=Mat());
     
 //! transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
-CV_EXPORTS void reduce(const Mat& src, CV_OUT Mat& dst, int dim, int rtype, int dtype=-1);
+CV_EXPORTS_W void reduce(const Mat& src, CV_OUT Mat& dst, int dim, int rtype, int dtype=-1);
 //! makes multi-channel array out of several single-channel arrays
-CV_EXPORTS void merge(CV_CARRAY(count) const Mat* mv, size_t count, CV_OUT Mat& dst);
+CV_EXPORTS void merge(const Mat* mv, size_t count, CV_OUT Mat& dst);
 //! copies each plane of a multi-channel array to a dedicated array
-CV_EXPORTS void split(const Mat& src, CV_OUT CV_CARRAY(src.channels()) Mat* mvbegin);
+CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
+
+CV_WRAP static inline void merge(const vector<Mat>& mv, Mat& dst)
+{ merge(&mv[0], mv.size(), dst); }
 
+CV_WRAP static inline void split(const Mat& m, vector<Mat>& mv)
+{
+    mv.resize(m.channels());
+    if(m.channels() > 0)
+        split(m, &mv[0]);
+}        
+    
 //! copies selected channels from the input arrays to the selected channels of the output arrays
-CV_EXPORTS void mixChannels(CV_CARRAY(nsrcs) const Mat* src, size_t nsrcs, CV_CARRAY(ndsts) Mat* dst, size_t ndsts,
-                            CV_CARRAY(npairs*2) const int* fromTo, size_t npairs);
+CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
+                            const int* fromTo, size_t npairs);
+
+static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
+                               const int* fromTo, int npairs)
+{
+    mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
+}
+    
+
 //! reverses the order of the rows, columns or both in a matrix
-CV_EXPORTS void flip(const Mat& src, CV_OUT Mat& dst, int flipCode);
+CV_EXPORTS_W void flip(const Mat& src, CV_OUT Mat& dst, int flipCode);
 
 //! replicates the input matrix the specified number of times in the horizontal and/or vertical direction
-CV_EXPORTS void repeat(const Mat& src, int ny, int nx, CV_OUT Mat& dst);
+CV_EXPORTS_W void repeat(const Mat& src, int ny, int nx, CV_OUT Mat& dst);
 static inline Mat repeat(const Mat& src, int ny, int nx)
 {
     if( nx == 1 && ny == 1 ) return src;
@@ -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 <cmpop> src2)
-CV_EXPORTS void compare(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int cmpop);
+CV_EXPORTS_W void compare(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int cmpop);
 //! compares elements of array with scalar (dst = src1 <cmpop> src2)
-CV_EXPORTS void compare(const Mat& src1, double s, CV_OUT Mat& dst, int cmpop);
+CV_EXPORTS_W void compare(const Mat& src1, double s, CV_OUT Mat& dst, int cmpop);
 //! computes per-element minimum of two arrays (dst = min(src1, src2))
-CV_EXPORTS void min(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void min(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
 //! computes per-element minimum of array and scalar (dst = min(src1, src2))
-CV_EXPORTS void min(const Mat& src1, double src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void min(const Mat& src1, double src2, CV_OUT Mat& dst);
 //! computes per-element maximum of two arrays (dst = max(src1, src2))
-CV_EXPORTS void max(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void max(const Mat& src1, const Mat& src2, CV_OUT Mat& dst);
 //! computes per-element maximum of array and scalar (dst = max(src1, src2))
-CV_EXPORTS void max(const Mat& src1, double src2, CV_OUT Mat& dst);
+CV_EXPORTS_W void max(const Mat& src1, double src2, CV_OUT Mat& dst);
 
 //! computes square root of each matrix element (dst = src**0.5)
-CV_EXPORTS void sqrt(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void sqrt(const Mat& src, CV_OUT Mat& dst);
 //! raises the input matrix elements to the specified power (b = a**power) 
-CV_EXPORTS void pow(const Mat& src, double power, CV_OUT Mat& dst);
+CV_EXPORTS_W void pow(const Mat& src, double power, CV_OUT Mat& dst);
 //! computes exponent of each matrix element (dst = e**src)
-CV_EXPORTS void exp(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void exp(const Mat& src, CV_OUT Mat& dst);
 //! computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
-CV_EXPORTS void log(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void log(const Mat& src, CV_OUT Mat& dst);
 //! computes cube root of the argument
-CV_EXPORTS float cubeRoot(float val);
+CV_EXPORTS_W float cubeRoot(float val);
 //! computes the angle in degrees (0..360) of the vector (x,y)
-CV_EXPORTS float fastAtan2(float y, float x);
+CV_EXPORTS_W float fastAtan2(float y, float x);
 //! converts polar coordinates to Cartesian
-CV_EXPORTS void polarToCart(const Mat& magnitude, const Mat& angle,
+CV_EXPORTS_W void polarToCart(const Mat& magnitude, const Mat& angle,
                             CV_OUT Mat& x, CV_OUT Mat& y, bool angleInDegrees=false);
 //! converts Cartesian coordinates to polar
-CV_EXPORTS void cartToPolar(const Mat& x, const Mat& y,
+CV_EXPORTS_W void cartToPolar(const Mat& x, const Mat& y,
                             CV_OUT Mat& magnitude, CV_OUT Mat& angle,
                             bool angleInDegrees=false);
 //! computes angle (angle(i)) of each (x(i), y(i)) vector
-CV_EXPORTS void phase(const Mat& x, const Mat& y, CV_OUT Mat& angle,
-                      bool angleInDegrees=false);
+CV_EXPORTS_W void phase(const Mat& x, const Mat& y, CV_OUT Mat& angle,
+                        bool angleInDegrees=false);
 //! computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
-CV_EXPORTS void magnitude(const Mat& x, const Mat& y, CV_OUT Mat& magnitude);
+CV_EXPORTS_W void magnitude(const Mat& x, const Mat& y, CV_OUT Mat& magnitude);
 //! checks that each matrix element is within the specified range.
-CV_EXPORTS bool checkRange(const Mat& a, bool quiet=true, CV_OUT Point* pt=0,
-                           double minVal=-DBL_MAX, double maxVal=DBL_MAX);
+CV_EXPORTS_W bool checkRange(const Mat& a, bool quiet=true, CV_OUT Point* pt=0,
+                            double minVal=-DBL_MAX, double maxVal=DBL_MAX);
 //! implements generalized matrix product algorithm GEMM from BLAS
-CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
-                     const Mat& src3, double gamma, CV_OUT Mat& dst, int flags=0);
+CV_EXPORTS_W void gemm(const Mat& src1, const Mat& src2, double alpha,
+                       const Mat& src3, double gamma, CV_OUT Mat& dst, int flags=0);
 //! multiplies matrix by its transposition from the left or from the right
-CV_EXPORTS void mulTransposed( const Mat& src, CV_OUT Mat& dst, bool aTa,
-                               const Mat& delta=Mat(),
-                               double scale=1, int rtype=-1 );
+CV_EXPORTS_W void mulTransposed( const Mat& src, CV_OUT Mat& dst, bool aTa,
+                                 const Mat& delta=Mat(),
+                                 double scale=1, int rtype=-1 );
 //! transposes the matrix
-CV_EXPORTS void transpose(const Mat& src, CV_OUT Mat& dst);
+CV_EXPORTS_W void transpose(const Mat& src, CV_OUT Mat& dst);
 //! performs affine transformation of each element of multi-channel input matrix
-CV_EXPORTS void transform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
+CV_EXPORTS_W void transform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
 //! performs perspective transformation of each element of multi-channel input matrix
-CV_EXPORTS void perspectiveTransform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
+CV_EXPORTS_W void perspectiveTransform(const Mat& src, CV_OUT Mat& dst, const Mat& m );
 
 //! extends the symmetrical matrix from the lower half or from the upper half 
-CV_EXPORTS void completeSymm(Mat& mtx, bool lowerToUpper=false);
+CV_EXPORTS_W void completeSymm(Mat& mtx, bool lowerToUpper=false);
 //! initializes scaled identity matrix
-CV_EXPORTS void setIdentity(Mat& mtx, const Scalar& s=Scalar(1));
+CV_EXPORTS_W void setIdentity(Mat& mtx, const Scalar& s=Scalar(1));
 //! computes determinant of a square matrix
-CV_EXPORTS double determinant(const Mat& mtx);
+CV_EXPORTS_W double determinant(const Mat& mtx);
 //! computes trace of a matrix
-CV_EXPORTS Scalar trace(const Mat& mtx);
+CV_EXPORTS_W Scalar trace(const Mat& mtx);
 //! computes inverse or pseudo-inverse matrix
-CV_EXPORTS double invert(const Mat& src, CV_OUT Mat& dst, int flags=DECOMP_LU);
+CV_EXPORTS_W double invert(const Mat& src, CV_OUT Mat& dst, int flags=DECOMP_LU);
 //! solves linear system or a least-square problem
-CV_EXPORTS bool solve(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int flags=DECOMP_LU);
+CV_EXPORTS_W bool solve(const Mat& src1, const Mat& src2, CV_OUT Mat& dst, int flags=DECOMP_LU);
 //! sorts independently each matrix row or each matrix column
-CV_EXPORTS void sort(const Mat& src, CV_OUT Mat& dst, int flags);
+CV_EXPORTS_W void sort(const Mat& src, CV_OUT Mat& dst, int flags);
 //! sorts independently each matrix row or each matrix column
-CV_EXPORTS void sortIdx(const Mat& src, CV_OUT Mat& dst, int flags);
+CV_EXPORTS_W void sortIdx(const Mat& src, CV_OUT Mat& dst, int flags);
 //! finds real roots of a cubic polynomial
-CV_EXPORTS int solveCubic(const Mat& coeffs, CV_OUT Mat& roots);
+CV_EXPORTS_W int solveCubic(const Mat& coeffs, CV_OUT Mat& roots);
 //! finds real and complex roots of a polynomial
-CV_EXPORTS double solvePoly(const Mat& coeffs, CV_OUT Mat& roots, int maxIters=300);
+CV_EXPORTS_W double solvePoly(const Mat& coeffs, CV_OUT Mat& roots, int maxIters=300);
 //! finds eigenvalues of a symmetric matrix
 CV_EXPORTS bool eigen(const Mat& src, CV_OUT Mat& eigenvalues, int lowindex=-1,
                       int highindex=-1);
@@ -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<typename _Tp, int m, int n, int nm> 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<typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
 
 //! fills array with uniformly-distributed random numbers from the range [low, high)
-static inline void randu(CV_OUT Mat& dst, const Scalar& low, const Scalar& high)
+CV_WRAP static inline void randu(CV_OUT Mat& dst, const Scalar& low, const Scalar& high)
 { theRNG().fill(dst, RNG::UNIFORM, low, high); }
     
 //! fills array with normally-distributed random numbers with the specified mean and the standard deviation
-static inline void randn(CV_OUT Mat& dst, const Scalar& mean, const Scalar& stddev)
+CV_WRAP static inline void randn(CV_OUT Mat& dst, const Scalar& mean, const Scalar& stddev)
 { theRNG().fill(dst, RNG::NORMAL, mean, stddev); }
 
 //! shuffles the input array elements
-CV_EXPORTS void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0);
+CV_EXPORTS_W void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0);
 
 //! draws the line segment (pt1, pt2) in the image
-CV_EXPORTS void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
+CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
                      int thickness=1, int lineType=8, int shift=0);
 
 //! draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
-CV_EXPORTS void rectangle(Mat& img, Point pt1, Point pt2,
+CV_EXPORTS_W void rectangle(Mat& img, Point pt1, Point pt2,
                           const Scalar& color, int thickness=1,
                           int lineType=8, int shift=0);
     
@@ -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<Point>& 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<Node> nodes; //!< all the tree nodes
-    Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set.
-    int maxDepth; //!< maximum depth of the search tree. Do not modify it
-    int normType; //!< type of the distance (cv::NORM_L1 or cv::NORM_L2) used for search. Initially set to cv::NORM_L2, but you can modify it
+    CV_PROP Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set.
+    CV_PROP int maxDepth; //!< maximum depth of the search tree. Do not modify it
+    CV_PROP_RW int normType; //!< type of the distance (cv::NORM_L1 or cv::NORM_L2) used for search. Initially set to cv::NORM_L2, but you can modify it
 };
 
 //////////////////////////////////////// XML & YAML I/O ////////////////////////////////////
@@ -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<CvFileStorage> 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 *();

modules/core/include/opencv2/core/mat.hpp

@@ -608,14 +608,25 @@ template<typename _Tp> inline MatIterator_<_Tp> Mat::end()
     return it;
 }
 
-template<typename _Tp> inline Mat::operator vector<_Tp>() const
+    
+template<typename _Tp> inline void Mat::copyTo(vector<_Tp>& v) const
 {
-    if( empty() )
-        return vector<_Tp>();
-    CV_Assert( dims >= 1 && DataType<_Tp>::channels == channels());
-    vector<_Tp> v(total());
-    Mat temp(dims, size.p, type(), &v[0]);
+    int n = checkVector(DataType<_Tp>::channels);
+    if( empty() || n == 0 )
+    {
+        v.clear();
+        return;
+    }
+    CV_Assert( n > 0 );
+    v.resize(n);
+    Mat temp(dims, size.p, DataType<_Tp>::type, &v[0]);
     convertTo(temp, DataType<_Tp>::type);
+}    
+    
+template<typename _Tp> inline Mat::operator vector<_Tp>() const
+{
+    vector<_Tp> v;
+    copyTo(v);
     return v;
 }
 
@@ -1011,7 +1022,9 @@ template<typename _Tp> inline const _Tp& Mat_<_Tp>::operator ()(int i0, int i1,
     
 template<typename _Tp> inline Mat_<_Tp>::operator vector<_Tp>() const
 {
-    return this->Mat::operator vector<_Tp>();
+    vector<_Tp> v;
+    copyTo(v);
+    return v;
 }
 
 template<typename _Tp> template<int n> inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>() const
@@ -1025,7 +1038,7 @@ template<typename _Tp> template<int m, int n> inline Mat_<_Tp>::operator Matx<ty
     CV_Assert(n % DataType<_Tp>::channels == 0);
     return this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
 }    
-    
+
 template<typename T1, typename T2, typename Op> inline void
 process( const Mat_<T1>& m1, Mat_<T2>& m2, Op op )
 {
@@ -1522,26 +1535,10 @@ operator ^= (const Mat_<_Tp>& a, const Scalar& s)
 }        
 
 /////////////////////////////// Miscellaneous operations //////////////////////////////
-
-static inline void merge(const vector<Mat>& mv, Mat& dst)
-{ merge(&mv[0], mv.size(), dst); }
-
-static inline void split(const Mat& m, vector<Mat>& mv)
-{
-    mv.resize(m.channels());
-    if(m.channels() > 0)
-        split(m, &mv[0]);
-}    
     
 template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
 { split(src, (vector<Mat>&)mv ); }
 
-static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
-                               const int* fromTo, int npairs)
-{
-    mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
-}
- 
 //////////////////////////////////////////////////////////////
     
 template<typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols)

modules/core/include/opencv2/core/operations.hpp

@@ -2494,10 +2494,10 @@ template<> CV_EXPORTS void Ptr<CvFileStorage>::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<typename _Tp> 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<typename _Tp> 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

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

modules/core/src/arithm.cpp

@@ -1530,8 +1530,6 @@ void compare( const Mat& src1, double value, Mat& dst, int cmpOp )
         binarySOpC1_<CmpGE<double> >, 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);

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
 \*************************************************************************************************/

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<KeyPoint>& keypoints);
+CV_EXPORTS_W void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints);
 //! reads vector of keypoints from the specified file storage node
-CV_EXPORTS void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);    
+CV_EXPORTS_W void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);    
 
 /*!
  SIFT implementation.
@@ -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<KeyPoint>& 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<KeyPoint>& keypoints,
                     int maxCount=0, bool scaleCoords=true) const;
-    CV_WRAP_AS(detect) void operator()(const vector<Mat>& pyr,
+    void operator()(const vector<Mat>& pyr,
                     CV_OUT vector<KeyPoint>& keypoints,
                     int maxCount=0, bool scaleCoords=true) const;
     void getMostStable2D(const Mat& image, CV_OUT vector<KeyPoint>& keypoints,
@@ -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<Point2f>& corners) const;
-    CV_WRAP_AS(detect) bool operator()(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
+    bool operator()(const Mat& image, CV_OUT Mat& H, CV_OUT vector<Point2f>& corners) const;
+    bool operator()(const vector<Mat>& pyr, const vector<KeyPoint>& keypoints,
                                        CV_OUT Mat& H, CV_OUT vector<Point2f>& corners,
                                        CV_OUT vector<int>* pairs=0) const;
     

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<int>& params=vector<int>());
-CV_EXPORTS Mat imdecode( const Mat& buf, int flags );
-CV_EXPORTS bool imencode( const string& ext, const Mat& img,
+CV_EXPORTS_W Mat imdecode( const Mat& buf, int flags );
+CV_EXPORTS_W bool imencode( const string& ext, const Mat& img,
                           CV_OUT vector<uchar>& buf,
                           const vector<int>& params=vector<int>());
 
-CV_EXPORTS int waitKey(int delay=0);
+CV_EXPORTS_W int waitKey(int delay=0);
 
 #ifndef CV_NO_VIDEO_CAPTURE_CPP_API
 
 template<> void CV_EXPORTS Ptr<CvCapture>::delete_obj();
 template<> void CV_EXPORTS Ptr<CvVideoWriter>::delete_obj();
 
-class CV_EXPORTS VideoCapture
+class CV_EXPORTS_W VideoCapture
 {
 public:
-    VideoCapture();
-    VideoCapture(const string& filename);
-    VideoCapture(int device);
+    CV_WRAP VideoCapture();
+    CV_WRAP VideoCapture(const string& filename);
+    CV_WRAP VideoCapture(int device);
     
     virtual ~VideoCapture();
-    virtual bool open(const string& filename);
-    virtual bool open(int device);
-    virtual bool isOpened() const;
-    virtual void release();
+    CV_WRAP virtual bool open(const string& filename);
+    CV_WRAP virtual bool open(int device);
+    CV_WRAP virtual bool isOpened() const;
+    CV_WRAP virtual void release();
     
-    virtual bool grab();
-    virtual bool retrieve(CV_OUT Mat& image, int channel=0);
-    virtual VideoCapture& operator >> (Mat& image);
+    CV_WRAP virtual bool grab();
+    CV_WRAP virtual bool retrieve(CV_OUT Mat& image, int channel=0);
+    CV_WRAP_AS(read) virtual VideoCapture& operator >> (CV_OUT Mat& image);
     
-    virtual bool set(int propId, double value);
-    virtual double get(int propId);
+    CV_WRAP virtual bool set(int propId, double value);
+    CV_WRAP virtual double get(int propId);
     
 protected:
     Ptr<CvCapture> cap;
 };
 
     
-class CV_EXPORTS VideoWriter
+class CV_EXPORTS_W VideoWriter
 {
 public:    
-    VideoWriter();
-    VideoWriter(const string& filename, int fourcc, double fps,
+    CV_WRAP VideoWriter();
+    CV_WRAP VideoWriter(const string& filename, int fourcc, double fps,
                 Size frameSize, bool isColor=true);
     
     virtual ~VideoWriter();
-    virtual bool open(const string& filename, int fourcc, double fps,
+    CV_WRAP virtual bool open(const string& filename, int fourcc, double fps,
                       Size frameSize, bool isColor=true);
-    virtual bool isOpened() const;
-    virtual VideoWriter& operator << (const Mat& image);
+    CV_WRAP virtual bool isOpened() const;
+    CV_WRAP_AS(write) virtual VideoWriter& operator << (const Mat& image);
     
 protected:
     Ptr<CvVideoWriter> writer;

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<FilterEngine> 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<FilterEngine> createGaussianFilter( int type, Size ksize,
                                     double sigma1, double sigma2=0,
                                     int borderType=BORDER_DEFAULT);
 //! initializes kernels of the generalized Sobel operator
-CV_EXPORTS void getDerivKernels( CV_OUT Mat& kx, CV_OUT Mat& ky,
+CV_EXPORTS_W void getDerivKernels( CV_OUT Mat& kx, CV_OUT Mat& ky,
                                  int dx, int dy, int ksize,
                                  bool normalize=false, int ktype=CV_32F );
 //! returns filter engine for the generalized Sobel operator
@@ -370,32 +370,32 @@ CV_EXPORTS Ptr<FilterEngine> 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<IplConvKernel>::delete_obj();
 
 //! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode 
-CV_EXPORTS void copyMakeBorder( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void copyMakeBorder( const Mat& src, CV_OUT Mat& dst,
                                 int top, int bottom, int left, int right,
                                 int borderType, const Scalar& value=Scalar() );
 
 //! smooths the image using median filter.
-CV_EXPORTS void medianBlur( const Mat& src, CV_OUT Mat& dst, int ksize );
+CV_EXPORTS_W void medianBlur( const Mat& src, CV_OUT Mat& dst, int ksize );
 //! smooths the image using Gaussian filter.
-CV_EXPORTS void GaussianBlur( const Mat& src, CV_OUT Mat& dst, Size ksize,
+CV_EXPORTS_W void GaussianBlur( const Mat& src, CV_OUT Mat& dst, Size ksize,
                               double sigma1, double sigma2=0,
                               int borderType=BORDER_DEFAULT );
 //! smooths the image using bilateral filter
-CV_EXPORTS void bilateralFilter( const Mat& src, CV_OUT Mat& dst, int d,
+CV_EXPORTS_W void bilateralFilter( const Mat& src, CV_OUT Mat& dst, int d,
                                  double sigmaColor, double sigmaSpace,
                                  int borderType=BORDER_DEFAULT );
 //! smooths the image using the box filter. Each pixel is processed in O(1) time
-CV_EXPORTS void boxFilter( const Mat& src, CV_OUT Mat& dst, int ddepth,
+CV_EXPORTS_W void boxFilter( const Mat& src, CV_OUT Mat& dst, int ddepth,
                            Size ksize, Point anchor=Point(-1,-1),
                            bool normalize=true,
                            int borderType=BORDER_DEFAULT );
 //! a synonym for normalized box filter
-static inline void blur( const Mat& src, CV_OUT Mat& dst,
+CV_WRAP static inline void blur( const Mat& src, CV_OUT Mat& dst,
                          Size ksize, Point anchor=Point(-1,-1),
                          int borderType=BORDER_DEFAULT )
 {
@@ -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<Vec3f>& 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<Mat>& dst, int maxlevel );
 
 //! corrects lens distortion for the given camera matrix and distortion coefficients
-CV_EXPORTS void undistort( const Mat& src, CV_OUT Mat& dst, const Mat& cameraMatrix,
+CV_EXPORTS_W void undistort( const Mat& src, CV_OUT Mat& dst, const Mat& cameraMatrix,
                            const Mat& distCoeffs, const Mat& newCameraMatrix=Mat() );
 //! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
-CV_EXPORTS void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs,
+CV_EXPORTS_W void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs,
                            const Mat& R, const Mat& newCameraMatrix,
                            Size size, int m1type, CV_OUT Mat& map1, CV_OUT Mat& map2 );
 
@@ -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<Point2f>& dst,
                                  const Mat& cameraMatrix, const Mat& distCoeffs,
                                  const Mat& R=Mat(), const Mat& P=Mat());
 //! returns points' coordinates after lens distortion correction
-CV_EXPORTS void undistortPoints( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void undistortPoints( const Mat& src, CV_OUT Mat& dst,
                                  const Mat& cameraMatrix, const Mat& distCoeffs,
                                  const Mat& R=Mat(), const Mat& P=Mat());
 
 template<> CV_EXPORTS void Ptr<CvHistogram>::delete_obj();
     
 //! computes the joint dense histogram for a set of images.
-CV_EXPORTS void calcHist( CV_CARRAY(nimages) const Mat* images, int nimages,
-                          CV_CARRAY(dims) const int* channels, const Mat& mask,
-                          CV_OUT Mat& hist, int dims, CV_CARRAY(dims) const int* histSize,
-                          CV_CUSTOM_CARRAY((dims,histSize,uniform)) const float** ranges,
-                          bool uniform=true, bool accumulate=false );
+CV_EXPORTS void calcHist( const Mat* images, int nimages,
+                          const int* channels, const Mat& mask,
+                          Mat& hist, int dims, const int* histSize,
+                          const float** ranges, bool uniform=true, bool accumulate=false );
 
 //! computes the joint sparse histogram for a set of images.
-CV_EXPORTS void calcHist( CV_CARRAY(nimages) const Mat* images, int nimages,
-                          CV_CARRAY(dims) const int* channels, const Mat& mask,
-                          CV_OUT SparseMat& hist, int dims, CV_CARRAY(dims) const int* histSize,
-                          CV_CUSTOM_CARRAY((dims,histSize,uniform)) const float** ranges,
+CV_EXPORTS void calcHist( const Mat* images, int nimages,
+                          const int* channels, const Mat& mask,
+                          SparseMat& hist, int dims,
+                          const int* histSize, const float** ranges,
                           bool uniform=true, bool accumulate=false );
 
 //! computes back projection for the set of images
-CV_EXPORTS void calcBackProject( CV_CARRAY(nimages) const Mat* images, int nimages,
-                                 CV_CARRAY(hist.dims) const int* channels, const Mat& hist,
-                                 CV_OUT Mat& backProject,
-                                 CV_CUSTOM_CARRAY(hist) const float** ranges,
+CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
+                                 const int* channels, const Mat& hist,
+                                 Mat& backProject, const float** ranges,
                                  double scale=1, bool uniform=true );
 
 //! computes back projection for the set of images
-CV_EXPORTS void calcBackProject( CV_CARRAY(nimages) const Mat* images, int nimages,
-                                 CV_CARRAY(hist.dims()) const int* channels,
-                                 const SparseMat& hist, CV_OUT Mat& backProject,
-                                 CV_CUSTOM_CARRAY(hist) const float** ranges,
+CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
+                                 const int* channels, const SparseMat& hist, 
+                                 Mat& backProject, const float** ranges,
                                  double scale=1, bool uniform=true );
 
 //! compares two histograms stored in dense arrays
-CV_EXPORTS double compareHist( const Mat& H1, const Mat& H2, int method );
+CV_EXPORTS_W double compareHist( const Mat& H1, const Mat& H2, int method );
 
 //! compares two histograms stored in sparse arrays
 CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
 
 //! normalizes the grayscale image brightness and contrast by normalizing its histogram
-CV_EXPORTS void equalizeHist( const Mat& src, CV_OUT Mat& dst );
+CV_EXPORTS_W void equalizeHist( const Mat& src, CV_OUT Mat& dst );
 
 //! segments the image using watershed algorithm
-CV_EXPORTS void watershed( const Mat& image, Mat& markers );
+CV_EXPORTS_W void watershed( const Mat& image, Mat& markers );
 
 //! filters image using meanshift algorithm
-CV_EXPORTS void pyrMeanShiftFiltering( const Mat& src, CV_OUT Mat& dst,
+CV_EXPORTS_W void pyrMeanShiftFiltering( const Mat& src, CV_OUT Mat& dst,
                     double sp, double sr, int maxLevel=1,
                     TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );
 
@@ -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<Point2f>& approxCurve,
                               double epsilon, bool closed );
 //! computes the contour perimeter (closed=true) or a curve length
-CV_EXPORTS double arcLength( const Mat& curve, bool closed );
+CV_EXPORTS_W double arcLength( const Mat& curve, bool closed );
 //! computes the bounding rectangle for a contour
-CV_EXPORTS Rect boundingRect( const Mat& points );
+CV_EXPORTS_W Rect boundingRect( const Mat& points );
 //! computes the contour area
-CV_EXPORTS double contourArea( const Mat& contour, bool oriented=false );
+CV_EXPORTS_W double contourArea( const Mat& contour, bool oriented=false );
 //! computes the minimal rotated rectangle for a set of points
-CV_EXPORTS RotatedRect minAreaRect( const Mat& points );
+CV_EXPORTS_W RotatedRect minAreaRect( const Mat& points );
 //! computes the minimal enclosing circle for a set of points
-CV_EXPORTS void minEnclosingCircle( const Mat& points,
+CV_EXPORTS_W void minEnclosingCircle( const Mat& points,
                                     Point2f& center, float& radius );    
 //! matches two contours using one of the available algorithms
-CV_EXPORTS double matchShapes( const Mat& contour1,
+CV_EXPORTS_W double matchShapes( const Mat& contour1,
                                const Mat& contour2,
                                int method, double parameter );
 //! computes convex hull for a set of 2D points.
@@ -830,28 +828,28 @@ CV_EXPORTS void convexHull( const Mat& points, CV_OUT vector<Point>& hull, bool
 CV_EXPORTS void convexHull( const Mat& points, CV_OUT vector<Point2f>& hull, bool clockwise=false );
 
 //! returns true iff the contour is convex. Does not support contours with self-intersection
-CV_EXPORTS bool isContourConvex( const Mat& contour );
+CV_EXPORTS_W bool isContourConvex( const Mat& contour );
 
 //! fits ellipse to the set of 2D points
-CV_EXPORTS RotatedRect fitEllipse( const Mat& points );
+CV_EXPORTS_W RotatedRect fitEllipse( const Mat& points );
 
 //! fits line to the set of 2D points using M-estimator algorithm
 CV_EXPORTS void fitLine( const Mat& points, CV_OUT Vec4f& line, int distType,
-                         double param, double reps, double aeps );
+                           double param, double reps, double aeps );
 //! fits line to the set of 3D points using M-estimator algorithm
 CV_EXPORTS void fitLine( const Mat& points, CV_OUT Vec6f& line, int distType,
-                         double param, double reps, double aeps );
+                           double param, double reps, double aeps );
 //! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
-CV_EXPORTS double pointPolygonTest( const Mat& contour,
+CV_EXPORTS_W double pointPolygonTest( const Mat& contour,
                                     Point2f pt, bool measureDist );
     
 //! estimates the best-fit affine transformation that maps one 2D point set to another or one image to another.
-CV_EXPORTS Mat estimateRigidTransform( const Mat& A, const Mat& B,
+CV_EXPORTS_W Mat estimateRigidTransform( const Mat& A, const Mat& B,
                                        bool fullAffine );
 
 //! computes the best-fit affine transformation that maps one 3D point set to another (RANSAC algorithm is used)
 CV_EXPORTS int estimateAffine3D(const Mat& from, const Mat& to, CV_OUT Mat& dst,
-                                vector<uchar>& outliers,
+                                CV_OUT vector<uchar>& outliers,
                                 double param1 = 3.0, double param2 = 0.99);
     
 }

modules/imgproc/src/contours.cpp

@@ -1627,12 +1627,11 @@ void cv::drawContours( Mat& image, const vector<vector<Point> >& contours,
                    -maxLevel : maxLevel, thickness, lineType, offset );
 }
 
+
 void cv::approxPolyDP( const Mat& curve, vector<Point>& approxCurve,
                        double epsilon, bool closed )
 {
-    CV_Assert(curve.isContinuous() && curve.depth() == CV_32S &&
-              ((curve.rows == 1 && curve.channels() == 2) ||
-               curve.cols*curve.channels() == 2));
+    CV_Assert(curve.checkVector(2, CV_32S) >= 0);
     CvMat _curve = curve;
     MemStorage storage(cvCreateMemStorage());
     Seq<Point> seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed));
@@ -1642,9 +1641,7 @@ void cv::approxPolyDP( const Mat& curve, vector<Point>& approxCurve,
 void cv::approxPolyDP( const Mat& curve, vector<Point2f>& approxCurve,
                        double epsilon, bool closed )
 {
-    CV_Assert(curve.isContinuous() && curve.depth() == CV_32F &&
-              ((curve.rows == 1 && curve.channels() == 2) ||
-               curve.cols*curve.channels() == 2));
+    CV_Assert(curve.checkVector(2, CV_32F) >= 0);
     CvMat _curve = curve;
     MemStorage storage(cvCreateMemStorage());
     Seq<Point2f> seq(cvApproxPoly(&_curve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed));
@@ -1653,10 +1650,7 @@ void cv::approxPolyDP( const Mat& curve, vector<Point2f>& 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*)&center, &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<int>& hull, bool clockwise )
 {
-    CV_Assert(points.isContinuous() &&
-              (points.depth() == CV_32S || points.depth() == CV_32F) &&
-              ((points.rows == 1 && points.channels() == 2) ||
-               points.cols*points.channels() == 2));
+    CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
     hull.resize(points.cols*points.rows*points.channels()/2);
     CvMat _points = Mat(points), _hull=Mat(hull);
     cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 0);
@@ -1740,9 +1715,7 @@ void cv::convexHull( const Mat& points, vector<int>& hull, bool clockwise )
 void cv::convexHull( const Mat& points,
                      vector<Point>& hull, bool clockwise )
 {
-    CV_Assert(points.isContinuous() && points.depth() == CV_32S &&
-              ((points.rows == 1 && points.channels() == 2) ||
-               points.cols*points.channels() == 2));
+    CV_Assert(points.checkVector(2, CV_32S) >= 0);
     hull.resize(points.cols*points.rows*points.channels()/2);
     CvMat _points = Mat(points), _hull=Mat(hull);
     cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 1);
@@ -1753,9 +1726,7 @@ void cv::convexHull( const Mat& points,
 void cv::convexHull( const Mat& points,
                      vector<Point2f>& hull, bool clockwise )
 {
-    CV_Assert(points.isContinuous() && points.depth() == CV_32F &&
-              ((points.rows == 1 && points.channels() == 2) ||
-               points.cols*points.channels() == 2));
+    CV_Assert(points.checkVector(2, CV_32F) >= 0);
     hull.resize(points.cols*points.rows*points.channels()/2);
     CvMat _points = Mat(points), _hull=Mat(hull);
     cvConvexHull2(&_points, &_hull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, 1);
@@ -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 );
 }

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<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
 
-    virtual void prune( CvSlice slice );
+    CV_WRAP virtual void prune( CvSlice slice );
 
-    virtual void clear();
+    CV_WRAP virtual void clear();
 
     virtual void write( CvFileStorage* storage, const char* name ) const;
     virtual void read( CvFileStorage* storage, CvFileNode* node );
@@ -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<s>*(bias+w*(x1+...+x4))), where x1,...x4 are some elements of X
-    // - is the vector used in computing of the activation function in backward
-    CvMat* exp2ssumWX;
-    // (x1+x2+x3+x4), where x1,...x4 are some elements of X
-    // - is the vector used in computing of the activation function in backward
-    CvMat* sumX;
-}CvCNNSubSamplingLayer;
-
-// Structure of the last layer.
-typedef struct CvCNNFullConnectLayer
-{
-    CV_CNN_LAYER_FIELDS();
-    // amplitude of sigmoid activation function
-    float a;
-    // scale parameter of sigmoid activation function
-    float s;
-    // exp2ssumWX = exp(2*<s>*(W*X)) - is the vector used in computing of the
-    // activation function and it's derivative by the formulae
-    // activ.func. = <a>(exp(2<s>WX)-1)/(exp(2<s>WX)+1) == <a> - 2<a>/(<exp2ssumWX> + 1)
-    // (activ.func.)' = 4<a><s>exp(2<s>WX)/(exp(2<s>WX)+1)^2
-    CvMat* exp2ssumWX;
-}CvCNNFullConnectLayer;
-
-typedef struct CvCNNetwork
-{
-    int n_layers;
-    CvCNNLayer* layers;
-    CvCNNetworkAddLayer add_layer;
-    CvCNNetworkRelease release;
-}CvCNNetwork;
-
-typedef struct CvCNNStatModel
-{
-    CV_STAT_MODEL_FIELDS();
-    CvCNNetwork* network;
-    // etalons are allocated as rows, the i-th etalon has label cls_labeles[i]
-    CvMat* etalons;
-    // classes labels
-    CvMat* cls_labels;
-}CvCNNStatModel;
-
-typedef struct CvCNNStatModelParams
-{
-    CV_STAT_MODEL_PARAM_FIELDS();
-    // network must be created by the functions cvCreateCNNetwork and <add_layer>
-    CvCNNetwork* network;
-    CvMat* etalons;
-    // termination criteria
-    int max_iter;
-    int start_iter;
-    int grad_estim_type;
-}CvCNNStatModelParams;
-
-CVAPI(CvCNNLayer*) cvCreateCNNConvolutionLayer(
-    int n_input_planes, int input_height, int input_width,
-    int n_output_planes, int K,
-    float init_learn_rate, int learn_rate_decrease_type,
-    CvMat* connect_mask CV_DEFAULT(0), CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNLayer*) cvCreateCNNSubSamplingLayer(
-    int n_input_planes, int input_height, int input_width,
-    int sub_samp_scale, float a, float s,
-    float init_learn_rate, int learn_rate_decrease_type, CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNLayer*) cvCreateCNNFullConnectLayer(
-    int n_inputs, int n_outputs, float a, float s,
-    float init_learn_rate, int learning_type, CvMat* weights CV_DEFAULT(0) );
-
-CVAPI(CvCNNetwork*) cvCreateCNNetwork( CvCNNLayer* first_layer );
-
-CVAPI(CvStatModel*) cvTrainCNNClassifier(
-            const CvMat* train_data, int tflag,
-            const CvMat* responses,
-            const CvStatModelParams* params,
-            const CvMat* CV_DEFAULT(0),
-            const CvMat* sample_idx CV_DEFAULT(0),
-            const CvMat* CV_DEFAULT(0), const CvMat* CV_DEFAULT(0) );
-
-/****************************************************************************************\
-*                               Estimate classifiers algorithms                          *
-\****************************************************************************************/
-typedef const CvMat* (CV_CDECL *CvStatModelEstimateGetMat)
-                    ( const CvStatModel* estimateModel );
-
-typedef int (CV_CDECL *CvStatModelEstimateNextStep)
-                    ( CvStatModel* estimateModel );
-
-typedef void (CV_CDECL *CvStatModelEstimateCheckClassifier)
-                    ( CvStatModel* estimateModel,
-                const CvStatModel* model,
-                const CvMat*       features,
-                      int          sample_t_flag,
-                const CvMat*       responses );
-
-typedef void (CV_CDECL *CvStatModelEstimateCheckClassifierEasy)
-                    ( CvStatModel* estimateModel,
-                const CvStatModel* model );
-
-typedef float (CV_CDECL *CvStatModelEstimateGetCurrentResult)
-                    ( const CvStatModel* estimateModel,
-                            float*       correlation );
-
-typedef void (CV_CDECL *CvStatModelEstimateReset)
-                    ( CvStatModel* estimateModel );
-
-//-------------------------------- Cross-validation --------------------------------------
-#define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS()    \
-    CV_STAT_MODEL_PARAM_FIELDS();                                 \
-    int     k_fold;                                               \
-    int     is_regression;                                        \
-    CvRNG*  rng
-
-typedef struct CvCrossValidationParams
-{
-    CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_PARAM_FIELDS();
-} CvCrossValidationParams;
-
-#define CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS()    \
-    CvStatModelEstimateGetMat               getTrainIdxMat; \
-    CvStatModelEstimateGetMat               getCheckIdxMat; \
-    CvStatModelEstimateNextStep             nextStep;       \
-    CvStatModelEstimateCheckClassifier      check;          \
-    CvStatModelEstimateGetCurrentResult     getResult;      \
-    CvStatModelEstimateReset                reset;          \
-    int     is_regression;                                  \
-    int     folds_all;                                      \
-    int     samples_all;                                    \
-    int*    sampleIdxAll;                                   \
-    int*    folds;                                          \
-    int     max_fold_size;                                  \
-    int         current_fold;                               \
-    int         is_checked;                                 \
-    CvMat*      sampleIdxTrain;                             \
-    CvMat*      sampleIdxEval;                              \
-    CvMat*      predict_results;                            \
-    int     correct_results;                                \
-    int     all_results;                                    \
-    double  sq_error;                                       \
-    double  sum_correct;                                    \
-    double  sum_predict;                                    \
-    double  sum_cc;                                         \
-    double  sum_pp;                                         \
-    double  sum_cp
-
-typedef struct CvCrossValidationModel
-{
-    CV_STAT_MODEL_FIELDS();
-    CV_CROSS_VALIDATION_ESTIMATE_CLASSIFIER_FIELDS();
-} CvCrossValidationModel;
-
-CVAPI(CvStatModel*)
-cvCreateCrossValidationEstimateModel
-           ( int                samples_all,
-       const CvStatModelParams* estimateParams CV_DEFAULT(0),
-       const CvMat*             sampleIdx CV_DEFAULT(0) );
-
-CVAPI(float)
-cvCrossValidation( const CvMat*             trueData,
-                         int                tflag,
-                   const CvMat*             trueClasses,
-                         CvStatModel*     (*createClassifier)( const CvMat*,
-                                                                     int,
-                                                               const CvMat*,
-                                                               const CvStatModelParams*,
-                                                               const CvMat*,
-                                                               const CvMat*,
-                                                               const CvMat*,
-                                                               const CvMat* ),
-                   const CvStatModelParams* estimateParams CV_DEFAULT(0),
-                   const CvStatModelParams* trainParams CV_DEFAULT(0),
-                   const CvMat*             compIdx CV_DEFAULT(0),
-                   const CvMat*             sampleIdx CV_DEFAULT(0),
-                         CvStatModel**      pCrValModel CV_DEFAULT(0),
-                   const CvMat*             typeMask CV_DEFAULT(0),
-                   const CvMat*             missedMeasurementMask CV_DEFAULT(0) );
-#endif
-
 /****************************************************************************************\
 *                           Auxilary functions declarations                              *
 \****************************************************************************************/
@@ -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;
     
 }

modules/ml/src/boost.cpp

@@ -1894,10 +1894,6 @@ float CvBoost::calc_error( CvMLData* _data, int type, std::vector<float> *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__;
 }
 
 

modules/objdetect/include/opencv2/objdetect/objdetect.hpp

@@ -270,8 +270,8 @@ namespace cv
 	
 ///////////////////////////// Object Detection ////////////////////////////
 
-CV_EXPORTS void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
-CV_EXPORTS void groupRectangles(vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
         
 class CV_EXPORTS FeatureEvaluator
 {
@@ -293,7 +293,7 @@ public:
 
 template<> CV_EXPORTS void Ptr<CvHaarClassifierCascade>::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<Rect>& 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<float>& _svmdetector);
+    CV_WRAP virtual void setSVMDetector(const vector<float>& _svmdetector);
     
     virtual bool read(FileNode& fn);
     virtual void write(FileStorage& fs, const String& objname) const;
     
-    virtual bool load(const String& filename, const String& objname=String());
-    virtual void save(const String& filename, const String& objname=String()) const;
+    CV_WRAP virtual bool load(const String& filename, const String& objname=String());
+    CV_WRAP virtual void save(const String& filename, const String& objname=String()) const;
     virtual void copyTo(HOGDescriptor& c) const;
     
-    virtual void compute(const Mat& img,
+    CV_WRAP virtual void compute(const Mat& img,
                          CV_OUT vector<float>& descriptors,
                          Size winStride=Size(), Size padding=Size(),
                          const vector<Point>& locations=vector<Point>()) const;
-    virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,
+    CV_WRAP virtual void detect(const Mat& img, CV_OUT vector<Point>& foundLocations,
                         double hitThreshold=0, Size winStride=Size(),
                         Size padding=Size(),
                         const vector<Point>& searchLocations=vector<Point>()) const;
-    virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,
+    CV_WRAP virtual void detectMultiScale(const Mat& img, CV_OUT vector<Rect>& foundLocations,
                                   double hitThreshold=0, Size winStride=Size(),
                                   Size padding=Size(), double scale=1.05,
                                   int groupThreshold=2) const;
-    virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
+    CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
                                  Size paddingTL=Size(), Size paddingBR=Size()) const;
     
     static vector<float> getDefaultPeopleDetector();
     
-    Size winSize;
-    Size blockSize;
-    Size blockStride;
-    Size cellSize;
-    int nbins;
-    int derivAperture;
-    double winSigma;
-    int histogramNormType;
-    double L2HysThreshold;
-    bool gammaCorrection;
-    vector<float> svmDetector;
+    CV_PROP Size winSize;
+    CV_PROP Size blockSize;
+    CV_PROP Size blockStride;
+    CV_PROP Size cellSize;
+    CV_PROP int nbins;
+    CV_PROP int derivAperture;
+    CV_PROP double winSigma;
+    CV_PROP int histogramNormType;
+    CV_PROP double L2HysThreshold;
+    CV_PROP bool gammaCorrection;
+    CV_PROP vector<float> svmDetector;
 };
 
 	

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

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<Point2f>& prevPts, CV_OUT vector<Point2f>& nextPts,
                            CV_OUT vector<uchar>& status, CV_OUT vector<float>& err,
                            Size winSize=Size(15,15), int maxLevel=3,
@@ -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 );