Merge pull request #317 from vpisarev:c2cpp_refactor_imgproc

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

@@ -109,6 +109,8 @@ template<typename _Tp> class CV_EXPORTS MatIterator_;
 template<typename _Tp> class CV_EXPORTS MatConstIterator_;
 template<typename _Tp> class CV_EXPORTS MatCommaInitializer_;
 
+template<typename _Tp, size_t fixed_size = 1024/sizeof(_Tp)+8> class CV_EXPORTS AutoBuffer;
+
 CV_EXPORTS string format( const char* fmt, ... );
 CV_EXPORTS string tempfile( const char* suffix CV_DEFAULT(0));
 
@@ -2061,7 +2063,8 @@ CV_EXPORTS void swap(Mat& a, Mat& b);
 
 //! converts array (CvMat or IplImage) to cv::Mat
 CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
-                          bool allowND=true, int coiMode=0);
+                          bool allowND=true, int coiMode=0,
+                          AutoBuffer<double>* buf=0);
 //! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
 CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
 //! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
@@ -3081,7 +3084,7 @@ public:
  \code
  void my_func(const cv::Mat& m)
  {
-    cv::AutoBuffer<float, 1000> buf; // create automatic buffer containing 1000 floats
+    cv::AutoBuffer<float> buf; // create automatic buffer containing 1000 floats
 
     buf.allocate(m.rows); // if m.rows <= 1000, the pre-allocated buffer is used,
                           // otherwise the buffer of "m.rows" floats will be allocated
@@ -3090,16 +3093,21 @@ public:
  }
  \endcode
 */
-template<typename _Tp, size_t fixed_size=4096/sizeof(_Tp)+8> class CV_EXPORTS AutoBuffer
+template<typename _Tp, size_t fixed_size> class CV_EXPORTS AutoBuffer
 {
 public:
     typedef _Tp value_type;
-    enum { buffer_padding = (int)((16 + sizeof(_Tp) - 1)/sizeof(_Tp)) };
 
     //! the default contructor
     AutoBuffer();
     //! constructor taking the real buffer size
     AutoBuffer(size_t _size);
+
+    //! the copy constructor
+    AutoBuffer(const AutoBuffer<_Tp, fixed_size>& buf);
+    //! the assignment operator
+    AutoBuffer<_Tp, fixed_size>& operator = (const AutoBuffer<_Tp, fixed_size>& buf);
+
     //! destructor. calls deallocate()
     ~AutoBuffer();
 
@@ -3107,6 +3115,10 @@ public:
     void allocate(size_t _size);
     //! deallocates the buffer if it was dynamically allocated
     void deallocate();
+    //! resizes the buffer and preserves the content
+    void resize(size_t _size);
+	//! returns the current buffer size
+	size_t size() const;
     //! returns pointer to the real buffer, stack-allocated or head-allocated
     operator _Tp* ();
     //! returns read-only pointer to the real buffer, stack-allocated or head-allocated
@@ -3116,9 +3128,9 @@ protected:
     //! pointer to the real buffer, can point to buf if the buffer is small enough
     _Tp* ptr;
     //! size of the real buffer
-    size_t size;
+    size_t sz;
     //! pre-allocated buffer
-    _Tp buf[fixed_size+buffer_padding];
+    _Tp buf[fixed_size];
 };
 
 /////////////////////////// multi-dimensional dense matrix //////////////////////////
@@ -4314,7 +4326,6 @@ public:
     int index;
 };
 
-
 class CV_EXPORTS Algorithm;
 class CV_EXPORTS AlgorithmInfo;
 struct CV_EXPORTS AlgorithmInfoData;

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

@@ -2534,48 +2534,109 @@ inline Point LineIterator::pos() const
 
 /////////////////////////////// AutoBuffer ////////////////////////////////////////
 
-template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>::AutoBuffer()
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::AutoBuffer()
 {
     ptr = buf;
-    size = fixed_size;
+    sz = fixed_size;
 }
 
-template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>::AutoBuffer(size_t _size)
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::AutoBuffer(size_t _size)
 {
     ptr = buf;
-    size = fixed_size;
+    sz = fixed_size;
     allocate(_size);
 }
 
-template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>::~AutoBuffer()
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::AutoBuffer(const AutoBuffer<_Tp, fixed_size>& abuf )
+{
+    ptr = buf;
+    sz = fixed_size;
+    allocate(abuf.size);
+    for( size_t i = 0; i < sz; i++ )
+        ptr[i] = abuf.ptr[i];
+}
+
+template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>&
+AutoBuffer<_Tp, fixed_size>::operator = (const AutoBuffer<_Tp, fixed_size>& abuf)
+{
+    if( this != &abuf )
+    {
+        deallocate();
+        allocate(abuf.size);
+        for( size_t i = 0; i < sz; i++ )
+            ptr[i] = abuf.ptr[i];
+    }
+    return *this;
+}
+
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::~AutoBuffer()
 { deallocate(); }
 
-template<typename _Tp, size_t fixed_size> inline void AutoBuffer<_Tp, fixed_size>::allocate(size_t _size)
+template<typename _Tp, size_t fixed_size> inline void
+AutoBuffer<_Tp, fixed_size>::allocate(size_t _size)
 {
-    if(_size <= size)
+    if(_size <= sz)
+    {
+        sz = _size;
         return;
+    }
     deallocate();
     if(_size > fixed_size)
     {
-        ptr = cv::allocate<_Tp>(_size);
-        size = _size;
+        ptr = new _Tp[_size];
+        sz = _size;
     }
 }
 
-template<typename _Tp, size_t fixed_size> inline void AutoBuffer<_Tp, fixed_size>::deallocate()
+template<typename _Tp, size_t fixed_size> inline void
+AutoBuffer<_Tp, fixed_size>::deallocate()
 {
     if( ptr != buf )
     {
-        cv::deallocate<_Tp>(ptr, size);
+        delete[] ptr;
         ptr = buf;
-        size = fixed_size;
+        sz = fixed_size;
     }
 }
 
-template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>::operator _Tp* ()
+template<typename _Tp, size_t fixed_size> inline void
+AutoBuffer<_Tp, fixed_size>::resize(size_t _size)
+{
+    if(_size <= sz)
+    {
+        sz = _size;
+        return;
+    }
+    size_t i, prevsize = sz, minsize = MIN(prevsize, _size);
+    _Tp* prevptr = ptr;
+    
+    ptr = _size > fixed_size ? new _Tp[_size] : buf;
+    sz = _size;
+    
+    if( ptr != prevptr )
+        for( i = 0; i < minsize; i++ )
+            ptr[i] = prevptr[i];
+    for( i = prevsize; i < _size; i++ )
+        ptr[i] = _Tp();
+    
+    if( prevptr != buf )
+        delete[] prevptr;
+}
+
+template<typename _Tp, size_t fixed_size> inline size_t
+AutoBuffer<_Tp, fixed_size>::size() const
+{ return sz; }
+
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::operator _Tp* ()
 { return ptr; }
 
-template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>::operator const _Tp* () const
+template<typename _Tp, size_t fixed_size> inline
+AutoBuffer<_Tp, fixed_size>::operator const _Tp* () const
 { return ptr; }
 
 

modules/core/src/convert.cpp

@@ -1314,7 +1314,7 @@ cvMixChannels( const CvArr** src, int src_count,
                CvArr** dst, int dst_count,
                const int* from_to, int pair_count )
 {
-    cv::AutoBuffer<cv::Mat, 32> buf(src_count + dst_count);
+    cv::AutoBuffer<cv::Mat> buf(src_count + dst_count);
 
     int i;
     for( i = 0; i < src_count; i++ )

modules/core/src/matrix.cpp

@@ -669,7 +669,7 @@ void Mat::push_back(const Mat& elems)
 
 
 Mat cvarrToMat(const CvArr* arr, bool copyData,
-               bool /*allowND*/, int coiMode)
+               bool /*allowND*/, int coiMode, AutoBuffer<double>* abuf )
 {
     if( !arr )
         return Mat();
@@ -687,10 +687,21 @@ Mat cvarrToMat(const CvArr* arr, bool copyData,
     if( CV_IS_SEQ(arr) )
     {
         CvSeq* seq = (CvSeq*)arr;
-        CV_Assert(seq->total > 0 && CV_ELEM_SIZE(seq->flags) == seq->elem_size);
+        int total = seq->total, type = CV_MAT_TYPE(seq->flags), esz = seq->elem_size;
+        if( total == 0 )
+            return Mat();
+        CV_Assert(total > 0 && CV_ELEM_SIZE(seq->flags) == esz);
         if(!copyData && seq->first->next == seq->first)
-            return Mat(seq->total, 1, CV_MAT_TYPE(seq->flags), seq->first->data);
-        Mat buf(seq->total, 1, CV_MAT_TYPE(seq->flags));
+            return Mat(total, 1, type, seq->first->data);
+        if( abuf )
+        {
+            abuf->allocate(((size_t)total*esz + sizeof(double)-1)/sizeof(double));
+            double* bufdata = *abuf;
+            cvCvtSeqToArray(seq, bufdata, CV_WHOLE_SEQ);
+            return Mat(total, 1, type, bufdata);
+        }
+
+        Mat buf(total, 1, type);
         cvCvtSeqToArray(seq, buf.data, CV_WHOLE_SEQ);
         return buf;
     }
@@ -830,7 +841,7 @@ int Mat::checkVector(int _elemChannels, int _depth, bool _requireContinuous) con
 {
     return (depth() == _depth || _depth <= 0) &&
         (isContinuous() || !_requireContinuous) &&
-        ((dims == 2 && (((rows == 1 || cols == 1) && channels() == _elemChannels) || (cols == _elemChannels))) ||
+        ((dims == 2 && (((rows == 1 || cols == 1) && channels() == _elemChannels) || (cols == _elemChannels && channels() == 1))) ||
         (dims == 3 && channels() == 1 && size.p[2] == _elemChannels && (size.p[0] == 1 || size.p[1] == 1) &&
          (isContinuous() || step.p[1] == step.p[2]*size.p[2])))
     ? (int)(total()*channels()/_elemChannels) : -1;

modules/highgui/src/grfmt_pxm.cpp

@@ -202,9 +202,9 @@ bool  PxMDecoder::readData( Mat& img )
     if( m_offset < 0 || !m_strm.isOpened())
         return false;
 
-    AutoBuffer<uchar,1024> _src(src_pitch + 32);
+    AutoBuffer<uchar> _src(src_pitch + 32);
     uchar* src = _src;
-    AutoBuffer<uchar,1024> _gray_palette;
+    AutoBuffer<uchar> _gray_palette;
     uchar* gray_palette = _gray_palette;
 
     // create LUT for converting colors

modules/highgui/src/grfmt_tiff.cpp

@@ -469,7 +469,7 @@ bool  TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
 
     // row buffer, because TIFFWriteScanline modifies the original data!
     size_t scanlineSize = TIFFScanlineSize(pTiffHandle);
-    AutoBuffer<uchar,1024> _buffer(scanlineSize+32);
+    AutoBuffer<uchar> _buffer(scanlineSize+32);
     uchar* buffer = _buffer;
     if (!buffer)
     {
@@ -577,9 +577,9 @@ bool  TiffEncoder::write( const Mat& img, const vector<int>& /*params*/)
 #endif*/
     int directoryOffset = 0;
 
-    AutoBuffer<int,1024> stripOffsets(stripCount);
-    AutoBuffer<short,1024> stripCounts(stripCount);
-    AutoBuffer<uchar,1024> _buffer(fileStep+32);
+    AutoBuffer<int> stripOffsets(stripCount);
+    AutoBuffer<short> stripCounts(stripCount);
+    AutoBuffer<uchar> _buffer(fileStep+32);
     uchar* buffer = _buffer;
     int  stripOffsetsOffset = 0;
     int  stripCountsOffset = 0;

modules/imgproc/src/_geom.h

@@ -52,16 +52,6 @@ CV_INLINE  float  icvDistanceL2_32f( CvPoint2D32f pt1, CvPoint2D32f pt2 )
 }
 
 
-int  icvIntersectLines( double x1, double dx1, double y1, double dy1,
-                        double x2, double dx2, double y2, double dy2,
-                        double* t2 );
-
-
-void icvIntersectLines3( double* a0, double* b0, double* c0,
-                         double* a1, double* b1, double* c1,
-                         CvPoint2D32f* point );
-
-
 /* curvature: 0 - 1-curvature, 1 - k-cosine curvature. */
 CvSeq* icvApproximateChainTC89( CvChain* chain, int header_size, CvMemStorage* storage, int method );
 

modules/imgproc/src/contours.cpp

@@ -1753,195 +1753,4 @@ void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
     findContours(_image, _contours, noArray(), mode, method, offset);
 }
 
-void cv::approxPolyDP( InputArray _curve, OutputArray _approxCurve,
-                       double epsilon, bool closed )
-{
-    Mat curve = _curve.getMat();
-    int npoints = curve.checkVector(2), depth = curve.depth();
-    CV_Assert( npoints >= 0 && (depth == CV_32S || depth == CV_32F));
-    CvMat _ccurve = curve;
-    MemStorage storage(cvCreateMemStorage());
-    CvSeq* result = cvApproxPoly(&_ccurve, sizeof(CvContour), storage, CV_POLY_APPROX_DP, epsilon, closed);
-    if( result->total > 0 )
-    {
-        _approxCurve.create(result->total, 1, CV_MAKETYPE(curve.depth(), 2), -1, true);
-        cvCvtSeqToArray(result, _approxCurve.getMat().data );
-    }
-}
-
-
-double cv::arcLength( InputArray _curve, bool closed )
-{
-    Mat curve = _curve.getMat();
-    CV_Assert(curve.checkVector(2) >= 0 && (curve.depth() == CV_32F || curve.depth() == CV_32S));
-    CvMat _ccurve = curve;
-    return cvArcLength(&_ccurve, CV_WHOLE_SEQ, closed);
-}
-
-
-cv::Rect cv::boundingRect( InputArray _points )
-{
-    Mat points = _points.getMat();
-    CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
-    CvMat _cpoints = points;
-    return cvBoundingRect(&_cpoints, 0);
-}
-
-
-double cv::contourArea( InputArray _contour, bool oriented )
-{
-    Mat contour = _contour.getMat();
-    CV_Assert(contour.checkVector(2) >= 0 && (contour.depth() == CV_32F || contour.depth() == CV_32S));
-    CvMat _ccontour = contour;
-    return cvContourArea(&_ccontour, CV_WHOLE_SEQ, oriented);
-}
-
-
-cv::RotatedRect cv::minAreaRect( InputArray _points )
-{
-    Mat points = _points.getMat();
-    CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
-    CvMat _cpoints = points;
-    return cvMinAreaRect2(&_cpoints, 0);
-}
-
-
-void cv::minEnclosingCircle( InputArray _points,
-                             Point2f& center, float& radius )
-{
-    Mat points = _points.getMat();
-    CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
-    CvMat _cpoints = points;
-    cvMinEnclosingCircle( &_cpoints, (CvPoint2D32f*)&center, &radius );
-}
-
-
-double cv::matchShapes( InputArray _contour1,
-                        InputArray _contour2,
-                        int method, double parameter )
-{
-    Mat contour1 = _contour1.getMat(), contour2 = _contour2.getMat();
-    CV_Assert(contour1.checkVector(2) >= 0 && contour2.checkVector(2) >= 0 &&
-              (contour1.depth() == CV_32F || contour1.depth() == CV_32S) &&
-              contour1.depth() == contour2.depth());
-
-    CvMat c1 = Mat(contour1), c2 = Mat(contour2);
-    return cvMatchShapes(&c1, &c2, method, parameter);
-}
-
-
-void cv::convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints )
-{
-    Mat points = _points.getMat();
-    int nelems = points.checkVector(2), depth = points.depth();
-    CV_Assert(nelems >= 0 && (depth == CV_32F || depth == CV_32S));
-
-    if( nelems == 0 )
-    {
-        _hull.release();
-        return;
-    }
-
-    returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S;
-    Mat hull(nelems, 1, returnPoints ? CV_MAKETYPE(depth, 2) : CV_32S);
-    CvMat _cpoints = points, _chull = hull;
-    cvConvexHull2(&_cpoints, &_chull, clockwise ? CV_CLOCKWISE : CV_COUNTER_CLOCKWISE, returnPoints);
-    _hull.create(_chull.rows, 1, hull.type(), -1, true);
-    Mat dhull = _hull.getMat(), shull(dhull.size(), dhull.type(), hull.data);
-    shull.copyTo(dhull);
-}
-
-
-void cv::convexityDefects( InputArray _points, InputArray _hull, OutputArray _defects )
-{
-    Mat points = _points.getMat();
-    int ptnum = points.checkVector(2, CV_32S);
-    CV_Assert( ptnum > 3 );
-    Mat hull = _hull.getMat();
-    CV_Assert( hull.checkVector(1, CV_32S) > 2 );
-    Ptr<CvMemStorage> storage = cvCreateMemStorage();
-
-    CvMat c_points = points, c_hull = hull;
-    CvSeq* seq = cvConvexityDefects(&c_points, &c_hull, storage);
-    int i, n = seq->total;
-
-    if( n == 0 )
-    {
-        _defects.release();
-        return;
-    }
-
-    _defects.create(n, 1, CV_32SC4);
-    Mat defects = _defects.getMat();
-
-    SeqIterator<CvConvexityDefect> it = Seq<CvConvexityDefect>(seq).begin();
-    CvPoint* ptorg = (CvPoint*)points.data;
-
-    for( i = 0; i < n; i++, ++it )
-    {
-        CvConvexityDefect& d = *it;
-        int idx0 = (int)(d.start - ptorg);
-        int idx1 = (int)(d.end - ptorg);
-        int idx2 = (int)(d.depth_point - ptorg);
-        CV_Assert( 0 <= idx0 && idx0 < ptnum );
-        CV_Assert( 0 <= idx1 && idx1 < ptnum );
-        CV_Assert( 0 <= idx2 && idx2 < ptnum );
-        CV_Assert( d.depth >= 0 );
-        int idepth = cvRound(d.depth*256);
-        defects.at<Vec4i>(i) = Vec4i(idx0, idx1, idx2, idepth);
-    }
-}
-
-
-bool cv::isContourConvex( InputArray _contour )
-{
-    Mat contour = _contour.getMat();
-    CV_Assert(contour.checkVector(2) >= 0 &&
-              (contour.depth() == CV_32F || contour.depth() == CV_32S));
-    CvMat c = Mat(contour);
-    return cvCheckContourConvexity(&c) > 0;
-}
-
-cv::RotatedRect cv::fitEllipse( InputArray _points )
-{
-    Mat points = _points.getMat();
-    CV_Assert(points.checkVector(2) >= 0 &&
-              (points.depth() == CV_32F || points.depth() == CV_32S));
-    CvMat _cpoints = points;
-    return cvFitEllipse2(&_cpoints);
-}
-
-
-void cv::fitLine( InputArray _points, OutputArray _line, int distType,
-                  double param, double reps, double aeps )
-{
-    Mat points = _points.getMat();
-
-    bool is3d = points.checkVector(3) >= 0;
-    bool is2d = points.checkVector(2) >= 0;
-
-    CV_Assert( (is2d || is3d) && (points.depth() == CV_32F || points.depth() == CV_32S) );
-    CvMat _cpoints = points.reshape(2 + (int)is3d);
-    float line[6];
-    cvFitLine(&_cpoints, distType, param, reps, aeps, &line[0]);
-
-    int out_size = (is2d)?( (is3d)? (points.channels() * points.rows * 2) : 4 ): 6;
-
-    _line.create(out_size, 1, CV_32F, -1, true);
-    Mat l = _line.getMat();
-    CV_Assert( l.isContinuous() );
-    memcpy( l.data, line, out_size * sizeof(line[0]) );
-}
-
-
-double cv::pointPolygonTest( InputArray _contour,
-                             Point2f pt, bool measureDist )
-{
-    Mat contour = _contour.getMat();
-    CV_Assert(contour.checkVector(2) >= 0 &&
-              (contour.depth() == CV_32F || contour.depth() == CV_32S));
-    CvMat c = Mat(contour);
-    return cvPointPolygonTest( &c, pt, measureDist );
-}
-
 /* End of file. */

modules/imgproc/src/geometry.cpp

@@ -92,93 +92,34 @@ cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] )
 }
 
 
-int
-icvIntersectLines( double x1, double dx1, double y1, double dy1,
-                   double x2, double dx2, double y2, double dy2, double *t2 )
-{
-    double d = dx1 * dy2 - dx2 * dy1;
-    int result = -1;
-
-    if( d != 0 )
-    {
-        *t2 = ((x2 - x1) * dy1 - (y2 - y1) * dx1) / d;
-        result = 0;
-    }
-    return result;
-}
-
-
-void
-icvIntersectLines3( double *a0, double *b0, double *c0,
-                    double *a1, double *b1, double *c1, CvPoint2D32f * point )
-{
-    double det = a0[0] * b1[0] - a1[0] * b0[0];
-
-    if( det != 0 )
-    {
-        det = 1. / det;
-        point->x = (float) ((b0[0] * c1[0] - b1[0] * c0[0]) * det);
-        point->y = (float) ((a1[0] * c0[0] - a0[0] * c1[0]) * det);
-    }
-    else
-    {
-        point->x = point->y = FLT_MAX;
-    }
-}
-
-
-CV_IMPL double
-cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
+double cv::pointPolygonTest( InputArray _contour, Point2f pt, bool measureDist )
 {
     double result = 0;
+    Mat contour = _contour.getMat();
+    int i, total = contour.checkVector(2), counter = 0;
+    int depth = contour.depth();
+    CV_Assert( total >= 0 && (depth == CV_32S || depth == CV_32F));
 
-    CvSeqBlock block;
-    CvContour header;
-    CvSeq* contour = (CvSeq*)_contour;
-    CvSeqReader reader;
-    int i, total, counter = 0;
-    int is_float;
+    bool is_float = depth == CV_32F;
     double min_dist_num = FLT_MAX, min_dist_denom = 1;
-    CvPoint ip = {0,0};
+    Point ip(cvRound(pt.x), cvRound(pt.y));
 
-    if( !CV_IS_SEQ(contour) )
-    {
-        contour = cvPointSeqFromMat( CV_SEQ_KIND_CURVE + CV_SEQ_FLAG_CLOSED,
-                                    _contour, &header, &block );
-    }
-    else if( CV_IS_SEQ_POINT_SET(contour) )
-    {
-        if( contour->header_size == sizeof(CvContour) && !measure_dist )
-        {
-            CvRect r = ((CvContour*)contour)->rect;
-            if( pt.x < r.x || pt.y < r.y ||
-                pt.x >= r.x + r.width || pt.y >= r.y + r.height )
-                return -1;
-        }
-    }
-    else if( CV_IS_SEQ_CHAIN(contour) )
-    {
-        CV_Error( CV_StsBadArg,
-            "Chains are not supported. Convert them to polygonal representation using cvApproxChains()" );
-    }
-    else
-        CV_Error( CV_StsBadArg, "Input contour is neither a valid sequence nor a matrix" );
+    if( total == 0 )
+        return measureDist ? -DBL_MAX : -1;
 
-    total = contour->total;
-    is_float = CV_SEQ_ELTYPE(contour) == CV_32FC2;
-    cvStartReadSeq( contour, &reader, -1 );
+    const Point* cnt = (const Point*)contour.data;
+    const Point2f* cntf = (const Point2f*)cnt;
 
-    if( !is_float && !measure_dist && (ip.x = cvRound(pt.x)) == pt.x && (ip.y = cvRound(pt.y)) == pt.y )
+    if( !is_float && !measureDist && ip.x == pt.x && ip.y == pt.y )
     {
-        // the fastest "pure integer" branch
-        CvPoint v0, v;
-        CV_READ_SEQ_ELEM( v, reader );
+        // the fastest "purely integer" branch
+        Point v0, v = cnt[total-1];
 
         for( i = 0; i < total; i++ )
         {
             int dist;
             v0 = v;
-            CV_READ_SEQ_ELEM( v, reader );
+            v = cnt[i];
 
             if( (v0.y <= ip.y && v.y <= ip.y) ||
                (v0.y > ip.y && v.y > ip.y) ||
@@ -202,34 +143,28 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
     }
     else
     {
-        CvPoint2D32f v0, v;
-        CvPoint iv;
+        Point2f v0, v;
+        Point iv;
 
         if( is_float )
         {
-            CV_READ_SEQ_ELEM( v, reader );
+            v = cntf[total-1];
         }
         else
         {
-            CV_READ_SEQ_ELEM( iv, reader );
-            v = cvPointTo32f( iv );
+            v = cnt[total-1];
         }
 
-        if( !measure_dist )
+        if( !measureDist )
         {
             for( i = 0; i < total; i++ )
             {
                 double dist;
                 v0 = v;
                 if( is_float )
-                {
-                    CV_READ_SEQ_ELEM( v, reader );
-                }
+                    v = cntf[i];
                 else
-                {
-                    CV_READ_SEQ_ELEM( iv, reader );
-                    v = cvPointTo32f( iv );
-                }
+                    v = cnt[i];
 
                 if( (v0.y <= pt.y && v.y <= pt.y) ||
                    (v0.y > pt.y && v.y > pt.y) ||
@@ -259,14 +194,9 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
 
                 v0 = v;
                 if( is_float )
-                {
-                    CV_READ_SEQ_ELEM( v, reader );
-                }
+                    v = cntf[i];
                 else
-                {
-                    CV_READ_SEQ_ELEM( iv, reader );
-                    v = cvPointTo32f( iv );
-                }
+                    v = cnt[i];
 
                 dx = v.x - v0.x; dy = v.y - v0.y;
                 dx1 = pt.x - v0.x; dy1 = pt.y - v0.y;
@@ -312,6 +242,14 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
 }
 
 
+CV_IMPL double
+cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
+{
+    cv::AutoBuffer<double> abuf;
+    cv::Mat contour = cv::cvarrToMat(_contour, false, false, 0, &abuf);
+    return cv::pointPolygonTest(contour, pt, measure_dist != 0);
+}
+
 /*
  This code is described in "Computational Geometry in C" (Second Edition),
  Chapter 7.  It is not written to be comprehensible without the

modules/imgproc/src/matchcontours.cpp

@@ -40,64 +40,21 @@
 //M*/
 #include "precomp.hpp"
 
-/*F///////////////////////////////////////////////////////////////////////////////////////
-//    Name: cvMatchContours
-//    Purpose:
-//      Calculates matching of the two contours
-//    Context:
-//    Parameters:
-//      contour_1 - pointer to the first input contour object.
-//      contour_2 - pointer to the second input contour object.
-//      method - method for the matching calculation
-//      (now CV_IPPI_CONTOURS_MATCH_I1, CV_CONTOURS_MATCH_I2 or
-//      CV_CONTOURS_MATCH_I3 only  )
-//      rezult - output calculated measure
-//
-//F*/
-CV_IMPL  double
-cvMatchShapes( const void* contour1, const void* contour2,
-               int method, double /*parameter*/ )
+
+double cv::matchShapes(InputArray contour1, InputArray contour2, int method, double)
 {
-    CvMoments moments;
-    CvHuMoments huMoments;
     double ma[7], mb[7];
     int i, sma, smb;
     double eps = 1.e-5;
     double mmm;
     double result = 0;
 
-    if( !contour1 || !contour2 )
-        CV_Error( CV_StsNullPtr, "" );
-
-    // calculate moments of the first shape
-    cvMoments( contour1, &moments );
-    cvGetHuMoments( &moments, &huMoments );
-
-    ma[0] = huMoments.hu1;
-    ma[1] = huMoments.hu2;
-    ma[2] = huMoments.hu3;
-    ma[3] = huMoments.hu4;
-    ma[4] = huMoments.hu5;
-    ma[5] = huMoments.hu6;
-    ma[6] = huMoments.hu7;
-
-
-    // calculate moments of the second shape
-    cvMoments( contour2, &moments );
-    cvGetHuMoments( &moments, &huMoments );
-
-    mb[0] = huMoments.hu1;
-    mb[1] = huMoments.hu2;
-    mb[2] = huMoments.hu3;
-    mb[3] = huMoments.hu4;
-    mb[4] = huMoments.hu5;
-    mb[5] = huMoments.hu6;
-    mb[6] = huMoments.hu7;
+    HuMoments( moments(contour1), ma );
+    HuMoments( moments(contour2), mb );
 
     switch (method)
     {
     case 1:
-        {
         for( i = 0; i < 7; i++ )
         {
             double ama = fabs( ma[i] );
@@ -124,10 +81,8 @@ cvMatchShapes( const void* contour1, const void* contour2,
             }
         }
         break;
-        }
 
     case 2:
-        {
         for( i = 0; i < 7; i++ )
         {
             double ama = fabs( ma[i] );
@@ -154,10 +109,8 @@ cvMatchShapes( const void* contour1, const void* contour2,
             }
         }
         break;
-        }
 
     case 3:
-        {
         for( i = 0; i < 7; i++ )
         {
             double ama = fabs( ma[i] );
@@ -186,7 +139,6 @@ cvMatchShapes( const void* contour1, const void* contour2,
             }
         }
         break;
-        }
     default:
         CV_Error( CV_StsBadArg, "Unknown comparison method" );
     }
@@ -195,4 +147,15 @@ cvMatchShapes( const void* contour1, const void* contour2,
 }
 
 
+CV_IMPL  double
+cvMatchShapes( const void* _contour1, const void* _contour2,
+               int method, double parameter )
+{
+    cv::AutoBuffer<double> abuf1, abuf2;
+    cv::Mat contour1 = cv::cvarrToMat(_contour1, false, false, 0, &abuf1);
+    cv::Mat contour2 = cv::cvarrToMat(_contour2, false, false, 0, &abuf2);
+
+    return cv::matchShapes(contour1, contour2, method, parameter);
+}
+
 /* End of file. */

modules/video/src/optflowgf.cpp

@@ -395,8 +395,8 @@ FarnebackUpdateFlow_GaussianBlur( const Mat& _R0, const Mat& _R1,
     double sigma = m*0.3, s = 1;
 
     AutoBuffer<float> _vsum((width+m*2+2)*5 + 16), _hsum(width*5 + 16);
-    AutoBuffer<float, 4096> _kernel((m+1)*5 + 16);
-    AutoBuffer<float*, 1024> _srow(m*2+1);
+    AutoBuffer<float> _kernel((m+1)*5 + 16);
+    AutoBuffer<float*> _srow(m*2+1);
     float *vsum = alignPtr((float*)_vsum + (m+1)*5, 16), *hsum = alignPtr((float*)_hsum, 16);
     float* kernel = (float*)_kernel;
     const float** srow = (const float**)&_srow[0];

samples/cpp/minarea.cpp

@@ -13,7 +13,7 @@ static void help()
             "Random points are generated and then enclosed.\n"
             "Call:\n"
             "./minarea\n"
-            "Using OpenCV version %s\n" << CV_VERSION << "\n" << endl;
+            "Using OpenCV v" << CV_VERSION << "\n" << endl;
 }
 
 int main( int /*argc*/, char** /*argv*/ )