Changeset 3860

Show
Ignore:
Timestamp:
11/02/10 10:58:22 (3 years ago)
Author:
vp153
Message:

almost finished Python wrappers

Location:
trunk/opencv/modules
Files:
1 added
1 removed
26 modified

Legend:

Unmodified
Added
Removed
  • trunk/opencv/modules/calib3d/include/opencv2/calib3d/calib3d.hpp

    r3837 r3860  
    445445CV_EXPORTS_AS(findHomographyAndOutliers) Mat findHomography( const Mat& srcPoints, 
    446446                               const Mat& dstPoints, 
    447                                CV_OUT Mat& mask, int method=0, 
    448                                double ransacReprojThreshold=3 ); 
    449  
    450 //! computes the best-fit perspective transformation mapping srcPoints to dstPoints. 
    451 CV_EXPORTS Mat findHomography( const Mat& srcPoints, 
    452                                const Mat& dstPoints, 
    453447                               vector<uchar>& mask, int method=0, 
    454448                               double ransacReprojThreshold=3 ); 
     
    494488 
    495489//! projects points from the model coordinate space to the image coordinates. Takes the intrinsic and extrinsic camera parameters into account 
    496 CV_EXPORTS void projectPoints( const Mat& objectPoints, 
     490CV_EXPORTS_W void projectPoints( const Mat& objectPoints, 
    497491                               const Mat& rvec, const Mat& tvec, 
    498492                               const Mat& cameraMatrix, 
     
    501495 
    502496//! 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 
    503 CV_EXPORTS void projectPoints( const Mat& objectPoints, 
     497CV_EXPORTS_AS(projectPointsJ) void projectPoints( const Mat& objectPoints, 
    504498                               const Mat& rvec, const Mat& tvec, 
    505499                               const Mat& cameraMatrix, 
     
    519513 
    520514//! initializes camera matrix from a few 3D points and the corresponding projections. 
    521 CV_EXPORTS Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints, 
     515CV_EXPORTS_W Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints, 
    522516                                   const vector<vector<Point2f> >& imagePoints, 
    523517                                   Size imageSize, double aspectRatio=1. ); 
     
    528522 
    529523//! finds checkerboard pattern of the specified size in the image 
    530 CV_EXPORTS bool findChessboardCorners( const Mat& image, Size patternSize, 
    531                                        CV_OUT vector<Point2f>& corners, 
    532                                        int flags=CALIB_CB_ADAPTIVE_THRESH+ 
     524CV_EXPORTS_W bool findChessboardCorners( const Mat& image, Size patternSize, 
     525                                         CV_OUT vector<Point2f>& corners, 
     526                                         int flags=CALIB_CB_ADAPTIVE_THRESH+ 
    533527                                              CALIB_CB_NORMALIZE_IMAGE ); 
    534528 
     
    559553 
    560554//! finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. 
    561 CV_EXPORTS double calibrateCamera( const vector<vector<Point3f> >& objectPoints, 
     555CV_EXPORTS_W double calibrateCamera( const vector<vector<Point3f> >& objectPoints, 
    562556                                     const vector<vector<Point2f> >& imagePoints, 
    563557                                     Size imageSize, 
     
    579573 
    580574//! finds intrinsic and extrinsic parameters of a stereo camera 
    581 CV_EXPORTS double stereoCalibrate( const vector<vector<Point3f> >& objectPoints, 
     575CV_EXPORTS_W double stereoCalibrate( const vector<vector<Point3f> >& objectPoints, 
    582576                                     const vector<vector<Point2f> >& imagePoints1, 
    583577                                     const vector<vector<Point2f> >& imagePoints2, 
     
    616610 
    617611//! computes the rectification transformations for 3-head camera, where all the heads are on the same line. 
    618 CV_EXPORTS float rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1, 
     612CV_EXPORTS_W float rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1, 
    619613                                      const Mat& cameraMatrix2, const Mat& distCoeffs2, 
    620614                                      const Mat& cameraMatrix3, const Mat& distCoeffs3, 
  • trunk/opencv/modules/core/include/opencv2/core/core.hpp

    r3843 r3860  
    973973    typedef value_type vec_type; 
    974974     
    975     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     975    enum { generic = 1, depth = DataDepth<channel_type>::value, channels = 1, 
    976976        fmt=DataDepth<channel_type>::fmt, 
    977977        type = CV_MAKETYPE(depth, channels) }; 
     
    985985    typedef value_type channel_type; 
    986986    typedef value_type vec_type; 
    987     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     987    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    988988           fmt=DataDepth<channel_type>::fmt, 
    989989           type = CV_MAKETYPE(depth, channels) }; 
     
    997997    typedef value_type channel_type; 
    998998    typedef value_type vec_type; 
    999     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     999    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10001000           fmt=DataDepth<channel_type>::fmt, 
    10011001           type = CV_MAKETYPE(depth, channels) }; 
     
    10091009    typedef value_type channel_type; 
    10101010    typedef value_type vec_type; 
    1011     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1011    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10121012           fmt=DataDepth<channel_type>::fmt, 
    10131013           type = CV_MAKETYPE(depth, channels) }; 
     
    10211021    typedef value_type channel_type; 
    10221022    typedef value_type vec_type; 
    1023     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1023    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10241024           fmt=DataDepth<channel_type>::fmt, 
    10251025           type = CV_MAKETYPE(depth, channels) }; 
     
    10331033    typedef value_type channel_type; 
    10341034    typedef value_type vec_type; 
    1035     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1035    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10361036           fmt=DataDepth<channel_type>::fmt, 
    10371037           type = CV_MAKETYPE(depth, channels) }; 
     
    10451045    typedef value_type channel_type; 
    10461046    typedef value_type vec_type; 
    1047     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1047    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10481048           fmt=DataDepth<channel_type>::fmt, 
    10491049           type = CV_MAKETYPE(depth, channels) }; 
     
    10571057    typedef value_type channel_type; 
    10581058    typedef value_type vec_type; 
    1059     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1059    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10601060           fmt=DataDepth<channel_type>::fmt, 
    10611061           type = CV_MAKETYPE(depth, channels) }; 
     
    10691069    typedef value_type channel_type; 
    10701070    typedef value_type vec_type; 
    1071     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1071    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10721072           fmt=DataDepth<channel_type>::fmt, 
    10731073           type = CV_MAKETYPE(depth, channels) }; 
     
    10811081    typedef value_type channel_type; 
    10821082    typedef value_type vec_type; 
    1083     enum { depth = DataDepth<channel_type>::value, channels = 1, 
     1083    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 1, 
    10841084           fmt=DataDepth<channel_type>::fmt, 
    10851085           type = CV_MAKETYPE(depth, channels) }; 
     
    10931093    typedef _Tp channel_type; 
    10941094    typedef value_type vec_type; 
    1095     enum { depth = DataDepth<channel_type>::value, channels = cn, 
     1095    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = cn, 
    10961096           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    10971097           type = CV_MAKETYPE(depth, channels) }; 
     
    11041104    typedef value_type work_type; 
    11051105    typedef _Tp channel_type; 
    1106     enum { depth = DataDepth<channel_type>::value, channels = 2, 
     1106    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 2, 
    11071107           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11081108           type = CV_MAKETYPE(depth, channels) }; 
     
    11161116    typedef value_type work_type; 
    11171117    typedef _Tp channel_type; 
    1118     enum { depth = DataDepth<channel_type>::value, channels = 2, 
     1118    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 2, 
    11191119           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11201120           type = CV_MAKETYPE(depth, channels) }; 
     
    11281128    typedef Point_<typename DataType<_Tp>::work_type> work_type; 
    11291129    typedef _Tp channel_type; 
    1130     enum { depth = DataDepth<channel_type>::value, channels = 2, 
     1130    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 2, 
    11311131           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11321132           type = CV_MAKETYPE(depth, channels) }; 
     
    11401140    typedef Point3_<typename DataType<_Tp>::work_type> work_type; 
    11411141    typedef _Tp channel_type; 
    1142     enum { depth = DataDepth<channel_type>::value, channels = 3, 
     1142    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 3, 
    11431143           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11441144           type = CV_MAKETYPE(depth, channels) }; 
     
    11521152    typedef Size_<typename DataType<_Tp>::work_type> work_type; 
    11531153    typedef _Tp channel_type; 
    1154     enum { depth = DataDepth<channel_type>::value, channels = 2, 
     1154    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 2, 
    11551155           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11561156           type = CV_MAKETYPE(depth, channels) }; 
     
    11641164    typedef Rect_<typename DataType<_Tp>::work_type> work_type; 
    11651165    typedef _Tp channel_type; 
    1166     enum { depth = DataDepth<channel_type>::value, channels = 4, 
     1166    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 4, 
    11671167           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11681168           type = CV_MAKETYPE(depth, channels) }; 
     
    11761176    typedef Scalar_<typename DataType<_Tp>::work_type> work_type; 
    11771177    typedef _Tp channel_type; 
    1178     enum { depth = DataDepth<channel_type>::value, channels = 4, 
     1178    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 4, 
    11791179           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11801180           type = CV_MAKETYPE(depth, channels) }; 
     
    11881188    typedef value_type work_type; 
    11891189    typedef int channel_type; 
    1190     enum { depth = DataDepth<channel_type>::value, channels = 2, 
     1190    enum { generic = 0, depth = DataDepth<channel_type>::value, channels = 2, 
    11911191           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt, 
    11921192           type = CV_MAKETYPE(depth, channels) }; 
     
    21552155    \endcode 
    21562156*/ 
    2157 class CV_EXPORTS_W PCA 
     2157class CV_EXPORTS PCA 
    21582158{ 
    21592159public: 
    21602160    //! default constructor 
    2161     CV_WRAP PCA(); 
     2161    PCA(); 
    21622162    //! the constructor that performs PCA 
    2163     CV_WRAP PCA(const Mat& data, const Mat& mean, int flags, int maxComponents=0); 
     2163    PCA(const Mat& data, const Mat& mean, int flags, int maxComponents=0); 
    21642164    //! operator that performs PCA. The previously stored data, if any, is released 
    2165     CV_WRAP_AS(compute) PCA& operator()(const Mat& data, const Mat& mean, int flags, int maxComponents=0); 
     2165    PCA& operator()(const Mat& data, const Mat& mean, int flags, int maxComponents=0); 
    21662166    //! projects vector from the original space to the principal components subspace 
    21672167    Mat project(const Mat& vec) const; 
    21682168    //! projects vector from the original space to the principal components subspace 
    2169     CV_WRAP void project(const Mat& vec, CV_OUT Mat& result) const; 
     2169    void project(const Mat& vec, CV_OUT Mat& result) const; 
    21702170    //! reconstructs the original vector from the projection 
    21712171    Mat backProject(const Mat& vec) const; 
    21722172    //! reconstructs the original vector from the projection 
    2173     CV_WRAP void backProject(const Mat& vec, CV_OUT Mat& result) const; 
    2174  
    2175     CV_PROP Mat eigenvectors; //!< eigenvectors of the covariation matrix 
    2176     CV_PROP Mat eigenvalues; //!< eigenvalues of the covariation matrix 
    2177     CV_PROP Mat mean; //!< mean value subtracted before the projection and added after the back projection 
     2173    void backProject(const Mat& vec, CV_OUT Mat& result) const; 
     2174 
     2175    Mat eigenvectors; //!< eigenvectors of the covariation matrix 
     2176    Mat eigenvalues; //!< eigenvalues of the covariation matrix 
     2177    Mat mean; //!< mean value subtracted before the projection and added after the back projection 
    21782178}; 
    21792179 
     
    22742274 
    22752275//! shuffles the input array elements 
    2276 CV_EXPORTS_W void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0); 
     2276CV_EXPORTS void randShuffle(Mat& dst, double iterFactor=1., RNG* rng=0); 
    22772277 
    22782278//! draws the line segment (pt1, pt2) in the image 
     
    35773577    //! the full constructor that builds the search tree 
    35783578    CV_WRAP KDTree(const Mat& _points, bool copyAndReorderPoints=false); 
     3579    //! the full constructor that builds the search tree 
     3580    CV_WRAP KDTree(const Mat& _points, const Mat& _labels, bool copyAndReorderPoints=false); 
    35793581    //! builds the search tree 
    35803582    CV_WRAP void build(const Mat& _points, bool copyAndReorderPoints=false); 
     3583    //! builds the search tree 
     3584    CV_WRAP void build(const Mat& _points, const Mat& _labels, bool copyAndReorderPoints=false); 
    35813585    //! finds the K nearest neighbors of "vec" while looking at Emax (at most) leaves 
    35823586    int findNearest(const float* vec, 
    35833587                    int K, int Emax, int* neighborsIdx, 
    3584                     Mat* neighbors=0, float* dist=0) const; 
     3588                    Mat* neighbors=0, float* dist=0, int* labels=0) const; 
    35853589    //! finds the K nearest neighbors while looking at Emax (at most) leaves 
    35863590    int findNearest(const float* vec, int K, int Emax, 
    35873591                    vector<int>* neighborsIdx, 
    3588                     Mat* neighbors=0, vector<float>* dist=0) const; 
     3592                    Mat* neighbors=0, 
     3593                    vector<float>* dist=0, 
     3594                    vector<int>* labels=0) const; 
     3595    CV_WRAP int findNearest(const vector<float>& vec, int K, int Emax, 
     3596                    CV_OUT vector<int>* neighborsIdx, 
     3597                    CV_OUT Mat* neighbors=0, 
     3598                    CV_OUT vector<float>* dist=0, 
     3599                    CV_OUT vector<int>* labels=0) const; 
    35893600    //! finds all the points from the initial set that belong to the specified box  
    35903601    void findOrthoRange(const float* minBounds, const float* maxBounds, 
    3591                         vector<int>* neighborsIdx, Mat* neighbors=0) const; 
     3602                        vector<int>* neighborsIdx, Mat* neighbors=0, 
     3603                        vector<int>* labels=0) const; 
     3604    CV_WRAP void findOrthoRange(const vector<float>& minBounds, const vector<float>& maxBounds, 
     3605                                CV_OUT vector<int>* neighborsIdx, CV_OUT Mat* neighbors=0, 
     3606                                CV_OUT vector<int>* labels=0) const; 
    35923607    //! returns vectors with the specified indices 
    3593     void getPoints(const int* idx, size_t nidx, Mat& pts) const; 
     3608    void getPoints(const int* idx, size_t nidx, Mat& pts, vector<int>* labels=0) const; 
    35943609    //! returns vectors with the specified indices 
    3595     void getPoints(const Mat& idxs, Mat& pts) const; 
     3610    CV_WRAP void getPoints(const vector<int>& idxs, Mat& pts, CV_OUT vector<int>* labels=0) const; 
    35963611    //! return a vector with the specified index 
    3597     const float* getPoint(int ptidx) const; 
     3612    const float* getPoint(int ptidx, int* label=0) const; 
    35983613    //! returns the search space dimensionality 
    35993614    CV_WRAP int dims() const; 
     
    36013616    vector<Node> nodes; //!< all the tree nodes 
    36023617    CV_PROP Mat points; //!< all the points. It can be a reordered copy of the input vector set or the original vector set. 
     3618    CV_PROP vector<int> labels; //!< the parallel array of labels. 
    36033619    CV_PROP int maxDepth; //!< maximum depth of the search tree. Do not modify it 
    36043620    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 
     
    37443760    CV_WRAP FileNode root(int streamidx=0) const; 
    37453761    //! returns the specified element of the top-level mapping 
    3746     CV_WRAP FileNode operator[](const string& nodename) const; 
     3762    FileNode operator[](const string& nodename) const; 
    37473763    //! returns the specified element of the top-level mapping 
    37483764    CV_WRAP FileNode operator[](const char* nodename) const; 
     
    37783794 When a file storage is opened for writing, no data is stored in memory after it is written. 
    37793795*/ 
    3780 class CV_EXPORTS_W FileNode 
     3796class CV_EXPORTS_W_SIMPLE FileNode 
    37813797{ 
    37823798public: 
     
    38143830    CV_WRAP int type() const; 
    38153831 
    3816     CV_WRAP int rawDataSize(const string& fmt) const; 
    38173832    //! returns true if the node is empty  
    38183833    CV_WRAP bool empty() const; 
     
    38363851    CV_WRAP size_t size() const; 
    38373852    //! returns the node content as an integer. If the node stores floating-point number, it is rounded. 
    3838     CV_WRAP operator int() const; 
     3853    operator int() const; 
    38393854    //! returns the node content as float 
    3840     CV_WRAP operator float() const; 
     3855    operator float() const; 
    38413856    //! returns the node content as double 
    3842     CV_WRAP operator double() const; 
     3857    operator double() const; 
    38433858    //! returns the node content as text string 
    3844     CV_WRAP operator string() const; 
     3859    operator string() const; 
    38453860     
    38463861    //! returns pointer to the underlying file node 
  • trunk/opencv/modules/core/include/opencv2/core/operations.hpp

    r3837 r3860  
    29912991        _Tp *lb; 
    29922992        _Tp *ub; 
    2993     } 
    2994     stack[48]; 
     2993    } stack[48]; 
    29952994 
    29962995    size_t total = vec.size(); 
  • trunk/opencv/modules/core/include/opencv2/core/types_c.h

    r3837 r3860  
    162162#define CV_CUSTOM_CARRAY(args) 
    163163#define CV_EXPORTS_W CV_EXPORTS 
     164#define CV_EXPORTS_W_SIMPLE CV_EXPORTS 
    164165#define CV_EXPORTS_AS(synonym) CV_EXPORTS 
    165 #define CV_EXPORTS_AS_MAP CV_EXPORTS 
     166#define CV_EXPORTS_W_MAP CV_EXPORTS 
    166167#define CV_IN_OUT 
    167168#define CV_OUT 
  • trunk/opencv/modules/core/src/datastructs.cpp

    r3343 r3860  
    35563556} 
    35573557 
     3558KDTree::KDTree(const Mat& _points, const Mat& _labels, bool _copyData) 
     3559{ 
     3560    maxDepth = -1; 
     3561    normType = NORM_L2; 
     3562    build(_points, _labels, _copyData); 
     3563}     
     3564     
    35583565struct SubTree 
    35593566{ 
     
    36313638} 
    36323639 
    3633  
     3640     
    36343641void KDTree::build(const Mat& _points, bool _copyData) 
    36353642{ 
    3636     CV_Assert(_points.type() == CV_32F); 
     3643    build(_points, Mat(), _copyData); 
     3644} 
     3645 
     3646 
     3647void KDTree::build(const Mat& _points, const Mat& _labels, bool _copyData) 
     3648{ 
     3649    CV_Assert(_points.type() == CV_32F && !_points.empty()); 
    36373650    vector<KDTree::Node>().swap(nodes); 
    36383651 
     
    36443657        points.create(_points.size(), _points.type()); 
    36453658    } 
    3646  
     3659     
    36473660    int i, j, n = _points.rows, dims = _points.cols, top = 0; 
    36483661    const float* data = _points.ptr<float>(0); 
     
    36513664    size_t dstep = points.step1(); 
    36523665    int ptpos = 0; 
     3666    labels.resize(n); 
     3667    const int* _labels_data = 0; 
     3668     
     3669    if( !_labels.empty() ) 
     3670    { 
     3671        int nlabels = _labels.checkVector(1, CV_32S, true); 
     3672        CV_Assert(nlabels == n); 
     3673        _labels_data = (const int*)_labels.data; 
     3674    } 
    36533675 
    36543676    Mat sumstack(MAX_TREE_DEPTH*2, dims*2, CV_64F); 
     
    36763698        if( count == 1 ) 
    36773699        { 
    3678             int idx = _copyData ? ptpos++ : (int)(ptofs[first]/step); 
     3700            int idx0 = (int)(ptofs[first]/step); 
     3701            int idx = _copyData ? ptpos++ : idx0; 
    36793702            nodes[nidx].idx = ~idx; 
    36803703            if( _copyData ) 
     
    36853708                    dst[j] = src[j]; 
    36863709            } 
     3710            labels[idx] = _labels_data ? _labels_data[idx0] : idx0;  
    36873711            _maxDepth = std::max(_maxDepth, depth); 
    36883712            continue; 
     
    37243748                         vector<int>* neighborsIdx, 
    37253749                         Mat* neighbors, 
    3726                          vector<float>* dist) const 
     3750                         vector<float>* dist, 
     3751                         vector<int>* labels) const 
    37273752{ 
    37283753    K = std::min(K, points.rows); 
     
    37323757    if(dist) 
    37333758        dist->resize(K); 
     3759    if(labels) 
     3760        labels->resize(K); 
    37343761    K = findNearest(vec, K, emax, neighborsIdx ? &(*neighborsIdx)[0] : 0, 
    3735                     neighbors, dist ? &(*dist)[0] : 0); 
     3762                    neighbors, dist ? &(*dist)[0] : 0, labels ? &(*labels)[0] : 0); 
    37363763    if(neighborsIdx) 
    37373764        neighborsIdx->resize(K); 
    37383765    if(dist) 
    37393766        dist->resize(K); 
     3767    if(labels) 
     3768        labels->resize(K); 
    37403769    return K; 
    37413770} 
    3742  
     3771     
     3772int KDTree::findNearest(const vector<float>& vec, int K, int emax, 
     3773                        vector<int>* neighborsIdx, 
     3774                        Mat* neighbors, 
     3775                        vector<float>* dist, 
     3776                        vector<int>* labels) const 
     3777{ 
     3778    CV_Assert((int)vec.size() == points.cols); 
     3779    K = std::min(K, points.rows); 
     3780    CV_Assert(K > 0); 
     3781    if(neighborsIdx) 
     3782        neighborsIdx->resize(K); 
     3783    if(dist) 
     3784        dist->resize(K); 
     3785    if(labels) 
     3786        labels->resize(K); 
     3787    K = findNearest(&vec[0], K, emax, neighborsIdx ? &(*neighborsIdx)[0] : 0, 
     3788                    neighbors, dist ? &(*dist)[0] : 0, labels ? &(*labels)[0] : 0); 
     3789    if(neighborsIdx) 
     3790        neighborsIdx->resize(K); 
     3791    if(dist) 
     3792        dist->resize(K); 
     3793    if(labels) 
     3794        labels->resize(K); 
     3795    return K; 
     3796}     
    37433797 
    37443798struct PQueueElem 
     
    37533807int KDTree::findNearest(const float* vec, int K, int emax, 
    37543808                        int* _neighborsIdx, Mat* _neighbors, 
    3755                         float* _dist) const 
     3809                        float* _dist, int* _labels) const 
    37563810     
    37573811{ 
     
    38863940            _dist[i] = std::sqrt(dist[i]); 
    38873941    } 
     3942    if( _labels ) 
     3943    { 
     3944        for( i = 0; i < K; i++ ) 
     3945            _labels[i] = labels[idx[i]]; 
     3946    } 
    38883947 
    38893948    if( _neighbors ) 
     
    38943953 
    38953954void KDTree::findOrthoRange(const float* L, const float* R, 
    3896                             vector<int>* neighborsIdx, Mat* neighbors) const 
     3955                            vector<int>* neighborsIdx, 
     3956                            Mat* neighbors, vector<int>* _labels) const 
    38973957{ 
    38983958    int dims = points.cols; 
     
    39323992 
    39333993    if( neighbors ) 
    3934         getPoints( &(*idx)[0], idx->size(), *neighbors ); 
     3994        getPoints( &(*idx)[0], idx->size(), *neighbors, _labels ); 
    39353995} 
    39363996 
    39373997     
    3938 void KDTree::getPoints(const int* idx, size_t nidx, Mat& pts) const 
     3998void KDTree::findOrthoRange(const vector<float>& L, const vector<float>& R, 
     3999                            vector<int>* neighborsIdx, Mat* neighbors, vector<int>* _labels) const 
     4000{ 
     4001    size_t dims = points.cols; 
     4002    CV_Assert(L.size() == dims && R.size() == dims); 
     4003    findOrthoRange(&L[0], &R[0], neighborsIdx, neighbors, _labels); 
     4004} 
     4005         
     4006     
     4007void KDTree::getPoints(const int* idx, size_t nidx, Mat& pts, vector<int>* _labels) const 
    39394008{ 
    39404009    int dims = points.cols, n = (int)nidx; 
    39414010    pts.create( n, dims, points.type()); 
     4011    if(_labels) 
     4012        _labels->resize(nidx); 
     4013 
    39424014    for( int i = 0; i < n; i++ ) 
    39434015    { 
     
    39464018        const float* src = points.ptr<float>(k); 
    39474019        std::copy(src, src + dims, pts.ptr<float>(i)); 
    3948     } 
    3949 } 
    3950  
    3951  
    3952 void KDTree::getPoints(const Mat& idx, Mat& pts) const 
    3953 { 
    3954     CV_Assert(idx.type() == CV_32S && idx.isContinuous() && 
    3955               (idx.cols == 1 || idx.rows == 1)); 
     4020        if(_labels) 
     4021            (*_labels)[i] = labels[k]; 
     4022    } 
     4023} 
     4024 
     4025 
     4026void KDTree::getPoints(const vector<int>& idx, Mat& pts, vector<int>* _labels) const 
     4027{ 
    39564028    int dims = points.cols; 
    3957     int i, nidx = idx.cols + idx.rows - 1; 
     4029    int i, nidx = (int)idx.size(); 
    39584030    pts.create( nidx, dims, points.type()); 
    3959     const int* _idx = idx.ptr<int>(); 
     4031     
     4032    if(_labels) 
     4033        _labels->resize(nidx); 
    39604034     
    39614035    for( i = 0; i < nidx; i++ ) 
    39624036    { 
    3963         int k = _idx[i]; 
     4037        int k = idx[i]; 
    39644038        CV_Assert( (unsigned)k < (unsigned)points.rows ); 
    39654039        const float* src = points.ptr<float>(k); 
    39664040        std::copy(src, src + dims, pts.ptr<float>(i)); 
    3967     } 
    3968 } 
    3969  
    3970  
    3971 const float* KDTree::getPoint(int ptidx) const 
     4041        if(_labels) (*_labels)[i] = labels[k]; 
     4042    } 
     4043} 
     4044 
     4045 
     4046const float* KDTree::getPoint(int ptidx, int* label) const 
    39724047{ 
    39734048    CV_Assert( (unsigned)ptidx < (unsigned)points.rows); 
     4049    if(label) 
     4050        *label = label[ptidx]; 
    39744051    return points.ptr<float>(ptidx); 
    39754052} 
     4053 
     4054 
     4055int KDTree::dims() const 
     4056{ 
     4057    return !points.empty() ? points.cols : 0; 
     4058} 
     4059     
     4060//////////////////////////////////////////////////////////////////////////////// 
    39764061     
    39774062schar*  seqPush( CvSeq* seq, const void* element ) 
  • trunk/opencv/modules/core/src/persistence.cpp

    r3757 r3860  
    51315131} 
    51325132 
    5133  
    51345133FileNodeIterator::FileNodeIterator() 
    51355134{ 
  • trunk/opencv/modules/features2d/include/opencv2/features2d/features2d.hpp

    r3851 r3860  
    217217 cv::KDTree or another method. 
    218218*/ 
    219 class CV_EXPORTS KeyPoint 
     219class CV_EXPORTS_W_SIMPLE KeyPoint 
    220220{ 
    221221public: 
    222222    //! the default constructor 
    223     KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {} 
     223    CV_WRAP KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {} 
    224224    //! the full constructor 
    225225    KeyPoint(Point2f _pt, float _size, float _angle=-1, 
     
    228228            response(_response), octave(_octave), class_id(_class_id) {} 
    229229    //! another form of the full constructor 
    230     KeyPoint(float x, float y, float _size, float _angle=-1, 
     230    CV_WRAP KeyPoint(float x, float y, float _size, float _angle=-1, 
    231231            float _response=0, int _octave=0, int _class_id=-1) 
    232232            : pt(x, y), size(_size), angle(_angle), 
     
    246246    static float overlap(const KeyPoint& kp1, const KeyPoint& kp2); 
    247247 
    248     Point2f pt; //!< coordinates of the keypoints 
    249     float size; //!< diameter of the meaningfull keypoint neighborhood 
    250     float angle; //!< computed orientation of the keypoint (-1 if not applicable) 
    251     float response; //!< the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling 
    252     int octave; //!< octave (pyramid layer) from which the keypoint has been extracted 
    253     int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)  
     248    CV_PROP_RW Point2f pt; //!< coordinates of the keypoints 
     249    CV_PROP_RW float size; //!< diameter of the meaningfull keypoint neighborhood 
     250    CV_PROP_RW float angle; //!< computed orientation of the keypoint (-1 if not applicable) 
     251    CV_PROP_RW float response; //!< the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling 
     252    CV_PROP_RW int octave; //!< octave (pyramid layer) from which the keypoint has been extracted 
     253    CV_PROP_RW int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)  
    254254}; 
    255255 
    256256//! writes vector of keypoints to the file storage 
    257 CV_EXPORTS_W void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints); 
     257CV_EXPORTS void write(FileStorage& fs, const string& name, const vector<KeyPoint>& keypoints); 
    258258//! reads vector of keypoints from the specified file storage node 
    259 CV_EXPORTS_W void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);     
     259CV_EXPORTS void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);     
    260260 
    261261/*! 
  • trunk/opencv/modules/highgui/include/opencv2/highgui/highgui.hpp

    r3837 r3860  
    8989typedef void (CV_CDECL *TrackbarCallback)(int pos, void* userdata); 
    9090 
    91 CV_EXPORTS_W int createTrackbar( const string& trackbarname, const string& winname, 
     91CV_EXPORTS int createTrackbar( const string& trackbarname, const string& winname, 
    9292                               int* value, int count, 
    9393                               TrackbarCallback onChange CV_DEFAULT(0), 
     
    100100 
    101101//! assigns callback for mouse events 
    102 CV_EXPORTS_W void setMouseCallback( const string& windowName, MouseCallback onMouse, void* param=0); 
     102CV_EXPORTS void setMouseCallback( const string& windowName, MouseCallback onMouse, void* param=0); 
    103103     
    104104CV_EXPORTS_W Mat imread( const string& filename, int flags=1 ); 
     
    132132    CV_WRAP virtual bool grab(); 
    133133    CV_WRAP virtual bool retrieve(CV_OUT Mat& image, int channel=0); 
    134     CV_WRAP_AS(read) virtual VideoCapture& operator >> (CV_OUT Mat& image); 
     134    virtual VideoCapture& operator >> (CV_OUT Mat& image); 
     135    CV_WRAP virtual bool read(CV_OUT Mat& image); 
    135136     
    136137    CV_WRAP virtual bool set(int propId, double value); 
     
    153154                      Size frameSize, bool isColor=true); 
    154155    CV_WRAP virtual bool isOpened() const; 
    155     CV_WRAP_AS(write) virtual VideoWriter& operator << (const Mat& image); 
     156    virtual VideoWriter& operator << (const Mat& image); 
     157    CV_WRAP virtual void write(const Mat& image); 
    156158     
    157159protected: 
  • trunk/opencv/modules/highgui/src/cap.cpp

    r3355 r3860  
    409409    return true; 
    410410} 
     411 
     412bool VideoCapture::read(Mat& image) 
     413{ 
     414    if(!grab()) 
     415        image.release(); 
     416    else 
     417        retrieve(image); 
     418    return !image.empty(); 
     419} 
    411420     
    412421VideoCapture& VideoCapture::operator >> (Mat& image) 
     
    452461    return !writer.empty(); 
    453462}     
    454      
    455 VideoWriter& VideoWriter::operator << (const Mat& image) 
     463 
     464void VideoWriter::write(const Mat& image) 
    456465{ 
    457466    IplImage _img = image; 
    458467    cvWriteFrame(writer, &_img); 
     468} 
     469     
     470VideoWriter& VideoWriter::operator << (const Mat& image) 
     471{ 
     472    write(image); 
    459473    return *this;     
    460474} 
  • trunk/opencv/modules/imgproc/include/opencv2/imgproc/imgproc.hpp

    r3843 r3860  
    460460 
    461461//! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima 
    462 CV_EXPORTS void goodFeaturesToTrack( const Mat& image, CV_OUT vector<Point2f>& corners, 
     462CV_EXPORTS_W void goodFeaturesToTrack( const Mat& image, CV_OUT vector<Point2f>& corners, 
    463463                                     int maxCorners, double qualityLevel, double minDistance, 
    464464                                     const Mat& mask=Mat(), int blockSize=3, 
     
    466466 
    467467//! finds lines in the black-n-white image using the standard or pyramid Hough transform 
    468 CV_EXPORTS void HoughLines( const Mat& image, CV_OUT vector<Vec2f>& lines, 
     468CV_EXPORTS_W void HoughLines( const Mat& image, CV_OUT vector<Vec2f>& lines, 
    469469                            double rho, double theta, int threshold, 
    470470                            double srn=0, double stn=0 ); 
    471471 
    472472//! finds line segments in the black-n-white image using probabalistic Hough transform 
    473 CV_EXPORTS void HoughLinesP( Mat& image, CV_OUT vector<Vec4i>& lines, 
     473CV_EXPORTS_W void HoughLinesP( Mat& image, CV_OUT vector<Vec4i>& lines, 
    474474                             double rho, double theta, int threshold, 
    475475                             double minLineLength=0, double maxLineGap=0 ); 
    476476 
    477477//! finds circles in the grayscale image using 2+1 gradient Hough transform  
    478 CV_EXPORTS void HoughCircles( const Mat& image, CV_OUT vector<Vec3f>& circles, 
     478CV_EXPORTS_W void HoughCircles( const Mat& image, CV_OUT vector<Vec3f>& circles, 
    479479                              int method, double dp, double minDist, 
    480480                              double param1=100, double param2=100, 
     
    717717//! fills the semi-uniform image region starting from the specified seed point 
    718718CV_EXPORTS_W int floodFill( Mat& image, 
    719                           Point seedPoint, Scalar newVal, Rect* rect=0, 
     719                          Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0, 
    720720                          Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), 
    721721                          int flags=4 ); 
     
    723723//! fills the semi-uniform image region and/or the mask starting from the specified seed point 
    724724CV_EXPORTS_AS(floodFillMask) int floodFill( Mat& image, Mat& mask, 
    725                           Point seedPoint, Scalar newVal, Rect* rect=0, 
     725                          Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0, 
    726726                          Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), 
    727727                          int flags=4 ); 
     
    731731 
    732732//! raster image moments 
    733 class CV_EXPORTS Moments 
     733class CV_EXPORTS_W_MAP Moments 
    734734{ 
    735735public: 
     
    745745     
    746746    //! spatial moments 
    747     double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; 
     747    CV_PROP_RW double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; 
    748748    //! central moments 
    749     double  mu20, mu11, mu02, mu30, mu21, mu12, mu03; 
     749    CV_PROP_RW double  mu20, mu11, mu02, mu30, mu21, mu12, mu03; 
    750750    //! central normalized moments 
    751     double  nu20, nu11, nu02, nu30, nu21, nu12, nu03; 
     751    CV_PROP_RW double  nu20, nu11, nu02, nu30, nu21, nu12, nu03; 
    752752}; 
    753753 
  • trunk/opencv/modules/ml/include/opencv2/ml/ml.hpp

    r3843 r3860  
    189189#define CV_TEST_ERROR   1 
    190190 
    191 class CV_EXPORTS_AS(StatModel) CvStatModel 
     191class CV_EXPORTS_W CvStatModel 
    192192{ 
    193193public: 
     
    218218class CvMLData; 
    219219 
    220 struct CV_EXPORTS CvParamGrid 
     220struct CV_EXPORTS_W_MAP CvParamGrid 
    221221{ 
    222222    // SVM params type 
     
    237237    bool check() const; 
    238238 
    239     double min_val; 
    240     double max_val; 
    241     double step; 
    242 }; 
    243  
    244 class CV_EXPORTS_AS(NormalBayesClassifier) CvNormalBayesClassifier : public CvStatModel 
     239    CV_PROP_RW double min_val; 
     240    CV_PROP_RW double max_val; 
     241    CV_PROP_RW double step; 
     242}; 
     243 
     244class CV_EXPORTS_W CvNormalBayesClassifier : public CvStatModel 
    245245{ 
    246246public: 
     
    263263                       const cv::Mat& varIdx = cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), 
    264264                       bool update=false ); 
    265     CV_WRAP virtual float predict( const cv::Mat& samples, cv::Mat* results=0 ) const; 
     265    CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0 ) const; 
    266266#endif 
    267267     
     
    288288 
    289289// k Nearest Neighbors 
    290 class CV_EXPORTS_AS(KNearest) CvKNearest : public CvStatModel 
     290class CV_EXPORTS_W CvKNearest : public CvStatModel 
    291291{ 
    292292public: 
     
    313313                       int maxK=32, bool updateBase=false );     
    314314     
    315     CV_WRAP virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0, 
     315    virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0, 
    316316                                const float** neighbors=0, cv::Mat* neighborResponses=0, 
    317317                                cv::Mat* dist=0 ) const; 
     318    CV_WRAP virtual float find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results, 
     319                                        CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const; 
    318320#endif 
    319321     
     
    345347 
    346348// SVM training parameters 
    347 struct CV_EXPORTS_AS_MAP CvSVMParams 
     349struct CV_EXPORTS_W_MAP CvSVMParams 
    348350{ 
    349351    CvSVMParams(); 
     
    353355                 CvMat* _class_weights, CvTermCriteria _term_crit ); 
    354356 
    355     int         svm_type; 
    356     int         kernel_type; 
    357     double      degree; // for poly 
    358     double      gamma;  // for poly/rbf/sigmoid 
    359     double      coef0;  // for poly/sigmoid 
    360  
    361     double      C;  // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR 
    362     double      nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR 
    363     double      p; // for CV_SVM_EPS_SVR 
     357    CV_PROP_RW int         svm_type; 
     358    CV_PROP_RW int         kernel_type; 
     359    CV_PROP_RW double      degree; // for poly 
     360    CV_PROP_RW double      gamma;  // for poly/rbf/sigmoid 
     361    CV_PROP_RW double      coef0;  // for poly/sigmoid 
     362 
     363    CV_PROP_RW double      C;  // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR 
     364    CV_PROP_RW double      nu; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR 
     365    CV_PROP_RW double      p; // for CV_SVM_EPS_SVR 
    364366    CvMat*      class_weights; // for CV_SVM_C_SVC 
    365     CvTermCriteria term_crit; // termination criteria 
     367    CV_PROP_RW CvTermCriteria term_crit; // termination criteria 
    366368}; 
    367369 
     
    508510 
    509511// SVM model 
    510 class CV_EXPORTS_AS(SVM) CvSVM : public CvStatModel 
     512class CV_EXPORTS_W CvSVM : public CvStatModel 
    511513{ 
    512514public: 
     
    555557                            const cv::Mat& varIdx, const cv::Mat& sampleIdx, CvSVMParams params, 
    556558                            int k_fold = 10, 
    557                             CvParamGrid Cgrid      = get_default_grid(CvSVM::C), 
    558                             CvParamGrid gammaGrid  = get_default_grid(CvSVM::GAMMA), 
    559                             CvParamGrid pGrid      = get_default_grid(CvSVM::P), 
    560                             CvParamGrid nuGrid     = get_default_grid(CvSVM::NU), 
    561                             CvParamGrid coeffGrid  = get_default_grid(CvSVM::COEF), 
    562                             CvParamGrid degreeGrid = get_default_grid(CvSVM::DEGREE) ); 
     559                            CvParamGrid Cgrid      = CvSVM::get_default_grid(CvSVM::C), 
     560                            CvParamGrid gammaGrid  = CvSVM::get_default_grid(CvSVM::GAMMA), 
     561                            CvParamGrid pGrid      = CvSVM::get_default_grid(CvSVM::P), 
     562                            CvParamGrid nuGrid     = CvSVM::get_default_grid(CvSVM::NU), 
     563                            CvParamGrid coeffGrid  = CvSVM::get_default_grid(CvSVM::COEF), 
     564                            CvParamGrid degreeGrid = CvSVM::get_default_grid(CvSVM::DEGREE) ); 
    563565    CV_WRAP virtual float predict( const cv::Mat& sample, bool returnDFVal=false ) const;     
    564566#endif 
     
    566568    CV_WRAP virtual int get_support_vector_count() const; 
    567569    virtual const float* get_support_vector(int i) const; 
    568     CV_WRAP virtual CvSVMParams get_params() const { return params; }; 
     570    virtual CvSVMParams get_params() const { return params; }; 
    569571    CV_WRAP virtual void clear(); 
    570572 
     
    609611\****************************************************************************************/ 
    610612 
    611 struct CV_EXPORTS_AS_MAP CvEMParams 
     613struct CV_EXPORTS_W_MAP CvEMParams 
    612614{ 
    613615    CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/), 
     
    625627    {} 
    626628 
    627     int nclusters; 
    628     int cov_mat_type; 
    629     int start_step; 
     629    CV_PROP_RW int nclusters; 
     630    CV_PROP_RW int cov_mat_type; 
     631    CV_PROP_RW int start_step; 
    630632    const CvMat* probs; 
    631633    const CvMat* weights; 
    632634    const CvMat* means; 
    633635    const CvMat** covs; 
    634     CvTermCriteria term_crit; 
    635 }; 
    636  
    637  
    638 class CV_EXPORTS_AS(EM) CvEM : public CvStatModel 
     636    CV_PROP_RW CvTermCriteria term_crit; 
     637}; 
     638 
     639 
     640class CV_EXPORTS_W CvEM : public CvStatModel 
    639641{ 
    640642public: 
     
    660662#ifndef SWIG 
    661663    CV_WRAP CvEM( const cv::Mat& samples, const cv::Mat& sampleIdx=cv::Mat(), 
    662          CvEMParams params=CvEMParams(), cv::Mat* labels=0 ); 
    663      
    664     CV_WRAP virtual bool train( const cv::Mat& samples, const cv::Mat& sampleIdx=cv::Mat(), 
    665                        CvEMParams params=CvEMParams(), cv::Mat* labels=0 ); 
    666      
    667     CV_WRAP virtual float predict( const cv::Mat& sample, cv::Mat* probs ) const; 
     664                  CvEMParams params=CvEMParams() ); 
     665     
     666    CV_WRAP virtual bool train( const cv::Mat& samples, 
     667                                const cv::Mat& sampleIdx=cv::Mat(), 
     668                                CvEMParams params=CvEMParams(), 
     669                                CV_OUT cv::Mat* labels=0 ); 
     670     
     671    CV_WRAP virtual float predict( const cv::Mat& sample, CV_OUT cv::Mat* probs=0 ) const; 
     672     
     673    CV_WRAP int  getNClusters() const; 
     674    CV_WRAP cv::Mat  getMeans()     const; 
     675    CV_WRAP void getCovs(CV_OUT std::vector<cv::Mat>& covs)      const; 
     676    CV_WRAP cv::Mat  getWeights()   const; 
     677    CV_WRAP cv::Mat  getProbs()     const; 
     678     
     679    CV_WRAP inline double getLikelihood() const { return log_likelihood;     }; 
    668680#endif 
    669681     
    670682    CV_WRAP virtual void clear(); 
    671683 
    672     CV_WRAP int           get_nclusters() const; 
    673     CV_WRAP const CvMat*  get_means()     const; 
    674     CV_WRAP const CvMat** get_covs()      const; 
    675     CV_WRAP const CvMat*  get_weights()   const; 
    676     CV_WRAP const CvMat*  get_probs()     const; 
    677  
    678     CV_WRAP inline double         get_log_likelihood     () const { return log_likelihood;     }; 
     684    int           get_nclusters() const; 
     685    const CvMat*  get_means()     const; 
     686    const CvMat** get_covs()      const; 
     687    const CvMat*  get_weights()   const; 
     688    const CvMat*  get_probs()     const; 
     689 
     690    inline double         get_log_likelihood     () const { return log_likelihood;     }; 
    679691     
    680692//    inline const CvMat *  get_log_weight_div_det () const { return log_weight_div_det; }; 
     
    772784 
    773785 
    774 struct CV_EXPORTS_AS_MAP CvDTreeParams 
    775 { 
    776     int   max_categories; 
    777     int   max_depth; 
    778     int   min_sample_count; 
    779     int   cv_folds; 
    780     bool  use_surrogates; 
    781     bool  use_1se_rule; 
    782     bool  truncate_pruned_tree; 
    783     float regression_accuracy; 
     786struct CV_EXPORTS_W_MAP CvDTreeParams 
     787{ 
     788    CV_PROP_RW int   max_categories; 
     789    CV_PROP_RW int   max_depth; 
     790    CV_PROP_RW int   min_sample_count; 
     791    CV_PROP_RW int   cv_folds; 
     792    CV_PROP_RW bool  use_surrogates; 
     793    CV_PROP_RW bool  use_1se_rule; 
     794    CV_PROP_RW bool  truncate_pruned_tree; 
     795    CV_PROP_RW float regression_accuracy; 
    784796    const float* priors; 
    785797 
     
    915927} 
    916928 
    917 class CV_EXPORTS_AS(DTree) CvDTree : public CvStatModel 
     929class CV_EXPORTS_W CvDTree : public CvStatModel 
    918930{ 
    919931public: 
     
    946958    CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& sample, const cv::Mat& missingDataMask=cv::Mat(), 
    947959                                  bool preprocessedInput=false ) const; 
     960    CV_WRAP virtual cv::Mat getVarImportance(); 
    948961#endif 
    949962     
    950     CV_WRAP virtual const CvMat* get_var_importance(); 
     963    virtual const CvMat* get_var_importance(); 
    951964    CV_WRAP virtual void clear(); 
    952965 
     
    10481061 
    10491062 
    1050 struct CV_EXPORTS_AS_MAP CvRTParams : public CvDTreeParams 
     1063struct CV_EXPORTS_W_MAP CvRTParams : public CvDTreeParams 
    10511064{ 
    10521065    //Parameters for the forest 
    1053     bool calc_var_importance; // true <=> RF processes variable importance 
    1054     int nactive_vars; 
    1055     CvTermCriteria term_crit; 
     1066    CV_PROP_RW bool calc_var_importance; // true <=> RF processes variable importance 
     1067    CV_PROP_RW int nactive_vars; 
     1068    CV_PROP_RW CvTermCriteria term_crit; 
    10561069 
    10571070    CvRTParams() : CvDTreeParams( 5, 10, 0, false, 10, 0, false, false, 0 ), 
     
    10781091 
    10791092 
    1080 class CV_EXPORTS_AS(RTrees) CvRTrees : public CvStatModel 
     1093class CV_EXPORTS_W CvRTrees : public CvStatModel 
    10811094{ 
    10821095public: 
     
    11011114    CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const; 
    11021115    CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const; 
     1116    CV_WRAP virtual cv::Mat getVarImportance(); 
    11031117#endif 
    11041118     
    11051119    CV_WRAP virtual void clear(); 
    11061120 
    1107     CV_WRAP virtual const CvMat* get_var_importance(); 
     1121    virtual const CvMat* get_var_importance(); 
    11081122    virtual float get_proximity( const CvMat* sample1, const CvMat* sample2, 
    11091123        const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const; 
     
    11771191}; 
    11781192 
    1179 class CV_EXPORTS_AS(ERTrees) CvERTrees : public CvRTrees 
     1193class CV_EXPORTS_W CvERTrees : public CvRTrees 
    11801194{ 
    11811195public: 
     
    12041218\****************************************************************************************/ 
    12051219 
    1206 struct CV_EXPORTS_AS_MAP CvBoostParams : public CvDTreeParams 
    1207 { 
    1208     int boost_type; 
    1209     int weak_count; 
    1210     int split_criteria; 
    1211     double weight_trim_rate; 
     1220struct CV_EXPORTS_W_MAP CvBoostParams : public CvDTreeParams 
     1221{ 
     1222    CV_PROP_RW int boost_type; 
     1223    CV_PROP_RW int weak_count; 
     1224    CV_PROP_RW int split_criteria; 
     1225    CV_PROP_RW double weight_trim_rate; 
    12121226 
    12131227    CvBoostParams(); 
     
    12661280 
    12671281 
    1268 class CV_EXPORTS_AS(Boost) CvBoost : public CvStatModel 
     1282class CV_EXPORTS_W CvBoost : public CvStatModel 
    12691283{ 
    12701284public: 
     
    13141328     
    13151329    CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(), 
    1316                           cv::Mat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ, 
    1317                           bool rawMode=false, bool returnSum=false ) const; 
     1330                                   const cv::Range& slice=cv::Range::all(), bool rawMode=false, 
     1331                                  bool returnSum=false ) const; 
    13181332#endif 
    13191333     
     
    13831397 
    13841398 
    1385 struct CV_EXPORTS_AS_MAP CvGBTreesParams : public CvDTreeParams 
    1386 { 
    1387     int weak_count; 
    1388     int loss_function_type; 
    1389     float subsample_portion; 
    1390     float shrinkage; 
     1399struct CV_EXPORTS_W_MAP CvGBTreesParams : public CvDTreeParams 
     1400{ 
     1401    CV_PROP_RW int weak_count; 
     1402    CV_PROP_RW int loss_function_type; 
     1403    CV_PROP_RW float subsample_portion; 
     1404    CV_PROP_RW float shrinkage; 
    13911405 
    13921406    CvGBTreesParams(); 
     
    14431457 
    14441458 
    1445 class CV_EXPORTS_AS(GBTrees) CvGBTrees : public CvStatModel 
     1459class CV_EXPORTS_W CvGBTrees : public CvStatModel 
    14461460{ 
    14471461public: 
     
    15241538    // RESULT 
    15251539    */ 
    1526     CV_WRAP CvGBTrees( const CvMat* trainData, int tflag, 
     1540    CvGBTrees( const CvMat* trainData, int tflag, 
    15271541             const CvMat* responses, const CvMat* varIdx=0, 
    15281542             const CvMat* sampleIdx=0, const CvMat* varType=0, 
     
    15761590    // Error state. 
    15771591    */ 
    1578     CV_WRAP virtual bool train( const CvMat* trainData, int tflag, 
     1592    virtual bool train( const CvMat* trainData, int tflag, 
    15791593             const CvMat* responses, const CvMat* varIdx=0, 
    15801594             const CvMat* sampleIdx=0, const CvMat* varType=0, 
     
    16321646    // Predicted value. 
    16331647    */ 
    1634     CV_WRAP virtual float predict( const CvMat* sample, const CvMat* missing=0, 
     1648    virtual float predict( const CvMat* sample, const CvMat* missing=0, 
    16351649            CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ, 
    16361650            int k=-1 ) const; 
     
    17031717    virtual void read( CvFileStorage* fs, CvFileNode* node ); 
    17041718 
    1705  
     1719     
     1720    // new-style C++ interface 
     1721    CV_WRAP CvGBTrees( const cv::Mat& trainData, int tflag, 
     1722              const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(), 
     1723              const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), 
     1724              const cv::Mat& missingDataMask=cv::Mat(), 
     1725              CvGBTreesParams params=CvGBTreesParams() ); 
     1726     
     1727    CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag, 
     1728                       const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(), 
     1729                       const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), 
     1730                       const cv::Mat& missingDataMask=cv::Mat(), 
     1731                       CvGBTreesParams params=CvGBTreesParams(), 
     1732                       bool update=false ); 
     1733 
     1734    CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(), 
     1735                           const cv::Range& slice = cv::Range::all(), 
     1736                           int k=-1 ) const; 
     1737     
    17061738protected: 
    17071739 
     
    18941926/////////////////////////////////// Multi-Layer Perceptrons ////////////////////////////// 
    18951927 
    1896 struct CV_EXPORTS_AS_MAP CvANN_MLP_TrainParams 
     1928struct CV_EXPORTS_W_MAP CvANN_MLP_TrainParams 
    18971929{ 
    18981930    CvANN_MLP_TrainParams(); 
     
    19031935    enum { BACKPROP=0, RPROP=1 }; 
    19041936 
    1905     CvTermCriteria term_crit; 
    1906     int train_method; 
     1937    CV_PROP_RW CvTermCriteria term_crit; 
     1938    CV_PROP_RW int train_method; 
    19071939 
    19081940    // backpropagation parameters 
    1909     double bp_dw_scale, bp_moment_scale; 
     1941    CV_PROP_RW double bp_dw_scale, bp_moment_scale; 
    19101942 
    19111943    // rprop parameters 
    1912     double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max; 
    1913 }; 
    1914  
    1915  
    1916 class CV_EXPORTS_AS(ANN_MLP) CvANN_MLP : public CvStatModel 
     1944    CV_PROP_RW double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max; 
     1945}; 
     1946 
     1947 
     1948class CV_EXPORTS_W CvANN_MLP : public CvStatModel 
    19171949{ 
    19181950public: 
    19191951    CV_WRAP CvANN_MLP(); 
    19201952    CvANN_MLP( const CvMat* layerSizes, 
    1921                int activateFunc=SIGMOID_SYM, 
     1953               int activateFunc=CvANN_MLP::SIGMOID_SYM, 
    19221954               double fparam1=0, double fparam2=0 ); 
    19231955 
     
    19251957 
    19261958    virtual void create( const CvMat* layerSizes, 
    1927                          int activateFunc=SIGMOID_SYM, 
     1959                         int activateFunc=CvANN_MLP::SIGMOID_SYM, 
    19281960                         double fparam1=0, double fparam2=0 ); 
    19291961     
     
    19361968#ifndef SWIG 
    19371969    CV_WRAP CvANN_MLP( const cv::Mat& layerSizes, 
    1938               int activateFunc=SIGMOID_SYM, 
     1970              int activateFunc=CvANN_MLP::SIGMOID_SYM, 
    19391971              double fparam1=0, double fparam2=0 ); 
    19401972     
    19411973    CV_WRAP virtual void create( const cv::Mat& layerSizes, 
    1942                         int activateFunc=SIGMOID_SYM, 
     1974                        int activateFunc=CvANN_MLP::SIGMOID_SYM, 
    19431975                        double fparam1=0, double fparam2=0 );     
    19441976     
  • trunk/opencv/modules/ml/src/ann_mlp.cpp

    r3060 r3860  
    15021502using namespace cv; 
    15031503 
     1504CvANN_MLP::CvANN_MLP( const Mat& _layer_sizes, int _activ_func, 
     1505                      double _f_param1, double _f_param2 ) 
     1506{ 
     1507    layer_sizes = wbuf = 0; 
     1508    min_val = max_val = min_val1 = max_val1 = 0.; 
     1509    weights = 0; 
     1510    rng = cvRNG(-1); 
     1511    default_model_name = "my_nn"; 
     1512    create( _layer_sizes, _activ_func, _f_param1, _f_param2 ); 
     1513} 
     1514 
    15041515void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func, 
    15051516                       double _f_param1, double _f_param2 ) 
  • trunk/opencv/modules/ml/src/boost.cpp

    r3837 r3860  
    21392139float 
    21402140CvBoost::predict( const Mat& _sample, const Mat& _missing, 
    2141                  Mat* weak_responses, CvSlice slice, 
    2142                  bool raw_mode, bool return_sum ) const 
    2143 { 
    2144     CvMat sample = _sample, mmask = _missing, wr, *pwr = 0; 
    2145     if( weak_responses ) 
     2141                  const Range& slice, bool raw_mode, bool return_sum ) const 
     2142{ 
     2143    CvMat sample = _sample, mmask = _missing; 
     2144    /*if( weak_responses ) 
    21462145    { 
    21472146        int weak_count = cvSliceLength( slice, weak ); 
     
    21572156            weak_responses->create(weak_count, 1, CV_32FC1); 
    21582157        pwr = &(wr = *weak_responses); 
    2159     } 
    2160     return predict(&sample, &mmask, pwr, slice, raw_mode, return_sum); 
     2158    }*/ 
     2159    return predict(&sample, _missing.empty() ? &mmask : 0, 0, 
     2160                   slice == Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), 
     2161                   raw_mode, return_sum); 
    21612162} 
    21622163 
  • trunk/opencv/modules/ml/src/em.cpp

    r3060 r3860  
    11101110using namespace cv; 
    11111111 
    1112 CvEM::CvEM( const Mat& samples, const Mat& sample_idx, 
    1113            CvEMParams params, Mat* labels ) 
     1112CvEM::CvEM( const Mat& samples, const Mat& sample_idx, CvEMParams params ) 
    11141113{ 
    11151114    means = weights = probs = inv_eigen_values = log_weight_div_det = 0; 
     
    11171116     
    11181117    // just invoke the train() method 
    1119     train(samples, sample_idx, params, labels); 
     1118    train(samples, sample_idx, params); 
    11201119}     
    11211120 
     
    11551154} 
    11561155 
     1156int CvEM::getNClusters() const 
     1157{ 
     1158    return params.nclusters; 
     1159} 
     1160 
     1161Mat CvEM::getMeans() const 
     1162{ 
     1163    return Mat(means); 
     1164} 
     1165 
     1166void CvEM::getCovs(vector<Mat>& _covs) const 
     1167{ 
     1168    int i, n = params.nclusters; 
     1169    _covs.resize(n); 
     1170    for( i = 0; i < n; i++ ) 
     1171        _covs[i] = Mat(covs[i]); 
     1172} 
     1173 
     1174Mat CvEM::getWeights() const 
     1175{ 
     1176    return Mat(weights); 
     1177} 
     1178 
     1179Mat CvEM::getProbs() const 
     1180{ 
     1181    return Mat(probs); 
     1182} 
     1183 
    11571184 
    11581185/* End of file. */ 
  • trunk/opencv/modules/ml/src/gbt.cpp

    r3829 r3860  
    10411041 
    10421042} 
     1043 
     1044 
     1045CvGBTrees::CvGBTrees( const cv::Mat& trainData, int tflag, 
     1046          const cv::Mat& responses, const cv::Mat& varIdx, 
     1047          const cv::Mat& sampleIdx, const cv::Mat& varType, 
     1048          const cv::Mat& missingDataMask, 
     1049          CvGBTreesParams params ) 
     1050{ 
     1051    data = 0; 
     1052    weak = 0; 
     1053    default_model_name = "my_boost_tree"; 
     1054    orig_response = sum_response = sum_response_tmp = 0; 
     1055    weak_eval = subsample_train = subsample_test = 0; 
     1056    missing = sample_idx = 0; 
     1057    class_labels = 0; 
     1058    class_count = 1; 
     1059    delta = 0.0f; 
     1060     
     1061    clear(); 
     1062     
     1063    train(trainData, tflag, responses, varIdx, sampleIdx, varType, missingDataMask, params, false); 
     1064} 
     1065 
     1066bool CvGBTrees::train( const cv::Mat& trainData, int tflag, 
     1067                   const cv::Mat& responses, const cv::Mat& varIdx, 
     1068                   const cv::Mat& sampleIdx, const cv::Mat& varType, 
     1069                   const cv::Mat& missingDataMask, 
     1070                   CvGBTreesParams params, 
     1071                   bool update ) 
     1072{ 
     1073    CvMat _trainData = trainData, _responses = responses; 
     1074    CvMat _varIdx = varIdx, _sampleIdx = sampleIdx, _varType = _varType; 
     1075    CvMat _missingDataMask = missingDataMask; 
     1076     
     1077    return train(&_trainData, tflag, &_responses, varIdx.empty() ? &_varIdx : 0, 
     1078          sampleIdx.empty() ? &_sampleIdx : 0, varType.empty() ? &_varType : 0, 
     1079          missingDataMask.empty() ? &_missingDataMask : 0, params, update); 
     1080} 
     1081 
     1082float CvGBTrees::predict( const cv::Mat& sample, const cv::Mat& missing, 
     1083                          const cv::Range& slice, int k ) const 
     1084{ 
     1085    CvMat _sample = sample, _missing = missing; 
     1086    return predict(&_sample, missing.empty() ? &_missing : 0, 0, 
     1087                   slice==cv::Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), k); 
     1088} 
  • trunk/opencv/modules/ml/src/knearest.cpp

    r3060 r3860  
    453453} 
    454454 
     455 
     456float CvKNearest::find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results, 
     457                                CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const 
     458{ 
     459    return find_nearest(samples, k, &results, 0, &neighborResponses, &dists); 
     460} 
     461 
    455462/* End of file */ 
    456463 
  • trunk/opencv/modules/ml/src/nbayes.cpp

    r3060 r3860  
    568568using namespace cv; 
    569569 
     570CvNormalBayesClassifier::CvNormalBayesClassifier( const Mat& _train_data, const Mat& _responses, 
     571                                    const Mat& _var_idx, const Mat& _sample_idx ) 
     572{ 
     573    var_count = var_all = 0; 
     574    var_idx = 0; 
     575    cls_labels = 0; 
     576    count = 0; 
     577    sum = 0; 
     578    productsum = 0; 
     579    avg = 0; 
     580    inv_eigen_values = 0; 
     581    cov_rotate_mats = 0; 
     582    c = 0; 
     583    default_model_name = "my_nb"; 
     584     
     585    CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx; 
     586    train(&tdata, &responses, vidx.data.ptr ? &vidx : 0, 
     587                 sidx.data.ptr ? &sidx : 0); 
     588} 
     589 
    570590bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _responses, 
    571591                                    const Mat& _var_idx, const Mat& _sample_idx, bool update ) 
  • trunk/opencv/modules/ml/src/rtrees.cpp

    r3603 r3860  
    838838} 
    839839 
     840Mat CvRTrees::getVarImportance() 
     841{ 
     842    return Mat(get_var_importance()); 
     843} 
    840844 
    841845// End of file. 
  • trunk/opencv/modules/ml/src/svm.cpp

    r3486 r3860  
    19861986 
    19871987 
     1988CvSVM::CvSVM( const Mat& _train_data, const Mat& _responses, 
     1989              const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params ) 
     1990{ 
     1991    decision_func = 0; 
     1992    class_labels = 0; 
     1993    class_weights = 0; 
     1994    storage = 0; 
     1995    var_idx = 0; 
     1996    kernel = 0; 
     1997    solver = 0; 
     1998    default_model_name = "my_svm"; 
     1999     
     2000    train( _train_data, _responses, _var_idx, _sample_idx, _params ); 
     2001} 
     2002 
    19882003bool CvSVM::train( const Mat& _train_data, const Mat& _responses, 
    19892004                  const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params ) 
  • trunk/opencv/modules/ml/src/tree.cpp

    r3659 r3860  
    40754075} 
    40764076 
     4077Mat CvDTree::getVarImportance() 
     4078{ 
     4079    return Mat(get_var_importance()); 
     4080} 
     4081 
    40774082/* End of file. */ 
  • trunk/opencv/modules/objdetect/include/opencv2/objdetect/objdetect.hpp

    r3837 r3860  
    364364    CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8), 
    365365        cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1), 
    366         histogramNormType(L2Hys), L2HysThreshold(0.2), gammaCorrection(true) 
     366        histogramNormType(HOGDescriptor::L2Hys), L2HysThreshold(0.2), gammaCorrection(true) 
    367367    {} 
    368368     
    369369    CV_WRAP HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, 
    370370                  Size _cellSize, int _nbins, int _derivAperture=1, double _winSigma=-1, 
    371                   int _histogramNormType=L2Hys, double _L2HysThreshold=0.2, bool _gammaCorrection=false) 
     371                  int _histogramNormType=HOGDescriptor::L2Hys, 
     372                  double _L2HysThreshold=0.2, bool _gammaCorrection=false) 
    372373    : winSize(_winSize), blockSize(_blockSize), blockStride(_blockStride), cellSize(_cellSize), 
    373374    nbins(_nbins), derivAperture(_derivAperture), winSigma(_winSigma), 
  • trunk/opencv/modules/python/CMakeLists.txt

    r3737 r3860  
    1919    "${CMAKE_SOURCE_DIR}/modules/contrib/include" 
    2020    ) 
    21      
     21 
    2222include_directories(${CMAKE_CURRENT_BINARY_DIR}) 
     23 
     24set(opencv_hdrs "${CMAKE_SOURCE_DIR}/modules/core/include/opencv2/core/core.hpp" 
     25    "${CMAKE_SOURCE_DIR}/modules/imgproc/include/opencv2/imgproc/imgproc.hpp" 
     26    "${CMAKE_SOURCE_DIR}/modules/video/include/opencv2/video/background_segm.hpp" 
     27    "${CMAKE_SOURCE_DIR}/modules/video/include/opencv2/video/tracking.hpp" 
     28    "${CMAKE_SOURCE_DIR}/modules/highgui/include/opencv2/highgui/highgui.hpp" 
     29    "${CMAKE_SOURCE_DIR}/modules/ml/include/opencv2/ml/ml.hpp" 
     30    "${CMAKE_SOURCE_DIR}/modules/features2d/include/opencv2/features2d/features2d.hpp" 
     31    "${CMAKE_SOURCE_DIR}/modules/calib3d/include/opencv2/calib3d/calib3d.hpp" 
     32    "${CMAKE_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp" 
     33    "${CMAKE_SOURCE_DIR}/modules/python/opencv_extra_api.hpp") 
     34 
     35set(generated_hdrs 
     36        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_funcs.h" 
     37        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_func_tab.h" 
     38        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_types.h" 
     39        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_type_reg.h" 
     40        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_const_reg.h") 
    2341 
    2442if(MSVC) 
     
    2745 
    2846file(GLOB lib_srcs "*.cpp") 
     47file(GLOB lib_hdrs "*.h") 
    2948 
    3049add_custom_command( 
     
    3655   ) 
    3756 
     57add_custom_command( 
     58  OUTPUT ${generated_hdrs} 
     59  COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gen2.py ${CMAKE_CURRENT_BINARY_DIR} ${opencv_hdrs} 
     60  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/gen2.py 
     61  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/hdr_parser.py 
     62  DEPENDS ${opencv_hdrs} 
     63  ) 
     64 
    3865set(the_target "opencv_python") 
    39 add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${CMAKE_CURRENT_BINARY_DIR}/generated0.i) 
     66add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${CMAKE_CURRENT_BINARY_DIR}/generated0.i opencv2x.h opencv_extra_api.hpp ${generated_hdrs}) 
    4067target_link_libraries(${the_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib) 
    4168     
  • trunk/opencv/modules/python/cv.cpp

    r3844 r3860  
    38493849 
    38503850#include "opencv2x.h" 
     3851#include "pyopencv_generated_types.h" 
     3852#include "pyopencv_generated_funcs.h" 
    38513853 
    38523854static PyMethodDef methods[] = { 
     
    38543856#if PYTHON_USE_NUMPY 
    38553857    {"fromarray", (PyCFunction)pycvfromarray, METH_KEYWORDS, "fromarray(array) -> cvmatnd"}, 
    3856    
    3857     {"absdiff", (PyCFunction)cv::pyopencv_absdiff, METH_KEYWORDS, "absdiff(src1,src2,dst=None) -> dst"},     
    3858     {"add", (PyCFunction)cv::pyopencv_add, METH_KEYWORDS, "add(src1,src2,dst=None,mask=None) -> dst"}, 
    3859     {"bitwise_and", (PyCFunction)cv::pyopencv_and, METH_KEYWORDS, "bitwise_and(src1,src2,dst=None,mask=None) -> dst"}, 
    3860     {"bitwise_or", (PyCFunction)cv::pyopencv_or, METH_KEYWORDS, "bitwise_or(src1,src2,dst=None,mask=None) -> dst"}, 
    3861     {"bitwise_xor", (PyCFunction)cv::pyopencv_xor, METH_KEYWORDS, "bitwise_xor(src1,src2,dst=None,mask=None) -> dst"}, 
    3862     {"max", (PyCFunction)cv::pyopencv_max, METH_KEYWORDS, "max(src1,src2,dst=None) -> dst"}, 
    3863     {"min", (PyCFunction)cv::pyopencv_min, METH_KEYWORDS, "min(src1,src2,dst=None) -> dst"}, 
    3864     {"subtract", (PyCFunction)cv::pyopencv_subtract, METH_KEYWORDS, "subtract(src1,src2,dst=None,mask=None) -> dst"}, 
    38653858#endif 
    38663859 
     
    38733866 
    38743867#include "generated1.i" 
     3868#include "pyopencv_generated_func_tab.h" 
    38753869 
    38763870  {NULL, NULL}, 
     
    38883882} 
    38893883 
    3890 #define MKTYPE(NAME)  do { NAME##_specials(); if (!to_ok(&NAME##_Type)) return; } while (0) 
     3884#define MKTYPE(NAME)  NAME##_specials(); if (!to_ok(&NAME##_Type)) return 
     3885#define MKTYPE2(NAME) pyopencv_##NAME##_specials(); if (!to_ok(&pyopencv_##NAME##_Type)) return 
    38913886 
    38923887using namespace cv; 
     
    39243919 
    39253920#include "generated4.i" 
     3921#include "pyopencv_generated_type_reg.h" 
    39263922 
    39273923  m = Py_InitModule(MODULESTR"", methods); 
     
    39453941#define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I)) 
    39463942#define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I)) 
     3943#define PUBLISH2(I, value) PyDict_SetItemString(d, #I, PyLong_FromLong(value)) 
    39473944 
    39483945  PUBLISHU(IPL_DEPTH_8U); 
     
    40194016 
    40204017#include "generated2.i" 
     4018#include "pyopencv_generated_const_reg.h" 
    40214019 
    40224020#if 0 
  • trunk/opencv/modules/python/gen2.py

    r3843 r3860  
    1 import opencv_parser, sys, re, cStringIO 
     1import hdr_parser, sys, re, os, cStringIO 
    22from string import Template 
    33 
    44gen_template_check_self = Template("""    if(!PyObject_TypeCheck(self, &pyopencv_${name}_Type)) 
    5         return failmsg("Incorrect type of self (must be '${name}' or its derivative)"); 
    6     $cname* _self_ = ((pyopencv_${name}_t*)self)->v; 
     5        return failmsgp("Incorrect type of self (must be '${name}' or its derivative)"); 
     6    $cname* _self_ = ${amp}((pyopencv_${name}_t*)self)->v; 
    77""") 
    88 
    99gen_template_call_constructor = Template("""self = PyObject_NEW(pyopencv_${name}_t, &pyopencv_${name}_Type); 
    10         if(self) ERRWRAP2(self->v = new $cname""") 
     10        if(self) ERRWRAP2(self->v = $op$cname""") 
    1111 
    1212gen_template_parse_args = Template("""const char* keywords[] = { $kw_list, NULL }; 
     
    1717    { 
    1818        $code_fcall; 
    19         return $code_retval; 
     19        $code_ret; 
    2020    } 
    2121""") 
    2222 
    23 gen_template_set_prop_from_map = Template(""" 
    24     if( PyMapping_HasKeyString(src, "$propname") ) 
    25     { 
    26         tmp = PyMapping_GetItemString(src, "$propname"); 
    27         ok = tmp && pyopencv_to_$proptype(tmp, dst.$propname); 
    28         Py_DECREF(tmp); 
    29         if(!ok) return false; 
    30     }""") 
    31  
    32 gen_template_decl_type = Template(""" 
    33 /* 
    34   $cname is the OpenCV C struct 
    35   pyopencv_${name}_t is the Python object 
    36 */ 
    37  
     23gen_template_simple_type_decl = Template(""" 
    3824struct pyopencv_${name}_t 
    3925{ 
    4026    PyObject_HEAD 
    41     ${cname}* v; 
    42 }; 
    43  
    44 static void pyopencv_${name}_dealloc(PyObject* self) 
    45 { 
    46     delete ((pyopencv_${name}_t*)self)->v; 
    47     PyObject_Del(self); 
    48 } 
    49  
    50 static PyObject* pyopencv_${name}_repr(PyObject* self) 
    51 { 
    52     char str[1000]; 
    53     sprintf(str, "<$wname %p>", self); 
    54     return PyString_FromString(str); 
    55 } 
    56  
    57 ${getset_code} 
    58  
    59 static PyGetSetDef pyopencv_${name}_getseters[] = 
    60 {${getset_inits} 
    61     {NULL}  /* Sentinel */ 
    62 }; 
    63  
    64 ${methods_code} 
    65  
    66 static PyMethodDef pyopencv_${name}_methods[] = 
    67 { 
    68 ${methods_inits} 
    69     {NULL,          NULL} 
     27    ${cname} v; 
    7028}; 
    7129 
     
    7836}; 
    7937 
     38static void pyopencv_${name}_dealloc(PyObject* self) 
     39{ 
     40    PyObject_Del(self); 
     41} 
     42 
     43static PyObject* pyopencv_from(const ${cname}& r) 
     44{ 
     45    pyopencv_${name}_t *m = PyObject_NEW(pyopencv_${name}_t, &pyopencv_${name}_Type); 
     46    m->v = r; 
     47    return (PyObject*)m; 
     48} 
     49 
     50static bool pyopencv_to(PyObject* src, ${cname}& dst, const char* name="<unknown>") 
     51{ 
     52    if( src == NULL or src == Py_None ) 
     53        return true; 
     54    if(!PyObject_TypeCheck(src, &pyopencv_${name}_Type)) 
     55    { 
     56        failmsg("Expected ${cname} for argument '%s'", name); 
     57        return false; 
     58    } 
     59    dst = ((pyopencv_${name}_t*)src)->v; 
     60    return true; 
     61} 
     62""") 
     63 
     64 
     65gen_template_type_decl = Template(""" 
     66struct pyopencv_${name}_t 
     67{ 
     68    PyObject_HEAD 
     69    ${cname}* v; 
     70}; 
     71 
     72static PyTypeObject pyopencv_${name}_Type = 
     73{ 
     74    PyObject_HEAD_INIT(&PyType_Type) 
     75    0, 
     76    MODULESTR".$wname", 
     77    sizeof(pyopencv_${name}_t), 
     78}; 
     79 
     80static void pyopencv_${name}_dealloc(PyObject* self) 
     81{ 
     82    delete ((pyopencv_${name}_t*)self)->v; 
     83    PyObject_Del(self); 
     84} 
     85""") 
     86 
     87gen_template_map_type_cvt = Template(""" 
     88static bool pyopencv_to(PyObject* src, ${cname}& dst, const char* name="<unknown>"); 
     89""") 
     90 
     91gen_template_set_prop_from_map = Template(""" 
     92    if( PyMapping_HasKeyString(src, (char*)"$propname") ) 
     93    { 
     94        tmp = PyMapping_GetItemString(src, (char*)"$propname"); 
     95        ok = tmp && pyopencv_to(tmp, dst.$propname); 
     96        Py_DECREF(tmp); 
     97        if(!ok) return false; 
     98    }""") 
     99 
     100gen_template_type_impl = Template(""" 
     101static PyObject* pyopencv_${name}_repr(PyObject* self) 
     102{ 
     103    char str[1000]; 
     104    sprintf(str, "<$wname %p>", self); 
     105    return PyString_FromString(str); 
     106} 
     107 
     108${getset_code} 
     109 
     110static PyGetSetDef pyopencv_${name}_getseters[] = 
     111{${getset_inits} 
     112    {NULL}  /* Sentinel */ 
     113}; 
     114 
     115${methods_code} 
     116 
     117static PyMethodDef pyopencv_${name}_methods[] = 
     118{ 
     119${methods_inits} 
     120    {NULL,          NULL} 
     121}; 
     122 
    80123static void pyopencv_${name}_specials(void) 
    81124{ 
     
    86129    pyopencv_${name}_Type.tp_methods = pyopencv_${name}_methods;${extra_specials} 
    87130} 
    88  
    89 static PyObject* pyopencv_from_${name}_ptr(<$cname>* r) 
    90 { 
    91     pyopencv_${name}_t *m = PyObject_NEW(pyopencv_${name}_t, &pyopencv_${name}_Type); 
    92     m->v = r; 
    93     return (PyObject*)m; 
    94 } 
    95  
    96 static bool pyopencv_to_${name}_ptr(PyObject* src, <$cname>*& dst, const char* name="") 
    97 { 
    98     if( src == NULL or src == Py_None ) 
    99     { 
    100         dst = 0; 
    101         return true; 
    102     } 
    103     if(!PyObject_TypeCheck(src, &pyopencv_${name}_Type)) 
    104         return failmsg("Expected ${cname} for argument '%s'", name); 
    105     dst = ((pyopencv_${name}_t*)src)->v; 
    106     return true; 
    107 } 
    108131""") 
     132 
    109133 
    110134gen_template_get_prop = Template(""" 
    111135static PyObject* pyopencv_${name}_get_${member}(pyopencv_${name}_t* p, void *closure) 
    112136{ 
    113     return pyopencv_from_${membertype}(p->v->${member}); 
     137    return pyopencv_from(p->v${access}${member}); 
    114138} 
    115139""") 
     
    123147        return -1; 
    124148    } 
    125     return pyopencv_to_${membertype}(value, p->v->${member}) ? 0 : -1; 
     149    return pyopencv_to(value, p->v${access}${member}) ? 0 : -1; 
    126150} 
    127151""") 
     
    134158 
    135159simple_argtype_mapping = { 
    136     "bool": ("bool", "b", "pyopencv_from_bool", "0"), 
    137     "int": ("int", "i", "pyopencv_from_int", "0"), 
    138     "float": ("float", "f", "pyopencv_from_float", "0.f"), 
    139     "double": ("double", "d", "pyopencv_from_double", "0"), 
    140     "c_string": ("char*", "s", "pyopencv_from_c_string", '""') 
     160    "bool": ("bool", "b", "0"), 
     161    "int": ("int", "i", "0"), 
     162    "float": ("float", "f", "0.f"), 
     163    "double": ("double", "d", "0"), 
     164    "c_string": ("char*", "s", '""') 
    141165} 
    142166 
    143167class ClassProp(object): 
    144168    def __init__(self, decl): 
    145         self.tp = decl[0] 
     169        self.tp = decl[0].replace("*", "_ptr") 
    146170        self.name = decl[1] 
    147171        self.readonly = True 
     
    154178        self.name = self.wname = re.sub(r"^cv\.", "", name) 
    155179        self.ismap = False 
     180        self.issimple = False 
    156181        self.methods = {} 
    157182        self.props = [] 
     
    171196                elif m == "/Map": 
    172197                    self.ismap = True 
     198                elif m == "/Simple": 
     199                    self.issimple = True 
    173200            self.props = [ClassProp(p) for p in decl[3]] 
    174201         
     
    176203            self.wname = self.wname[2:] 
    177204         
    178     def gen_map_code(self): 
    179         code = "static bool pyopencv_to_%s(PyObject* src, %s& dst)\n{\n    PyObject* tmp;\n    bool ok;\n" % (self.name, self.cname) 
     205    def gen_map_code(self, all_classes): 
     206        code = "static bool pyopencv_to(PyObject* src, %s& dst, const char* name)\n{\n    PyObject* tmp;\n    bool ok;\n" % (self.cname) 
    180207        code += "".join([gen_template_set_prop_from_map.substitute(propname=p.name,proptype=p.tp) for p in self.props]) 
    181         code += "\n    return true;\n}" 
     208        if self.bases: 
     209            code += "\n    return pyopencv_to(src, (%s&)dst, name);\n}\n" % all_classes[self.bases[0]].cname 
     210        else: 
     211            code += "\n    return true;\n}\n" 
    182212        return code 
    183213         
    184214    def gen_code(self, all_classes): 
    185215        if self.ismap: 
    186             return self.gen_map_code() 
    187          
    188         getset_code = "" 
    189         getset_inits = "" 
     216            return self.gen_map_code(all_classes) 
     217         
     218        getset_code = cStringIO.StringIO() 
     219        getset_inits = cStringIO.StringIO() 
    190220         
    191221        sorted_props = [(p.name, p) for p in self.props] 
    192222        sorted_props.sort() 
    193223         
     224        access_op = "->" 
     225        if self.issimple: 
     226            access_op = "." 
     227         
    194228        for pname, p in sorted_props: 
    195             getset_code += gen_template_get_prop.substitute(name=self.name, member=pname, membertype=p.tp) 
     229            getset_code.write(gen_template_get_prop.substitute(name=self.name, member=pname, membertype=p.tp, access=access_op)) 
    196230            if p.readonly: 
    197                 getset_inits += gen_template_prop_init.substitute(name=self.name, member=pname) 
     231                getset_inits.write(gen_template_prop_init.substitute(name=self.name, member=pname)) 
    198232            else: 
    199                 getset_code += gen_template_set_prop.substitute(name=self.name, member=pname, membertype=p.tp) 
    200                 getset_inits += gen_template_rw_prop_init.substitute(name=self.name, member=pname) 
     233                getset_code.write(gen_template_set_prop.substitute(name=self.name, member=pname, membertype=p.tp, access=access_op)) 
     234                getset_inits.write(gen_template_rw_prop_init.substitute(name=self.name, member=pname)) 
    201235                 
    202         methods_code = "" 
    203         methods_inits = "" 
     236        methods_code = cStringIO.StringIO() 
     237        methods_inits = cStringIO.StringIO() 
    204238         
    205239        sorted_methods = self.methods.items() 
     
    207241         
    208242        for mname, m in sorted_methods: 
    209             methods_code += m.gen_code(all_classes) 
    210             methods_inits += m.get_tab_entry() 
     243            methods_code.write(m.gen_code(all_classes)) 
     244            methods_inits.write(m.get_tab_entry()) 
    211245         
    212246        baseptr = "NULL" 
     
    214248            baseptr = "&pyopencv_" + all_classes[self.bases[0]].name + "_Type" 
    215249         
    216         code = gen_template_decl_type.substitute(name=self.name, wname=self.wname, cname=self.cname, 
    217             getset_code=getset_code, getset_inits=getset_inits, 
    218             methods_code=methods_code, methods_inits=methods_inits, 
     250        code = gen_template_type_impl.substitute(name=self.name, wname=self.wname, cname=self.cname, 
     251            getset_code=getset_code.getvalue(), getset_inits=getset_inits.getvalue(), 
     252            methods_code=methods_code.getvalue(), methods_inits=methods_inits.getvalue(), 
    219253            baseptr=baseptr, extra_specials="") 
    220254         
     
    259293         
    260294    def isbig(self): 
    261         return self.tp == "Mat" or self.tp.startswith("vector") 
     295        return self.tp == "Mat" or self.tp == "vector_Mat"# or self.tp.startswith("vector") 
    262296 
    263297 
    264298class FuncVariant(object): 
    265     def __init__(self, name, decl, isconstructor): 
    266         self.name = name 
     299    def __init__(self, classname, name, decl, isconstructor): 
     300        self.classname = classname 
     301        self.name = self.wname = name 
    267302        self.isconstructor = isconstructor 
     303        if self.isconstructor and self.wname.startswith("Cv"): 
     304            self.wname = self.wname[2:] 
    268305        self.rettype = decl[1] 
    269306        if self.rettype == "void": 
     
    304341        outlist = [] 
    305342         
    306         firstoptarg = 0 
     343        firstoptarg = 1000000 
    307344        argno = -1 
    308345        for a in self.args: 
     
    318355            if not a.defval: 
    319356                arglist.append((a.name, argno)) 
    320                 firstoptarg = argno+1 
    321357            else: 
     358                firstoptarg = min(firstoptarg, len(arglist)) 
    322359                # if there are some array output parameters before the first default parameter, they 
    323360                # are added as optional parameters before the first optional parameter 
     
    328365                 
    329366        if outarr_list: 
     367            firstoptarg = min(firstoptarg, len(arglist)) 
    330368            arglist += outarr_list 
     369        firstoptarg = min(firstoptarg, len(arglist)) 
     370         
    331371        noptargs = len(arglist) - firstoptarg 
    332372        argnamelist = [aname for aname, argno in arglist] 
     
    339379            assert outlist == [] 
    340380            outlist = [("self", -1)] 
    341         if outlist: 
     381        if self.isconstructor: 
     382            classname = self.classname 
     383            if classname.startswith("Cv"): 
     384                classname=classname[2:] 
     385            outstr = "<%s object>" % (classname,) 
     386        elif outlist: 
    342387            outstr = ", ".join([o[0] for o in outlist]) 
    343         elif self.isconstructor: 
    344             outstr = self.classname + " object" 
    345388        else: 
    346389            outstr = "None" 
    347         self.py_docstring = "%s(%s) -> %s" % (self.name, argstr, outstr) 
     390             
     391        self.py_docstring = "%s(%s) -> %s" % (self.wname, argstr, outstr) 
    348392        self.py_noptargs = noptargs 
    349393        self.py_arglist = arglist 
     
    365409     
    366410    def add_variant(self, decl): 
    367         self.variants.append(FuncVariant(self.name, decl, self.isconstructor)) 
     411        self.variants.append(FuncVariant(self.classname, self.name, decl, self.isconstructor)) 
    368412         
    369413    def get_wrapper_name(self): 
     414        name = self.name 
    370415        if self.classname: 
    371             cn = self.classname + "_" 
     416            classname = self.classname + "_" 
     417            if "[" in name: 
     418                name = "getelem" 
    372419        else: 
    373             cn = "" 
    374         return "pyopencv_" + cn + self.name 
     420            classname = "" 
     421        return "pyopencv_" + classname + name 
    375422     
    376423    def get_wrapper_prototype(self): 
     
    396443        # we write ClassName([args ...]) -> object 
    397444        if have_empty_constructor and len(self.variants) == 2: 
    398             idx = self.variants[1].arglist != [] 
     445            idx = self.variants[1].py_arglist != [] 
    399446            docstring_list = ["[" + self.variants[idx].py_docstring + "]"] 
    400                          
     447             
    401448        return Template('    {"$py_funcname", (PyCFunction)$wrap_funcname, METH_KEYWORDS, "$py_docstring"},\n' 
    402                         ).substitute(py_funcname = self.name, wrap_funcname=self.get_wrapper_name(), 
     449                        ).substitute(py_funcname = self.variants[0].wname, wrap_funcname=self.get_wrapper_name(), 
    403450                                     py_docstring = "  or  ".join(docstring_list)) 
    404451         
     
    415462            selfinfo = all_classes[self.classname] 
    416463            if not self.isconstructor: 
    417                 code += gen_template_check_self.substitute(name=selfinfo.name, cname=selfinfo.cname) 
     464                amp = "" 
     465                if selfinfo.issimple: 
     466                    amp = "&" 
     467                code += gen_template_check_self.substitute(name=selfinfo.name, cname=selfinfo.cname, amp=amp) 
    418468                fullname = selfinfo.wname + "." + fullname 
    419469 
     
    428478            if self.isconstructor: 
    429479                code_decl += "    pyopencv_%s_t* self = 0;\n" % selfinfo.name 
    430                 code_fcall = gen_template_call_constructor.substitute(name=selfinfo.name, cname=selfinfo.cname) 
     480                op = "new " 
     481                if selfinfo.issimple: 
     482                    op = "" 
     483                code_fcall = gen_template_call_constructor.substitute(name=selfinfo.name, cname=selfinfo.cname, op=op) 
    431484            else: 
    432485                code_fcall = "ERRWRAP2( " 
     
    460513                    sys.exit(-1) 
    461514 
    462                 amapping = simple_argtype_mapping.get(tp, (tp, "O", "pyopencv_from_" + tp1, defval0)) 
     515                amapping = simple_argtype_mapping.get(tp, (tp, "O", defval0)) 
    463516                all_cargs.append(amapping) 
    464517                if a.py_inputarg: 
     
    466519                        code_decl += "    PyObject* pyobj_%s = NULL;\n" % (a.name,) 
    467520                        parse_arglist.append("pyobj_" + a.name) 
    468                         code_cvt_list.append("pyopencv_to_%s(pyobj_%s, %s)" % (tp1, a.name, a.name)) 
     521                        code_cvt_list.append("pyopencv_to(pyobj_%s, %s)" % (a.name, a.name)) 
    469522                    else: 
    470523                        parse_arglist.append(a.name) 
     
    472525                defval = a.defval 
    473526                if not defval: 
    474                     defval = amapping[3] 
     527                    defval = amapping[2] 
    475528                # "tp arg = tp();" is equivalent to "tp arg;" in the case of complex types 
    476529                if defval == tp + "()" and amapping[1] == "O": 
     530                    defval = "" 
     531                if a.outputarg and not a.inputarg: 
    477532                    defval = "" 
    478533                if defval: 
     
    497552                tp = v.rettype 
    498553                tp1 = tp.replace("*", "_ptr") 
    499                 amapping = simple_argtype_mapping.get(tp, (tp, "O", "pyopencv_from_" + tp1, "0")) 
     554                amapping = simple_argtype_mapping.get(tp, (tp, "O", "0")) 
    500555                all_cargs.append(amapping) 
    501556 
     
    520575 
    521576            if len(v.py_outlist) == 0: 
    522                 code_retval = "Py_RETURN_NONE" 
     577                code_ret = "Py_RETURN_NONE" 
    523578            elif len(v.py_outlist) == 1: 
    524579                if self.isconstructor: 
    525                     code_retval = "self" 
     580                    code_ret = "return (PyObject*)self" 
    526581                else: 
    527582                    aname, argno = v.py_outlist[0] 
    528                     code_retval = "%s(%s)" % (all_cargs[argno][2], aname) 
     583                    code_ret = "return pyopencv_from(%s)" % (aname,) 
    529584            else: 
    530585                # ther is more than 1 return parameter; form the tuple out of them 
     
    534589                    amapping = all_cargs[argno] 
    535590                    backcvt_arg_list.append("%s(%s)" % (amapping[2], aname)) 
    536                 code_retval = "Py_BuildTuple(\"(%s)\", %s)" % \ 
    537                     (fmtspec, ", ".join([all_cargs[argno][2] + "(" + aname + ")" for aname, argno in v.py_outlist]))                     
     591                code_ret = "return Py_BuildValue(\"(%s)\", %s)" % \ 
     592                    (fmtspec, ", ".join(["pyopencv_from(" + aname + ")" for aname, argno in v.py_outlist]))                     
    538593 
    539594            all_code_variants.append(gen_template_func_body.substitute(code_decl=code_decl, 
    540                 code_parse=code_parse, code_fcall=code_fcall, code_retval=code_retval)) 
     595                code_parse=code_parse, code_fcall=code_fcall, code_ret=code_ret)) 
    541596 
    542597        if len(all_code_variants)==1: 
     
    560615        self.code_types = cStringIO.StringIO() 
    561616        self.code_funcs = cStringIO.StringIO() 
    562         self.code_functab = cStringIO.StringIO() 
     617        self.code_func_tab = cStringIO.StringIO() 
    563618        self.code_type_reg = cStringIO.StringIO() 
    564619        self.code_const_reg = cStringIO.StringIO() 
     
    630685        f.close() 
    631686             
    632     def gen(self, api_list, output_path): 
     687    def gen(self, srcfiles, output_path): 
    633688        self.clear() 
    634          
    635         # step 1: scan the list of declarations and build more descriptive maps of classes, consts, functions 
    636         for decl in api_list: 
    637             name = decl[0] 
    638             if name.startswith("struct") or name.startswith("class"): 
    639                 # class/struct 
    640                 p = name.find(" ") 
    641                 stype = name[:p] 
    642                 name = name[p+1:].strip() 
    643                 self.add_class(stype, name, decl) 
    644             elif name.startswith("const"): 
    645                 # constant 
    646                 self.add_const(name.replace("const ", "").strip(), decl) 
    647             else: 
    648                 # function 
    649                 self.add_func(decl) 
     689        parser = hdr_parser.CppHeaderParser() 
     690         
     691        # step 1: scan the headers and build more descriptive maps of classes, consts, functions 
     692        for hdr in srcfiles: 
     693            decls = parser.parse(hdr) 
     694            for decl in decls: 
     695                name = decl[0] 
     696                if name.startswith("struct") or name.startswith("class"): 
     697                    # class/struct 
     698                    p = name.find(" ") 
     699                    stype = name[:p] 
     700                    name = name[p+1:].strip() 
     701                    self.add_class(stype, name, decl) 
     702                elif name.startswith("const"): 
     703                    # constant 
     704                    self.add_const(name.replace("const ", "").strip(), decl) 
     705                else: 
     706                    # function 
     707                    self.add_func(decl) 
    650708         
    651709        # step 2: generate code for the classes and their methods 
    652710        classlist = self.classes.items() 
    653711        classlist.sort() 
     712        for name, classinfo in classlist: 
     713            if classinfo.ismap: 
     714                self.code_types.write(gen_template_map_type_cvt.substitute(name=name, cname=classinfo.cname)) 
     715            else: 
     716                if classinfo.issimple: 
     717                    templ = gen_template_simple_type_decl 
     718                else: 
     719                    templ = gen_template_type_decl 
     720                self.code_types.write(templ.substitute(name=name, wname=classinfo.wname, cname=classinfo.cname)) 
     721         
    654722        for name, classinfo in classlist: 
    655723            code = classinfo.gen_code(self.classes) 
     
    664732            code = func.gen_code(self.classes) 
    665733            self.code_funcs.write(code) 
     734            self.code_func_tab.write(func.get_tab_entry()) 
    666735             
    667736        # step 4: generate the code for constants 
     
    673742        # That's it. Now save all the files 
    674743        self.save(output_path, "pyopencv_generated_funcs.h", self.code_funcs) 
    675         self.save(output_path, "pyopencv_generated_func_tab.h", self.code_functab) 
     744        self.save(output_path, "pyopencv_generated_func_tab.h", self.code_func_tab) 
    676745        self.save(output_path, "pyopencv_generated_const_reg.h", self.code_const_reg) 
    677746        self.save(output_path, "pyopencv_generated_types.h", self.code_types) 
    678747        self.save(output_path, "pyopencv_generated_type_reg.h", self.code_type_reg) 
    679748 
    680 def generate_all(): 
    681     decls = opencv_parser.parse_all() 
     749if __name__ == "__main__": 
     750    srcfiles = hdr_parser.opencv_hdr_list 
     751    dstdir = "/Users/vp/tmp" 
     752    if len(sys.argv) > 2: 
     753        dstdir = sys.argv[1] 
     754        srcfiles = sys.argv[2:] 
    682755    generator = PythonWrapperGenerator() 
    683     generator.gen(decls, "/Users/vp/tmp") 
    684      
    685 if __name__ == "__main__": 
    686     generate_all() 
     756    generator.gen(srcfiles, dstdir) 
    687757 
    688758     
  • trunk/opencv/modules/python/hdr_parser.py

    r3843 r3860  
    11import os, sys, re 
    22 
     3# the list only for debugging. The real list, used in the real OpenCV build, is specified in CMakeLists.txt 
    34opencv_hdr_list = [ 
    45"../core/include/opencv2/core/core.hpp", 
    5 #"../core/include/opencv2/core/core_c.h", 
    66"../ml/include/opencv2/ml/ml.hpp", 
    77"../imgproc/include/opencv2/imgproc/imgproc.hpp", 
    8 #"../imgproc/include/opencv2/imgproc/imgproc_c.h", 
    98"../calib3d/include/opencv2/calib3d/calib3d.hpp", 
    109"../features2d/include/opencv2/features2d/features2d.hpp", 
     
    1312"../objdetect/include/opencv2/objdetect/objdetect.hpp", 
    1413"../highgui/include/opencv2/highgui/highgui.hpp", 
    15 #"../highgui/include/opencv2/highgui/highgui_c.h", 
    16 "opencv_api_extra.hpp", 
     14"opencv_extra_api.hpp", 
    1715] 
    1816 
     
    4139     
    4240    def get_macro_arg(self, arg_str, npos): 
    43          
    4441        npos2 = npos3 = arg_str.find("(", npos) 
    4542        if npos2 < 0: 
     
    227224        l = decl_str 
    228225        modlist = [] 
    229         if "CV_EXPORTS_AS_MAP" in l: 
    230             l = l.replace("CV_EXPORTS_AS_MAP", "") 
     226        if "CV_EXPORTS_W_MAP" in l: 
     227            l = l.replace("CV_EXPORTS_W_MAP", "") 
    231228            modlist.append("/Map") 
     229        if "CV_EXPORTS_W_SIMPLE" in l: 
     230            l = l.replace("CV_EXPORTS_W_SIMPLE", "") 
     231            modlist.append("/Simple") 
    232232        npos = l.find("CV_EXPORTS_AS") 
    233233        if npos >= 0: 
     
    259259            return [] 
    260260         
     261        top = self.block_stack[-1] 
    261262        func_modlist = [] 
    262263         
     
    271272            func_modlist.append("="+arg) 
    272273            decl_str = decl_str[:npos] + decl_str[npos3+1:] 
     274             
    273275        # filter off some common prefixes, which are meaningless for Python wrappers. 
    274276        # note that we do not strip "static" prefix, which does matter; 
     
    278280 
    279281        static_method = False 
    280         context = self.block_stack[-1][0] 
     282        context = top[0] 
    281283        if decl_str.startswith("static") and (context == "class" or context == "struct"): 
    282284            decl_str = decl_str[len("static"):].lstrip() 
     
    307309                 
    308310        if argno >= 0: 
    309             classname = self.block_stack[-1][1] 
     311            classname = top[1] 
    310312            if rettype == classname or rettype == "~" + classname: 
    311313                rettype, funcname = "", rettype 
     
    493495            # looks like it's member declaration; append the members to the class declaration 
    494496            class_decl = stack_top[self.CLASS_DECL] 
    495             if ("CV_PROP" in stmt) or (class_decl and ("/Map" in class_decl[2])): 
     497            if ("CV_PROP" in stmt): # or (class_decl and ("/Map" in class_decl[2])): 
    496498                var_modlist = [] 
    497499                if "CV_PROP_RW" in stmt: 
     
    657659                    print 
    658660 
    659 def parse_all(): 
     661if __name__ == '__main__': 
    660662    parser = CppHeaderParser() 
    661663    decls = []  
    662664    for hname in opencv_hdr_list: 
    663665        decls += parser.parse(hname) 
    664     return decls 
    665  
    666 if __name__ == '__main__': 
    667     parser = CppHeaderParser() 
    668     decls = parse_all() 
    669     if 0: 
    670         pass 
    671     elif 1: 
    672         CppHeaderParser().print_decls(decls) 
    673         print len(decls) 
    674     else: 
    675         fcounts = {} 
    676         for f in decls: 
    677             fname = f[0] 
    678             fcounts[fname] = fcounts.get(fname, []) + [f] 
    679         items = fcounts.items() 
    680         items.sort() 
    681         for fname, flist in items: 
    682             if len(flist) > 1: 
    683                 parser.print_decls(flist) 
     666    parser.print_decls(decls) 
     667    print len(decls) 
  • trunk/opencv/modules/python/opencv2x.h

    r3843 r3860  
    33 
    44#include "opencv2/core/core.hpp" 
    5  
    6 namespace cv 
    7 { 
     5#include "opencv2/imgproc/imgproc.hpp" 
     6#include "opencv2/calib3d/calib3d.hpp" 
     7#include "opencv2/ml/ml.hpp" 
     8#include "opencv2/features2d/features2d.hpp" 
     9#include "opencv2/objdetect/objdetect.hpp" 
     10#include "opencv2/video/tracking.hpp" 
     11#include "opencv2/video/background_segm.hpp" 
     12#include "opencv2/highgui/highgui.hpp" 
     13#include "opencv_extra_api.hpp" 
    814 
    915#define ERRWRAP2(expr) \ 
     
    1824} 
    1925 
     26using namespace cv; 
     27 
     28typedef vector<uchar> vector_uchar; 
     29typedef vector<int> vector_int; 
     30typedef vector<float> vector_float; 
     31typedef vector<double> vector_double; 
     32typedef vector<Point> vector_Point; 
     33typedef vector<Point2f> vector_Point2f; 
     34typedef vector<Vec2f> vector_Vec2f; 
     35typedef vector<Vec3f> vector_Vec3f; 
     36typedef vector<Vec4i> vector_Vec4i; 
     37typedef vector<Rect> vector_Rect; 
     38typedef vector<KeyPoint> vector_KeyPoint; 
     39typedef vector<Mat> vector_Mat; 
     40typedef vector<vector<Point> > vector_vector_Point; 
     41typedef vector<vector<Point2f> > vector_vector_Point2f; 
     42typedef vector<vector<Point3f> > vector_vector_Point3f; 
     43 
     44static PyObject* failmsgp(const char *fmt, ...) 
     45{ 
     46  char str[1000]; 
     47 
     48  va_list ap; 
     49  va_start(ap, fmt); 
     50  vsnprintf(str, sizeof(str), fmt, ap); 
     51  va_end(ap); 
     52 
     53  PyErr_SetString(PyExc_TypeError, str); 
     54  return 0; 
     55} 
     56 
    2057static size_t REFCOUNT_OFFSET = (size_t)&(((PyObject*)0)->ob_refcnt) + 
    2158    (0x12345678 != *(const size_t*)"\x78\x56\x34\x12\0\0\0\0\0")*sizeof(int); 
     
    4178    { 
    4279        static int ncalls = 0; 
    43         printf("NumpyAllocator::allocate: %d\n", ncalls++); 
    4480         
    4581        int depth = CV_MAT_DEPTH(type); 
     
    66102        refcount = refcountFromPyObject(o); 
    67103        npy_intp* _strides = PyArray_STRIDES(o); 
    68         for( i = 0; i < dims-1; i++ ) 
     104        for( i = 0; i < dims - (cn > 1); i++ ) 
    69105            step[i] = (size_t)_strides[i]; 
    70106        datastart = data = (uchar*)PyArray_DATA(o); 
     
    74110    { 
    75111        static int ncalls = 0; 
    76         printf("NumpyAllocator::deallocate: %d\n", ncalls++); 
    77112         
    78113        if( !refcount ) 
    79114            return; 
    80115        PyObject* o = pyObjectFromRefcount(refcount); 
     116        Py_INCREF(o); 
    81117        Py_DECREF(o); 
    82118    } 
     
    87123enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 }; 
    88124 
    89 static int pyobjToMat(const PyObject* o, Mat& m, const char* name = "<unknown>", bool allowND=true) 
     125static int pyopencv_to(const PyObject* o, Mat& m, const char* name = "<unknown>", bool allowND=true) 
    90126{ 
    91127    static int call_idx = 0; 
    92     printf("pyobjToMatND: %d\n", call_idx++); 
    93      
    94     if( !PyArray_Check(o) ) { 
    95         if( o == Py_None ) 
    96             return ARG_NONE; 
     128     
     129    if(!o || o == Py_None) 
     130    { 
     131        if( !m.data ) 
     132            m.allocator = &g_numpyAllocator; 
     133        return true; 
     134    } 
     135         
     136    if( !PyArray_Check(o) ) 
     137    { 
    97138        failmsg("%s is not a numpy array", name); 
    98         return -1; 
     139        return false; 
    99140    } 
    100141     
     
    109150    { 
    110151        failmsg("%s data type = %d is not supported", name, typenum); 
    111         return -1; 
     152        return false; 
    112153    } 
    113154     
     
    116157    { 
    117158        failmsg("%s dimensionality (=%d) is too high", name, ndims); 
    118         return -1; 
     159        return false; 
    119160    } 
    120161     
    121162    int size[CV_MAX_DIM+1]; 
    122     size_t step[CV_MAX_DIM+1], elemsize = CV_ELEM_SIZE(type); 
     163    size_t step[CV_MAX_DIM+1], elemsize = CV_ELEM_SIZE1(type); 
    123164    const npy_intp* _sizes = PyArray_DIMS(o); 
    124165    const npy_intp* _strides = PyArray_STRIDES(o); 
     
    136177    } 
    137178     
     179    if( ndims == 3 && size[2] <= CV_CN_MAX && step[1] == elemsize*size[2] ) 
     180    { 
     181        ndims--; 
     182        type |= CV_MAKETYPE(0, size[2]); 
     183    } 
     184     
     185    if( ndims > 2 && !allowND ) 
     186    { 
     187        failmsg("%s has more than 2 dimensions", name); 
     188        return false; 
     189    } 
     190     
    138191    m = Mat(ndims, size, type, PyArray_DATA(o), step); 
    139192     
    140     if (!allowND) 
    141     { 
    142         if( ndims <= 2 ) 
    143             ; 
    144         else if( ndims == 3 ) 
    145         { 
    146             if( size[2] > CV_CN_MAX || step[1] != elemsize*size[2] ) 
    147             { 
    148                 failmsg("%s is not contiguous, thus it can not be interpreted as image", name); 
    149                 return -1; 
    150             } 
    151             m.dims--; 
    152             m.flags = (m.flags & ~CV_MAT_TYPE_MASK) | CV_MAKETYPE(type, size[2]); 
    153         } 
    154         else 
    155         { 
    156             failmsg("%s is not contiguous or has more than 3 dimensions, thus it can not be interpreted as image", name); 
    157             return -1; 
    158         } 
    159     } 
    160      
    161193    if( m.data ) 
    162194    { 
    163195        m.refcount = refcountFromPyObject(o); 
    164         ++*m.refcount; // protect the original numpy array from deallocation 
    165                        // (since Mat destructor will decrement the reference counter) 
     196        m.addref(); // protect the original numpy array from deallocation 
     197                    // (since Mat destructor will decrement the reference counter) 
    166198    }; 
    167199    m.allocator = &g_numpyAllocator; 
    168     return ARG_MAT; 
    169 } 
    170  
    171 static void makeEmptyMat(Mat& m) 
    172 { 
    173     m = Mat(); 
    174     m.allocator = &g_numpyAllocator; 
    175 } 
    176  
    177 static int pyobjToMat(const PyObject* o, Mat& m, const char* name = "<unknown>") 
    178 { 
    179     Mat temp; 
    180     int code = pyobjToMat(o, temp, name, false); 
    181     if(code > 0) 
    182         m = Mat(temp); 
    183     return code; 
    184 } 
    185  
    186 static int pyobjToScalar(PyObject *o, Scalar& s, const char *name = "<unknown>") 
    187 { 
     200    return true; 
     201} 
     202 
     203static PyObject* pyopencv_from(const Mat& m) 
     204{ 
     205    Mat temp, *p = (Mat*)&m; 
     206    if(!p->refcount || p->allocator != &g_numpyAllocator) 
     207    { 
     208        pyopencv_to(Py_None, temp); 
     209        m.copyTo(temp); 
     210        p = &temp; 
     211    } 
     212    p->addref(); 
     213    return pyObjectFromRefcount(p->refcount); 
     214} 
     215 
     216static bool pyopencv_to(PyObject *o, Scalar& s, const char *name = "<unknown>") 
     217{ 
     218    if(!o || o == Py_None) 
     219        return true; 
    188220    if (PySequence_Check(o)) { 
    189221        PyObject *fi = PySequence_Fast(o, name); 
    190222        if (fi == NULL) 
    191             return -1; 
     223            return false; 
    192224        if (4 < PySequence_Fast_GET_SIZE(fi)) 
    193225        { 
    194226            failmsg("Scalar value for argument '%s' is longer than 4", name); 
    195             return -1; 
     227            return false; 
    196228        } 
    197229        for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) { 
     
    201233            } else { 
    202234                failmsg("Scalar value for argument '%s' is not numeric", name); 
    203                 return -1; 
     235                return false; 
    204236            } 
    205237        } 
     
    210242        } else { 
    211243            failmsg("Scalar value for argument '%s' is not numeric", name); 
    212             return -1; 
     244            return false; 
    213245        } 
    214246    } 
    215     return ARG_SCALAR; 
    216 } 
    217  
    218  
    219 static int pyobjToMatOrScalar(PyObject* obj, Mat& m, Scalar& s, const char* name, bool allowND) 
    220 { 
    221     if( PyArray_Check(obj) || (obj == Py_None)) 
    222         return pyobjToMat(obj, m, name, allowND); 
    223  
    224     return pyobjToScalar(obj, s, name); 
    225 } 
    226  
    227 static void pyc_add_mm(const Mat& a, const Mat& b, Mat& c, const Mat& mask) { add(a, b, c, mask); } 
    228 static void pyc_add_ms(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool) { add(a, s, c, mask); } 
    229 static void pyc_subtract_mm(const Mat& a, const Mat& b, Mat& c, const Mat& mask) { subtract(a, b, c, mask); } 
    230 static void pyc_subtract_ms(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool rev) 
    231 { 
    232     if( !rev ) 
    233         subtract(a, s, c, mask); 
     247    return true; 
     248} 
     249 
     250static inline PyObject* pyopencv_from(const Scalar& src) 
     251{ 
     252    return Py_BuildValue("(dddd)", src[0], src[1], src[2], src[3]); 
     253} 
     254 
     255static PyObject* pyopencv_from(bool value) 
     256{ 
     257    return PyBool_FromLong(value); 
     258} 
     259 
     260static bool pyopencv_to(PyObject* obj, bool& value, const char* name = "<unknown>") 
     261{ 
     262    if(!obj || obj == Py_None) 
     263        return true; 
     264    int _val = PyObject_IsTrue(obj); 
     265    if(_val < 0) 
     266        return false; 
     267    value = _val > 0; 
     268    return true; 
     269} 
     270 
     271static PyObject* pyopencv_from(size_t value) 
     272{ 
     273    return PyLong_FromUnsignedLong((unsigned long)value); 
     274} 
     275 
     276static PyObject* pyopencv_from(int value) 
     277{ 
     278    return PyInt_FromLong(value); 
     279} 
     280 
     281static bool pyopencv_to(PyObject* obj, int& value, const char* name = "<unknown>") 
     282{ 
     283    if(!obj || obj == Py_None) 
     284        return true; 
     285    value = (int)PyInt_AsLong(obj); 
     286    return value != -1 || !PyErr_Occurred(); 
     287} 
     288 
     289static PyObject* pyopencv_from(double value) 
     290{ 
     291    return PyFloat_FromDouble(value); 
     292} 
     293 
     294static bool pyopencv_to(PyObject* obj, double& value, const char* name = "<unknown>") 
     295{ 
     296    if(!obj || obj == Py_None) 
     297        return true; 
     298    if(PyInt_CheckExact(obj)) 
     299        value = (double)PyInt_AS_LONG(obj); 
    234300    else 
    235         subtract(s, a, c, mask); 
    236 } 
    237  
    238 static void pyc_and_mm(const Mat& a, const Mat& b, Mat& c, const Mat& mask) { bitwise_and(a, b, c, mask); } 
    239 static void pyc_and_ms(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool) { bitwise_and(a, s, c, mask); } 
    240 static void pyc_or_mm(const Mat& a, const Mat& b, Mat& c, const Mat& mask) { bitwise_or(a, b, c, mask); } 
    241 static void pyc_or_ms(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool) { bitwise_or(a, s, c, mask); } 
    242 static void pyc_xor_mm(const Mat& a, const Mat& b, Mat& c, const Mat& mask) { bitwise_xor(a, b, c, mask); } 
    243 static void pyc_xor_ms(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool) { bitwise_xor(a, s, c, mask); } 
    244 static void pyc_absdiff_mm(const Mat& a, const Mat& b, Mat& c, const Mat&) { absdiff(a, b, c); } 
    245 static void pyc_absdiff_ms(const Mat& a, const Scalar& s, Mat& c, const Mat&, bool) { absdiff(a, s, c); } 
    246 static void pyc_min_mm(const Mat& a, const Mat& b, Mat& c, const Mat&) { min(a, b, c); } 
    247 static void pyc_min_ms(const Mat& a, const Scalar& s, Mat& c, const Mat&, bool) 
    248 { 
    249     CV_Assert( s.isReal() ); 
    250     min(a, s[0], c); 
    251 } 
    252 static void pyc_max_mm(const Mat& a, const Mat& b, Mat& c, const Mat&) { max(a, b, c); } 
    253 static void pyc_max_ms(const Mat& a, const Scalar& s, Mat& c, const Mat&, bool) 
    254 { 
    255     CV_Assert( s.isReal() ); 
    256     max(a, s[0], c); 
    257 } 
    258  
    259 typedef void (*BinaryOp)(const Mat& a, const Mat& b, Mat& c, const Mat& mask); 
    260 typedef void (*BinaryOpS)(const Mat& a, const Scalar& s, Mat& c, const Mat& mask, bool rev); 
    261  
    262 static PyObject *pyopencv_binary_op(PyObject* args, PyObject* kw, BinaryOp binOp, BinaryOpS binOpS, bool supportMask) 
    263 { 
    264     PyObject *pysrc1 = 0, *pysrc2 = 0, *pydst = 0, *pymask = 0; 
    265     Mat src1, src2, dst, mask; 
    266     Scalar alpha, beta; 
    267      
    268     if( supportMask ) 
    269     { 
    270         const char *keywords[] = { "src1", "src2", "dst", "mask", 0 }; 
    271         if( !PyArg_ParseTupleAndKeywords(args, kw, "OO|OO", (char**)keywords, 
    272                                         &pysrc1, &pysrc2, &pydst, &pymask)) 
    273             return 0; 
    274     } 
     301        value = PyFloat_AsDouble(obj); 
     302    return !PyErr_Occurred(); 
     303} 
     304 
     305static PyObject* pyopencv_from(float value) 
     306{ 
     307    return PyFloat_FromDouble(value); 
     308} 
     309 
     310static bool pyopencv_to(PyObject* obj, float& value, const char* name = "<unknown>") 
     311{ 
     312    if(!obj || obj == Py_None) 
     313        return true; 
     314    if(PyInt_CheckExact(obj)) 
     315        value = (float)PyInt_AS_LONG(obj); 
    275316    else 
    276     { 
    277         const char *keywords[] = { "src1", "src2", "dst", 0 }; 
    278         if( !PyArg_ParseTupleAndKeywords(args, kw, "OO|O", (char**)keywords, 
    279                                          &pysrc1, &pysrc2, &pydst)) 
    280             return 0; 
    281     } 
    282      
    283     int code_src1 = pysrc1 ? pyobjToMatOrScalar(pysrc1, src1, alpha, "src1", true) : -1; 
    284     int code_src2 = pysrc2 ? pyobjToMatOrScalar(pysrc2, src2, beta, "src2", true) : -1; 
    285     int code_dst = pydst ? pyobjToMat(pydst, dst, "dst", true) : 0; 
    286     int code_mask = pymask ? pyobjToMat(pymask, mask, "mask", true) : 0; 
    287      
    288     if( code_src1 < 0 || code_src2 < 0 || code_dst < 0 || code_mask < 0 ) 
     317        value = (float)PyFloat_AsDouble(obj); 
     318    return !PyErr_Occurred(); 
     319} 
     320 
     321static PyObject* pyopencv_from(const string& value) 
     322{ 
     323    return PyString_FromString(value.empty() ? "" : value.c_str()); 
     324} 
     325 
     326static bool pyopencv_to(PyObject* obj, string& value, const char* name = "<unknown>") 
     327{ 
     328    if(!obj || obj == Py_None) 
     329        return true; 
     330    char* str = PyString_AsString(obj); 
     331    if(!str) 
     332        return false; 
     333    value = string(str); 
     334    return true; 
     335} 
     336 
     337static inline bool pyopencv_to(PyObject* obj, Size& sz, const char* name = "<unknown>") 
     338{ 
     339    if(!obj || obj == Py_None) 
     340        return true; 
     341    return PyArg_Parse(obj, "ii", &sz.width, &sz.height) > 0; 
     342} 
     343 
     344static inline PyObject* pyopencv_from(const Size& sz) 
     345{ 
     346    return Py_BuildValue("(ii)", sz.width, sz.height); 
     347} 
     348 
     349static inline bool pyopencv_to(PyObject* obj, Rect& r, const char* name = "<unknown>") 
     350{ 
     351    if(!obj || obj == Py_None) 
     352        return true; 
     353    return PyArg_Parse(obj, "iiii", &r.x, &r.y, &r.width, &r.height) > 0; 
     354} 
     355 
     356static inline PyObject* pyopencv_from(const Rect& r) 
     357{ 
     358    return Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height); 
     359} 
     360 
     361static inline bool pyopencv_to(PyObject* obj, Range& r, const char* name = "<unknown>") 
     362{ 
     363    if(!obj || obj == Py_None) 
     364        return true; 
     365    if(PyObject_Size(obj) == 0) 
     366    { 
     367        r = Range::all(); 
     368        return true; 
     369    } 
     370    return PyArg_Parse(obj, "ii", &r.start, &r.end) > 0; 
     371} 
     372 
     373static inline PyObject* pyopencv_from(const Range& r) 
     374{ 
     375    return Py_BuildValue("(ii)", r.start, r.end); 
     376} 
     377 
     378static inline bool pyopencv_to(PyObject* obj, CvSlice& r, const char* name = "<unknown>") 
     379{ 
     380    if(!obj || obj == Py_None) 
     381        return true; 
     382    if(PyObject_Size(obj) == 0) 
     383    { 
     384        r = CV_WHOLE_SEQ; 
     385        return true; 
     386    } 
     387    return PyArg_Parse(obj, "ii", &r.start_index, &r.end_index) > 0; 
     388} 
     389                                                 
     390static inline PyObject* pyopencv_from(const CvSlice& r) 
     391{ 
     392    return Py_BuildValue("(ii)", r.start_index, r.end_index); 
     393}                                                     
     394                                                     
     395static inline bool pyopencv_to(PyObject* obj, Point& p, const char* name = "<unknown>") 
     396{ 
     397    if(!obj || obj == Py_None) 
     398        return true; 
     399    if(PyComplex_CheckExact(obj)) 
     400    { 
     401        Py_complex c = PyComplex_AsCComplex(obj); 
     402        p.x = saturate_cast<int>(c.real); 
     403        p.y = saturate_cast<int>(c.imag); 
     404        return true; 
     405    } 
     406    return PyArg_Parse(obj, "ii", &p.x, &p.y) > 0; 
     407} 
     408 
     409static inline bool pyopencv_to(PyObject* obj, Point2f& p, const char* name = "<unknown>") 
     410{ 
     411    if(!obj || obj == Py_None) 
     412        return true; 
     413    if(PyComplex_CheckExact(obj)) 
     414    { 
     415        Py_complex c = PyComplex_AsCComplex(obj); 
     416        p.x = saturate_cast<float>(c.real); 
     417        p.y = saturate_cast<float>(c.imag); 
     418        return true; 
     419    } 
     420    return PyArg_Parse(obj, "ff", &p.x, &p.y) > 0; 
     421} 
     422 
     423static inline PyObject* pyopencv_from(const Point& p) 
     424{ 
     425    return Py_BuildValue("(ii)", p.x, p.y); 
     426} 
     427 
     428static inline PyObject* pyopencv_from(const Point2f& p) 
     429{ 
     430    return Py_BuildValue("(dd)", p.x, p.y); 
     431} 
     432 
     433static inline bool pyopencv_to(PyObject* obj, Vec3d& v, const char* name = "<unknown>") 
     434{ 
     435    if(!obj) 
     436        return true; 
     437    return PyArg_Parse(obj, "ddd", &v[0], &v[1], &v[2]) > 0; 
     438} 
     439 
     440static inline PyObject* pyopencv_from(const Vec3d& v) 
     441{ 
     442    return Py_BuildValue("(ddd)", v[0], v[1], v[2]); 
     443} 
     444 
     445static inline PyObject* pyopencv_from(const Point2d& p) 
     446{ 
     447    return Py_BuildValue("(dd)", p.x, p.y); 
     448} 
     449 
     450template<typename _Tp> struct pyopencvVecConverter 
     451{ 
     452    static bool to(PyObject* obj, vector<_Tp>& value, const char* name="<unknown>") 
     453    { 
     454        typedef typename DataType<_Tp>::channel_type _Cp; 
     455        if(!obj) 
     456            return true; 
     457        if (PyArray_Check(obj)) 
     458        { 
     459            Mat m; 
     460            pyopencv_to(obj, m, name); 
     461            m.copyTo(value); 
     462        } 
     463        if (!PySequence_Check(obj)) 
     464            return false; 
     465        PyObject *seq = PySequence_Fast(obj, name); 
     466        if (seq == NULL) 
     467            return false; 
     468        int i, j, n = (int)PySequence_Fast_GET_SIZE(seq); 
     469        value.resize(n); 
     470         
     471        int type = DataType<_Tp>::type; 
     472        int depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type); 
     473        PyObject** items = PySequence_Fast_ITEMS(seq); 
     474         
     475        for( i = 0; i < n; i++ ) 
     476        { 
     477            PyObject* item = items[i]; 
     478            PyObject* seq_i = 0; 
     479            PyObject** items_i = &item; 
     480            _Cp* data = (_Cp*)&value[i]; 
     481             
     482            if( channels == 2 && PyComplex_CheckExact(item) ) 
     483            { 
     484                Py_complex c = PyComplex_AsCComplex(obj); 
     485                data[0] = saturate_cast<_Cp>(c.real); 
     486                data[1] = saturate_cast<_Cp>(c.imag); 
     487                continue; 
     488            } 
     489            if( channels > 1 ) 
     490            { 
     491                if( PyArray_Check(obj)) 
     492                { 
     493                    Mat src; 
     494                    pyopencv_to(obj, src, name); 
     495                    if( src.dims != 2 || src.channels() != 1 || 
     496                       ((src.cols != 1 || src.rows != channels) && 
     497                        (src.cols != channels || src.rows != 1))) 
     498                        break; 
     499                    Mat dst(src.rows, src.cols, depth, data); 
     500                    src.convertTo(dst, type); 
     501                    if( dst.data != (uchar*)data ) 
     502                        break; 
     503                    continue; 
     504                } 
     505                 
     506                seq_i = PySequence_Fast(item, name); 
     507                if( !seq_i || (int)PySequence_Fast_GET_SIZE(seq_i) != channels ) 
     508                { 
     509                    Py_XDECREF(seq_i); 
     510                    break; 
     511                } 
     512                items_i = PySequence_Fast_ITEMS(seq_i); 
     513            } 
     514             
     515            for( j = 0; j < channels; j++ ) 
     516            { 
     517                PyObject* item_ij = items_i[j]; 
     518                if( PyInt_Check(item_ij)) 
     519                { 
     520                    int v = PyInt_AsLong(item_ij); 
     521                    if( v == -1 && PyErr_Occurred() ) 
     522                        break; 
     523                    data[j] = saturate_cast<_Cp>(v); 
     524                } 
     525                else if( PyFloat_Check(item_ij)) 
     526                { 
     527                    double v = PyFloat_AsDouble(item_ij); 
     528                    if( PyErr_Occurred() ) 
     529                        break; 
     530                    data[j] = saturate_cast<_Cp>(v); 
     531                } 
     532                else 
     533                    break; 
     534            } 
     535            Py_XDECREF(seq_i); 
     536            if( j < channels ) 
     537                break; 
     538        } 
     539        Py_DECREF(seq); 
     540        return i == n; 
     541    } 
     542     
     543    static PyObject* from(const vector<_Tp>& value) 
     544    { 
     545        if(value.empty()) 
     546            return PyTuple_New(0); 
     547        Mat src((int)value.size(), DataType<_Tp>::channels, DataType<_Tp>::depth, (uchar*)&value[0]); 
     548        return pyopencv_from(src); 
     549    } 
     550}; 
     551 
     552 
     553template<typename _Tp> static inline bool pyopencv_to(PyObject* obj, vector<_Tp>& value, const char* name="<unknown>") 
     554{ 
     555    return pyopencvVecConverter<_Tp>::to(obj, value, name); 
     556} 
     557 
     558template<typename _Tp> static inline PyObject* pyopencv_from(const vector<_Tp>& value) 
     559{ 
     560    return pyopencvVecConverter<_Tp>::from(value); 
     561} 
     562 
     563static PyObject* pyopencv_from(const KeyPoint&); 
     564static bool pyopencv_from(PyObject*,KeyPoint&,const char*); 
     565 
     566template<typename _Tp> static inline bool pyopencv_to_generic_vec(PyObject* obj, vector<_Tp>& value, const char* name="<unknown>") 
     567{ 
     568    if (!PySequence_Check(obj)) 
     569        return false; 
     570    PyObject *seq = PySequence_Fast(obj, name); 
     571    if (seq == NULL) 
     572        return false; 
     573    int i, n = (int)PySequence_Fast_GET_SIZE(seq); 
     574    value.resize(n); 
     575     
     576    PyObject** items = PySequence_Fast_ITEMS(seq); 
     577     
     578    for( i = 0; i < n; i++ ) 
     579    { 
     580        PyObject* item = items[i]; 
     581        if(!pyopencv_to(item, value[i], name)) 
     582            break; 
     583    } 
     584    Py_DECREF(seq); 
     585    return i == n; 
     586} 
     587 
     588template<typename _Tp> static inline PyObject* pyopencv_from_generic_vec(const vector<_Tp>& value) 
     589{ 
     590    int i, n = (int)value.size(); 
     591    PyObject* seq = PyTuple_New(n); 
     592    for( i = 0; i < n; i++ ) 
     593    {         
     594        PyObject* item = pyopencv_from(value[i]); 
     595        if(!item) 
     596            break; 
     597        PyTuple_SET_ITEM(seq, i, item); 
     598    } 
     599    if( i < n ) 
     600    { 
     601        Py_DECREF(seq); 
    289602        return 0; 
    290      
    291     if( code_src1 == ARG_SCALAR && code_src2 == ARG_SCALAR ) 
    292     { 
    293         failmsg("Both %s and %s are scalars", "src1", "src2"); 
    294         return 0; 
    295     } 
    296      
    297     if( code_dst == 0 ) 
    298         makeEmptyMat(dst); 
    299      
    300     ERRWRAP2(code_src1 != ARG_SCALAR && code_src2 != ARG_SCALAR ? binOp(src1, src2, dst, mask) : 
    301              code_src1 != ARG_SCALAR ? binOpS(src2, alpha, dst, mask, true) : binOpS(src1, beta, dst, mask, false)); 
    302      
    303     PyObject* result = pyObjectFromRefcount(dst.refcount); 
    304     int D = PyArray_NDIM(result); 
    305     const npy_intp* sz = PyArray_DIMS(result); 
    306      
    307     printf("Result: check = %d, ndims = %d, size = (%d x %d), typenum=%d\n", PyArray_Check(result), 
    308            D, (int)sz[0], D >= 2 ? (int)sz[1] : 1, PyArray_TYPE(result)); 
    309      
    310     //Py_INCREF(result); 
    311     return result; 
    312 } 
    313  
    314 static PyObject* pyopencv_add(PyObject* self, PyObject* args, PyObject* kw) 
    315 { 
    316     return pyopencv_binary_op(args, kw, pyc_add_mm, pyc_add_ms, true); 
    317 } 
    318  
    319 static PyObject* pyopencv_subtract(PyObject* self, PyObject* args, PyObject* kw) 
    320 { 
    321     return pyopencv_binary_op(args, kw, pyc_subtract_mm, pyc_subtract_ms, true); 
    322 } 
    323  
    324 static PyObject* pyopencv_and(PyObject* self, PyObject* args, PyObject* kw) 
    325 { 
    326     return pyopencv_binary_op(args, kw, pyc_and_mm, pyc_and_ms, true); 
    327 } 
    328  
    329 static PyObject* pyopencv_or(PyObject* self, PyObject* args, PyObject* kw) 
    330 { 
    331     return pyopencv_binary_op(args, kw, pyc_or_mm, pyc_or_ms, true); 
    332 } 
    333  
    334 static PyObject* pyopencv_xor(PyObject* self, PyObject* args, PyObject* kw) 
    335 { 
    336     return pyopencv_binary_op(args, kw, pyc_xor_mm, pyc_xor_ms, true); 
    337 } 
    338  
    339 static PyObject* pyopencv_absdiff(PyObject* self, PyObject* args, PyObject* kw) 
    340 { 
    341     return pyopencv_binary_op(args, kw, pyc_absdiff_mm, pyc_absdiff_ms, true); 
    342 } 
    343  
    344 static PyObject* pyopencv_min(PyObject* self, PyObject* args, PyObject* kw) 
    345 { 
    346     return pyopencv_binary_op(args, kw, pyc_min_mm, pyc_min_ms, true); 
    347 } 
    348  
    349 static PyObject* pyopencv_max(PyObject* self, PyObject* args, PyObject* kw) 
    350 { 
    351     return pyopencv_binary_op(args, kw, pyc_max_mm, pyc_max_ms, true); 
    352 } 
    353  
    354 } 
    355      
     603    } 
     604    return seq; 
     605} 
     606 
     607 
     608template<typename _Tp> struct pyopencvVecConverter<vector<_Tp> > 
     609{ 
     610    static bool to(PyObject* obj, vector<vector<_Tp> >& value, const char* name="<unknown>") 
     611    { 
     612        return pyopencv_to_generic_vec(obj, value, name); 
     613    } 
     614     
     615    static PyObject* from(const vector<vector<_Tp> >& value) 
     616    { 
     617        return pyopencv_from_generic_vec(value); 
     618    } 
     619}; 
     620 
     621template<> struct pyopencvVecConverter<Mat> 
     622{ 
     623    static bool to(PyObject* obj, vector<Mat>& value, const char* name="<unknown>") 
     624    { 
     625        return pyopencv_to_generic_vec(obj, value, name); 
     626    } 
     627     
     628    static PyObject* from(const vector<Mat>& value) 
     629    { 
     630        return pyopencv_from_generic_vec(value); 
     631    } 
     632}; 
     633 
     634template<> struct pyopencvVecConverter<KeyPoint> 
     635{ 
     636    static bool to(PyObject* obj, vector<KeyPoint>& value, const char* name="<unknown>") 
     637    { 
     638        return pyopencv_to_generic_vec(obj, value, name); 
     639    } 
     640     
     641    static PyObject* from(const vector<KeyPoint>& value) 
     642    { 
     643        return pyopencv_from_generic_vec(value); 
     644    } 
     645}; 
     646 
     647 
     648static inline bool pyopencv_to(PyObject *obj, CvTermCriteria& dst, const char *name="<unknown>") 
     649{ 
     650    if(!obj) 
     651        return true; 
     652    return PyArg_ParseTuple(obj, "iid", &dst.type, &dst.max_iter, &dst.epsilon) > 0; 
     653} 
     654 
     655static inline PyObject* pyopencv_from(const CvTermCriteria& src) 
     656{ 
     657    return Py_BuildValue("(iid)", src.type, src.max_iter, src.epsilon); 
     658} 
     659 
     660static inline bool pyopencv_to(PyObject *obj, TermCriteria& dst, const char *name="<unknown>") 
     661{ 
     662    if(!obj) 
     663        return true; 
     664    return PyArg_ParseTuple(obj, "iid", &dst.type, &dst.maxCount, &dst.epsilon) > 0; 
     665} 
     666 
     667static inline PyObject* pyopencv_from(const TermCriteria& src) 
     668{ 
     669    return Py_BuildValue("(iid)", src.type, src.maxCount, src.epsilon); 
     670} 
     671 
     672static inline bool pyopencv_to(PyObject *obj, RotatedRect& dst, const char *name="<unknown>") 
     673{ 
     674    if(!obj) 
     675        return true; 
     676    return PyArg_ParseTuple(obj, "(ff)(ff)f", &dst.center.x, &dst.center.y, &dst.size.width, &dst.size.height, &dst.angle) > 0; 
     677} 
     678 
     679static inline PyObject* pyopencv_from(const RotatedRect& src) 
     680{ 
     681    return Py_BuildValue("((ff)(ff)f)", src.center.x, src.center.y, src.size.width, src.size.height, src.angle); 
     682} 
     683 
     684static inline PyObject* pyopencv_from(const Moments& m) 
     685{ 
     686    return Py_BuildValue("{s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d}", 
     687                         "m00", m.m00, "m10", m.m10, "m01", m.m01, 
     688                         "m20", m.m20, "m11", m.m11, "m02", m.m02, 
     689                         "m30", m.m30, "m21", m.m21, "m12", m.m12, "m03", m.m03, 
     690                         "mu20", m.mu20, "mu11", m.mu11, "mu02", m.mu02, 
     691                         "mu30", m.mu30, "mu21", m.mu21, "mu12", m.mu12, "mu03", m.mu03, 
     692                         "nu20", m.nu20, "nu11", m.nu11, "nu02", m.nu02, 
     693                         "nu30", m.nu30, "nu21", m.nu21, "nu12", m.nu12, "mu03", m.nu03); 
     694} 
     695 
    356696#endif