eliminated opencv_extra_api.hpp (all the functionality is moved to the regular OpenCV headers)

modules/core/src/convert.cpp

@@ -503,6 +503,22 @@ void cv::mixChannels(const vector<Mat>& src, vector<Mat>& dst,
                 !dst.empty() ? &dst[0] : 0, dst.size(), fromTo, npairs);
 }
 
+void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
+                     const vector<int>& fromTo)
+{
+    if(fromTo.empty())
+        return;
+    size_t i, nsrc = src.total(), ndst = dst.total();
+    CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0);
+    cv::AutoBuffer<Mat> _buf(nsrc + ndst);
+    Mat* buf = _buf;
+    for( i = 0; i < nsrc; i++ )
+        buf[i] = src.getMat(i);
+    for( i = 0; i < ndst; i++ )
+        buf[nsrc + i] = dst.getMat(i);
+    mixChannels(&buf[0], (int)nsrc, &buf[nsrc], (int)ndst, &fromTo[0], (int)(fromTo.size()/2));
+}
+
 void cv::extractChannel(InputArray _src, OutputArray _dst, int coi)
 {
     Mat src = _src.getMat();

modules/core/src/drawing.cpp

@@ -2012,6 +2012,63 @@ Size getTextSize( const string& text, int fontFace, double fontScale, int thickn
 
 }
 
+
+void cv::fillConvexPoly(InputOutputArray _img, InputArray _points,
+                        const Scalar& color, int lineType, int shift)
+{
+    Mat img = _img.getMat(), points = _points.getMat();
+    CV_Assert(points.checkVector(2, CV_32S) >= 0);
+    fillConvexPoly(img, (const Point*)points.data, points.rows*points.cols*points.channels()/2, color, lineType, shift);
+}
+
+
+void cv::fillPoly(InputOutputArray _img, InputArrayOfArrays pts,
+                  const Scalar& color, int lineType, int shift, Point offset)
+{
+    Mat img = _img.getMat();
+    size_t i, ncontours = pts.total();
+    if( ncontours == 0 )
+        return;
+    AutoBuffer<Point*> _ptsptr(ncontours);
+    AutoBuffer<int> _npts(ncontours);
+    Point** ptsptr = _ptsptr;
+    int* npts = _npts;
+    
+    for( i = 0; i < ncontours; i++ )
+    {
+        Mat p = pts.getMat(i);
+        CV_Assert(p.checkVector(2, CV_32S) >= 0);
+        ptsptr[i] = (Point*)p.data;
+        npts[i] = p.rows*p.cols*p.channels()/2;
+    }
+    fillPoly(img, (const Point**)ptsptr, npts, (int)ncontours, color, lineType, shift, offset);
+}
+
+
+void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
+                   bool isClosed, const Scalar& color,
+                   int thickness, int lineType, int shift )
+{
+    Mat img = _img.getMat();
+    size_t i, ncontours = pts.total();
+    if( ncontours == 0 )
+        return;
+    AutoBuffer<Point*> _ptsptr(ncontours);
+    AutoBuffer<int> _npts(ncontours);
+    Point** ptsptr = _ptsptr;
+    int* npts = _npts;
+    
+    for( i = 0; i < ncontours; i++ )
+    {
+        Mat p = pts.getMat(i);
+        CV_Assert(p.checkVector(2, CV_32S) >= 0);
+        ptsptr[i] = (Point*)p.data;
+        npts[i] = p.rows*p.cols*p.channels()/2;
+    }
+    polylines(img, (const Point**)ptsptr, npts, (int)ncontours, isClosed, color, thickness, lineType, shift);
+}
+
+
 static const int CodeDeltas[8][2] =
 { {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1} };
 

modules/core/src/lapack.cpp

@@ -1398,10 +1398,7 @@ bool cv::solve( InputArray _src, InputArray _src2arg, OutputArray _dst, int meth
 
 /////////////////// finding eigenvalues and eigenvectors of a symmetric matrix ///////////////
 
-namespace cv
-{
-
-static bool eigen( InputArray _src, OutputArray _evals, OutputArray _evects, bool computeEvects, int, int )
+bool cv::eigen( InputArray _src, bool computeEvects, OutputArray _evals, OutputArray _evects )
 {
     Mat src = _src.getMat();
     int type = src.type();
@@ -1431,17 +1428,14 @@ static bool eigen( InputArray _src, OutputArray _evals, OutputArray _evects, boo
     return ok;
 }
 
-}
-    
-bool cv::eigen( InputArray src, OutputArray evals, int lowindex, int highindex )
+bool cv::eigen( InputArray src, OutputArray evals, int, int )
 {
-    return eigen(src, evals, noArray(), false, lowindex, highindex);
+    return eigen(src, false, evals, noArray());
 }
 
-bool cv::eigen( InputArray src, OutputArray evals, OutputArray evects,
-                int lowindex, int highindex )
+bool cv::eigen( InputArray src, OutputArray evals, OutputArray evects, int, int)
 {
-    return eigen(src, evals, evects, true, lowindex, highindex);
+    return eigen(src, true, evals, evects);
 }
 
 namespace cv
@@ -1568,6 +1562,17 @@ void SVD::backSubst( InputArray rhs, OutputArray dst ) const
 }
 
 
+void cv::SVDecomp(InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags)
+{
+    SVD::compute(src, w, u, vt, flags);
+}
+
+void cv::SVBackSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
+{
+    SVD::backSubst(w, u, vt, rhs, dst);
+}
+
+
 CV_IMPL double
 cvDet( const CvArr* arr )
 {

modules/core/src/matmul.cpp

@@ -2884,6 +2884,34 @@ Mat PCA::backProject(InputArray data) const
 
 }
 
+void cv::PCACompute(InputArray data, InputOutputArray mean,
+                    OutputArray eigenvectors, int maxComponents)
+{
+    PCA pca;
+    pca(data, mean, 0, maxComponents);
+    pca.mean.copyTo(mean);
+    pca.eigenvectors.copyTo(eigenvectors);
+}
+    
+void cv::PCAProject(InputArray data, InputArray mean,
+                    InputArray eigenvectors, OutputArray result)
+{
+    PCA pca;
+    pca.mean = mean.getMat();
+    pca.eigenvectors = eigenvectors.getMat();
+    pca.project(data, result);
+}
+
+void cv::PCABackProject(InputArray data, InputArray mean,
+                    InputArray eigenvectors, OutputArray result)
+{
+    PCA pca;
+    pca.mean = mean.getMat();
+    pca.eigenvectors = eigenvectors.getMat();
+    pca.backProject(data, result);
+}
+
+
 /****************************************************************************************\
 *                                    Earlier API                                         *
 \****************************************************************************************/

modules/core/src/rand.cpp

@@ -812,6 +812,11 @@ void cv::randShuffle( InputOutputArray _dst, double iterFactor, RNG* _rng )
     func( dst, rng, iterFactor );
 }
 
+void cv::randShuffle_( InputOutputArray _dst, double iterFactor )
+{
+    randShuffle(_dst, iterFactor);
+}
+
 CV_IMPL void
 cvRandArr( CvRNG* _rng, CvArr* arr, int disttype, CvScalar param1, CvScalar param2 )
 {