diff --git a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp index 4491849c3..81924805f 100644 --- a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp @@ -536,6 +536,9 @@ CV_EXPORTS bool findCirclesGrid( InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr &blobDetector = new SimpleBlobDetector()); +CV_EXPORTS_W bool findCirclesGridDefault( InputArray image, Size patternSize, + OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID ); + enum { CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS, diff --git a/modules/calib3d/src/circlesgrid.cpp b/modules/calib3d/src/circlesgrid.cpp index 36fecba55..f1d20c292 100644 --- a/modules/calib3d/src/circlesgrid.cpp +++ b/modules/calib3d/src/circlesgrid.cpp @@ -1524,3 +1524,10 @@ size_t CirclesGridFinder::getFirstCorner(vector &largeCornerIndices, vect return cornerIdx; } + +bool cv::findCirclesGridDefault( InputArray image, Size patternSize, + OutputArray centers, int flags ) +{ + return findCirclesGrid(image, patternSize, centers, flags); +} + diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 492f8f489..50d8ac4f1 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/modules/core/include/opencv2/core/core.hpp @@ -216,7 +216,7 @@ CV_EXPORTS int getThreadNum(); before and after the function call. The granularity of ticks depends on the hardware and OS used. Use cv::getTickFrequency() to convert ticks to seconds. */ -CV_EXPORTS int64 getTickCount(); +CV_EXPORTS_W int64 getTickCount(); /*! Returns the number of ticks per seconds. @@ -240,7 +240,7 @@ CV_EXPORTS_W double getTickFrequency(); one can accurately measure the execution time of very small code fragments, for which cv::getTickCount() granularity is not enough. */ -CV_EXPORTS int64 getCPUTickCount(); +CV_EXPORTS_W int64 getCPUTickCount(); /*! Returns SSE etc. support status @@ -1327,6 +1327,7 @@ typedef InputArray InputArrayOfArrays; typedef const _OutputArray& OutputArray; typedef OutputArray OutputArrayOfArrays; typedef OutputArray InputOutputArray; +typedef OutputArray InputOutputArrayOfArrays; CV_EXPORTS OutputArray noArray(); @@ -2038,6 +2039,8 @@ CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts const int* fromTo, size_t npairs); CV_EXPORTS void mixChannels(const vector& src, vector& dst, const int* fromTo, size_t npairs); +CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, + const vector& fromTo); //! extracts a single channel from src (coi is 0-based index) CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi); @@ -2162,6 +2165,9 @@ CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1, CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1); +CV_EXPORTS_W bool eigen(InputArray src, bool computeEigenvectors, + OutputArray eigenvalues, OutputArray eigenvectors); + //! computes covariation matrix of a set of samples CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, int flags, int ctype=CV_64F); @@ -2246,6 +2252,16 @@ public: Mat mean; //!< mean value subtracted before the projection and added after the back projection }; +CV_EXPORTS_W void PCACompute(InputArray data, CV_OUT InputOutputArray mean, + OutputArray eigenvectors, int maxComponents=0); + +CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean, + InputArray eigenvectors, OutputArray result); + +CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean, + InputArray eigenvectors, OutputArray result); + + /*! Singular Value Decomposition class @@ -2295,6 +2311,14 @@ public: Mat u, w, vt; }; +//! computes SVD of src +CV_EXPORTS_W void SVDecomp( InputArray src, CV_OUT OutputArray w, + CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0 ); + +//! performs back substitution for the previously computed SVD +CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt, + InputArray rhs, CV_OUT OutputArray dst ); + //! computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar); //! a synonym for Mahalanobis @@ -2342,6 +2366,7 @@ CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev //! shuffles the input array elements CV_EXPORTS void randShuffle(InputOutputArray dst, double iterFactor=1., RNG* rng=0); +CV_EXPORTS_AS(randShuffle) void randShuffle_(InputOutputArray dst, double iterFactor=1.); //! draws the line segment (pt1, pt2) in the image CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color, @@ -2376,6 +2401,9 @@ CV_EXPORTS_W void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0); +CV_EXPORTS_W void fillConvexPoly(InputOutputArray img, InputArray points, + const Scalar& color, int lineType=8, + int shift=0); //! fills an area bounded by one or more polygons CV_EXPORTS void fillPoly(Mat& img, const Point** pts, @@ -2383,11 +2411,19 @@ CV_EXPORTS void fillPoly(Mat& img, const Point** pts, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() ); +CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts, + const Scalar& color, int lineType=8, int shift=0, + Point offset=Point() ); + //! draws one or more polygonal curves CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 ); +CV_EXPORTS_W void polylines(InputOutputArray, InputArrayOfArrays pts, + bool isClosed, const Scalar& color, + int thickness=1, int lineType=8, int shift=0 ); + //! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height) CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2); diff --git a/modules/core/src/convert.cpp b/modules/core/src/convert.cpp index 73b13ad71..9965f8478 100644 --- a/modules/core/src/convert.cpp +++ b/modules/core/src/convert.cpp @@ -503,6 +503,22 @@ void cv::mixChannels(const vector& src, vector& dst, !dst.empty() ? &dst[0] : 0, dst.size(), fromTo, npairs); } +void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, + const vector& 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 _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(); diff --git a/modules/core/src/drawing.cpp b/modules/core/src/drawing.cpp index d8101fd8d..e51925b52 100644 --- a/modules/core/src/drawing.cpp +++ b/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 _ptsptr(ncontours); + AutoBuffer _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 _ptsptr(ncontours); + AutoBuffer _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} }; diff --git a/modules/core/src/lapack.cpp b/modules/core/src/lapack.cpp index 03785f9ec..18656fde0 100644 --- a/modules/core/src/lapack.cpp +++ b/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 ) { diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp index 28767bfe3..914cdbaf8 100644 --- a/modules/core/src/matmul.cpp +++ b/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 * \****************************************************************************************/ diff --git a/modules/core/src/rand.cpp b/modules/core/src/rand.cpp index fb68d3884..e143256c8 100644 --- a/modules/core/src/rand.cpp +++ b/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 ) { diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp index f45cf49ad..38528c044 100644 --- a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp @@ -558,6 +558,9 @@ CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] ); //! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM ); +CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst ); +CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst ); + //! extracts rectangle from the image at sub-pixel location CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1 ); @@ -660,6 +663,13 @@ CV_EXPORTS void calcHist( const Mat* images, int nimages, SparseMat& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ); + +CV_EXPORTS_W void calcHist( InputArrayOfArrays images, + const vector& channels, + InputArray mask, OutputArray hist, + const vector& histSize, + const vector& ranges, + bool accumulate=false ); //! computes back projection for the set of images CV_EXPORTS void calcBackProject( const Mat* images, int nimages, @@ -673,6 +683,11 @@ CV_EXPORTS void calcBackProject( const Mat* images, int nimages, OutputArray backProject, const float** ranges, double scale=1, bool uniform=true ); +CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const vector& channels, + InputArray hist, OutputArray dst, + const vector& ranges, + double scale ); + //! compares two histograms stored in dense arrays CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method ); @@ -922,6 +937,7 @@ CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false ); //! computes 7 Hu invariants from the moments CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] ); +CV_EXPORTS_W void HuMoments( const Moments& m, CV_OUT OutputArray hu ); //! type of the template matching operation enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 }; diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp index 7ef258805..7a63b0ae2 100644 --- a/modules/imgproc/src/histogram.cpp +++ b/modules/imgproc/src/histogram.cpp @@ -634,6 +634,7 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels, ihist.convertTo(hist, CV_32F); } + namespace cv { @@ -824,7 +825,36 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels, ranges, uniform, accumulate, false ); } + +void cv::calcHist( InputArrayOfArrays images, const vector& channels, + InputArray mask, OutputArray hist, + const vector& histSize, + const vector& ranges, + bool accumulate ) +{ + int i, dims = (int)histSize.size(), rsz = (int)ranges.size(), csz = (int)channels.size(); + int nimages = (int)images.total(); + CV_Assert(nimages > 0 && dims > 0); + CV_Assert(rsz == dims*2 || (rsz == 0 && images.depth(0) == CV_8U)); + CV_Assert(csz == 0 || csz == dims); + float* _ranges[CV_MAX_DIM]; + if( rsz > 0 ) + { + for( i = 0; i < rsz/2; i++ ) + _ranges[i] = (float*)&ranges[i*2]; + } + + AutoBuffer buf(nimages); + for( i = 0; i < nimages; i++ ) + buf[i] = images.getMat(i); + + calcHist(&buf[0], nimages, csz ? &channels[0] : 0, + mask, hist, dims, &histSize[0], rsz ? (const float**)_ranges : 0, + true, accumulate); +} + + /////////////////////////////////////// B A C K P R O J E C T //////////////////////////////////// namespace cv @@ -1314,6 +1344,32 @@ void cv::calcBackProject( const Mat* images, int nimages, const int* channels, CV_Error(CV_StsUnsupportedFormat, ""); } + +void cv::calcBackProject( InputArrayOfArrays images, const vector& channels, + InputArray hist, OutputArray dst, + const vector& ranges, + double scale ) +{ + int i, dims = hist.getMat().dims, rsz = (int)ranges.size(), csz = (int)channels.size(); + int nimages = (int)images.total(); + CV_Assert(nimages > 0); + CV_Assert(rsz == dims*2 || (rsz == 0 && images.depth(0) == CV_8U)); + CV_Assert(csz == 0 || csz == dims); + float* _ranges[CV_MAX_DIM]; + if( rsz > 0 ) + { + for( i = 0; i < rsz/2; i++ ) + _ranges[i] = (float*)&ranges[i*2]; + } + + AutoBuffer buf(nimages); + for( i = 0; i < nimages; i++ ) + buf[i] = images.getMat(i); + + calcBackProject(&buf[0], nimages, csz ? &channels[0] : 0, + hist, dst, rsz ? (const float**)_ranges : 0, scale, true); +} + ////////////////// C O M P A R E H I S T O G R A M S //////////////////////// diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 1a1de0243..30eda4a95 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -3187,6 +3187,22 @@ void cv::invertAffineTransform(InputArray _matM, OutputArray __iM) CV_Error( CV_StsUnsupportedFormat, "" ); } + +cv::Mat cv::getPerspectiveTransform(InputArray _src, InputArray _dst) +{ + Mat src = _src.getMat(), dst = _dst.getMat(); + CV_Assert(src.checkVector(2, CV_32F) == 4 && dst.checkVector(2, CV_32F) == 4); + return getPerspectiveTransform((const Point2f*)src.data, (const Point2f*)dst.data); +} + +cv::Mat cv::getAffineTransform(InputArray _src, InputArray _dst) +{ + Mat src = _src.getMat(), dst = _dst.getMat(); + CV_Assert(src.checkVector(2, CV_32F) == 3 && dst.checkVector(2, CV_32F) == 3); + return getAffineTransform((const Point2f*)src.data, (const Point2f*)dst.data); +} + + CV_IMPL void cvResize( const CvArr* srcarr, CvArr* dstarr, int method ) { diff --git a/modules/imgproc/src/moments.cpp b/modules/imgproc/src/moments.cpp index 7bdc38a08..aa1a569e3 100644 --- a/modules/imgproc/src/moments.cpp +++ b/modules/imgproc/src/moments.cpp @@ -199,16 +199,16 @@ static void icvContourMoments( CvSeq* contour, CvMoments* moments ) template static void momentsInTile( const cv::Mat& img, double* moments ) { - cv::Size size = img.size(); + cv::Size size = img.size(); int x, y; MT mom[10] = {0,0,0,0,0,0,0,0,0,0}; for( y = 0; y < size.height; y++ ) { - const T* ptr = (const T*)(img.data + y*img.step); - WT x0 = 0, x1 = 0, x2 = 0; - MT x3 = 0; - + const T* ptr = (const T*)(img.data + y*img.step); + WT x0 = 0, x1 = 0, x2 = 0; + MT x3 = 0; + for( x = 0; x < size.width; x++ ) { WT p = ptr[x]; @@ -216,7 +216,7 @@ static void momentsInTile( const cv::Mat& img, double* moments ) x0 += p; x1 += xp; - xxp = xp * x; + xxp = xp * x; x2 += xxp; x3 += xxp * x; } @@ -244,7 +244,7 @@ static void momentsInTile( const cv::Mat& img, double* moments ) template<> void momentsInTile( const cv::Mat& img, double* moments ) { - typedef uchar T; + typedef uchar T; typedef int WT; typedef int MT; cv::Size size = img.size(); @@ -254,8 +254,8 @@ template<> void momentsInTile( const cv::Mat& img, double* mome for( y = 0; y < size.height; y++ ) { - const T* ptr = img.ptr(y); - int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0; + const T* ptr = img.ptr(y); + int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0; if( useSIMD ) { @@ -285,7 +285,7 @@ template<> void momentsInTile( const cv::Mat& img, double* mome _mm_store_si128((__m128i*)buf, qx3); x3 = buf[0] + buf[1] + buf[2] + buf[3]; } - + for( ; x < size.width; x++ ) { WT p = ptr[x]; @@ -293,7 +293,7 @@ template<> void momentsInTile( const cv::Mat& img, double* mome x0 += p; x1 += xp; - xxp = xp * x; + xxp = xp * x; x2 += xxp; x3 += xxp * x; } @@ -322,15 +322,15 @@ typedef void (*CvMomentsInTileFunc)(const cv::Mat& img, double* moments); CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary ) { - const int TILE_SIZE = 32; - int type, depth, cn, coi = 0; + const int TILE_SIZE = 32; + int type, depth, cn, coi = 0; CvMat stub, *mat = (CvMat*)array; CvMomentsInTileFunc func = 0; CvContour contourHeader; CvSeq* contour = 0; CvSeqBlock block; - double buf[TILE_SIZE*TILE_SIZE]; - uchar nzbuf[TILE_SIZE*TILE_SIZE]; + double buf[TILE_SIZE*TILE_SIZE]; + uchar nzbuf[TILE_SIZE*TILE_SIZE]; if( CV_IS_SEQ( array )) { @@ -375,47 +375,47 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary ) if( size.width <= 0 || size.height <= 0 ) return; - if( binary || depth == CV_8U ) - func = momentsInTile; - else if( depth == CV_16U ) - func = momentsInTile; - else if( depth == CV_16S ) - func = momentsInTile; - else if( depth == CV_32F ) - func = momentsInTile; - else if( depth == CV_64F ) - func = momentsInTile; - else - CV_Error( CV_StsUnsupportedFormat, "" ); - - cv::Mat src0(mat); + if( binary || depth == CV_8U ) + func = momentsInTile; + else if( depth == CV_16U ) + func = momentsInTile; + else if( depth == CV_16S ) + func = momentsInTile; + else if( depth == CV_32F ) + func = momentsInTile; + else if( depth == CV_64F ) + func = momentsInTile; + else + CV_Error( CV_StsUnsupportedFormat, "" ); + + cv::Mat src0(mat); for( int y = 0; y < size.height; y += TILE_SIZE ) { cv::Size tileSize; - tileSize.height = std::min(TILE_SIZE, size.height - y); + tileSize.height = std::min(TILE_SIZE, size.height - y); for( int x = 0; x < size.width; x += TILE_SIZE ) { tileSize.width = std::min(TILE_SIZE, size.width - x); - cv::Mat src(src0, cv::Rect(x, y, tileSize.width, tileSize.height)); + cv::Mat src(src0, cv::Rect(x, y, tileSize.width, tileSize.height)); - if( coi > 0 ) - { - cv::Mat tmp(tileSize, depth, buf); - int pairs[] = {coi-1, 0}; - cv::mixChannels(&src, 1, &tmp, 1, pairs, 1); - src = tmp; - } - if( binary ) - { - cv::Mat tmp(tileSize, CV_8U, nzbuf); - cv::compare( src, 0, tmp, CV_CMP_NE ); + if( coi > 0 ) + { + cv::Mat tmp(tileSize, depth, buf); + int pairs[] = {coi-1, 0}; + cv::mixChannels(&src, 1, &tmp, 1, pairs, 1); src = tmp; - } - - double mom[10]; - func( src, mom ); + } + if( binary ) + { + cv::Mat tmp(tileSize, CV_8U, nzbuf); + cv::compare( src, 0, tmp, CV_CMP_NE ); + src = tmp; + } + + double mom[10]; + func( src, mom ); if(binary) { @@ -423,10 +423,10 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary ) for( int k = 0; k < 10; k++ ) mom[k] *= s; } - + double xm = x * mom[0], ym = y * mom[0]; - // accumulate moments computed in each tile + // accumulate moments computed in each tile // + m00 ( = m00' ) moments->m00 += mom[0]; @@ -460,7 +460,7 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary ) } } - icvCompleteMomentState( moments ); + icvCompleteMomentState( moments ); } @@ -526,7 +526,7 @@ CV_IMPL double cvGetCentralMoment( CvMoments * moments, int x_order, int y_order CV_Error( CV_StsOutOfRange, "" ); return order >= 2 ? (&(moments->m00))[4 + order * 3 + y_order] : - order == 0 ? moments->m00 : 0; + order == 0 ? moments->m00 : 0; } @@ -640,5 +640,12 @@ void cv::HuMoments( const Moments& m, double hu[7] ) hu[6] = q1 * t0 - q0 * t1; } +void cv::HuMoments( const Moments& m, OutputArray _hu ) +{ + _hu.create(7, 1, CV_64F); + Mat hu = _hu.getMat(); + CV_Assert( hu.isContinuous() ); + HuMoments(m, (double*)hu.data); +} /* End of file. */ diff --git a/modules/python/CMakeLists.txt b/modules/python/CMakeLists.txt index 0251e7a29..196c99f9e 100644 --- a/modules/python/CMakeLists.txt +++ b/modules/python/CMakeLists.txt @@ -31,8 +31,7 @@ set(opencv_hdrs "${OpenCV_SOURCE_DIR}/modules/core/include/opencv2/core/core.hpp "${OpenCV_SOURCE_DIR}/modules/ml/include/opencv2/ml/ml.hpp" "${OpenCV_SOURCE_DIR}/modules/features2d/include/opencv2/features2d/features2d.hpp" "${OpenCV_SOURCE_DIR}/modules/calib3d/include/opencv2/calib3d/calib3d.hpp" - "${OpenCV_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp" - "${OpenCV_SOURCE_DIR}/modules/python/src2/opencv_extra_api.hpp") + "${OpenCV_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp") if(MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3") @@ -62,7 +61,7 @@ add_custom_command( DEPENDS ${opencv_hdrs}) set(cv2_target "opencv_python") -add_library(${cv2_target} SHARED src2/cv2.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated0.i src2/opencv_extra_api.hpp ${cv2_generated_hdrs} src2/cv2.cv.hpp) +add_library(${cv2_target} SHARED src2/cv2.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated0.i ${cv2_generated_hdrs} src2/cv2.cv.hpp) target_link_libraries(${cv2_target} ${PYTHON_LIBRARIES} opencv_core opencv_flann opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib) set_target_properties(${cv2_target} PROPERTIES PREFIX "") diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp index 2c8565c72..4faa6878d 100644 --- a/modules/python/src2/cv2.cpp +++ b/modules/python/src2/cv2.cpp @@ -18,7 +18,6 @@ #include "opencv2/video/tracking.hpp" #include "opencv2/video/background_segm.hpp" #include "opencv2/highgui/highgui.hpp" -#include "opencv_extra_api.hpp" using cv::flann::IndexParams; using cv::flann::SearchParams; @@ -356,6 +355,11 @@ static bool pyopencv_to(PyObject* obj, float& value, const char* name = " -static inline void mv2vv(const vector& src, vector >& dst) -{ - size_t i, n = src.size(); - dst.resize(src.size()); - for( i = 0; i < n; i++ ) - src[i].copyTo(dst[i]); -} - -///////////////////////////// core ///////////////////////////// - -CV_WRAP_AS(getTickCount) static inline double getTickCount_() -{ - return (double)getTickCount(); -} - -CV_WRAP_AS(getCPUTickCount) static inline double getCPUTickCount_() -{ - return (double)getCPUTickCount(); -} - -CV_WRAP void randShuffle(const Mat& src, CV_OUT Mat& dst, double iterFactor=1.) -{ - src.copyTo(dst); - randShuffle(dst, iterFactor, 0); -} - -CV_WRAP static inline void SVDecomp(const Mat& src, CV_OUT Mat& w, CV_OUT Mat& u, CV_OUT Mat& vt, int flags=0 ) -{ - SVD::compute(src, w, u, vt, flags); -} - -CV_WRAP static inline void SVBackSubst( const Mat& w, const Mat& u, const Mat& vt, - const Mat& rhs, CV_OUT Mat& dst ) -{ - SVD::backSubst(w, u, vt, rhs, dst); -} - -CV_WRAP static inline void mixChannels(const vector& src, vector& dst, - const vector& fromTo) -{ - if(fromTo.empty()) - return; - CV_Assert(fromTo.size()%2 == 0); - mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), &fromTo[0], (int)(fromTo.size()/2)); -} - -CV_WRAP static inline bool eigen(const Mat& src, bool computeEigenvectors, - CV_OUT Mat& eigenvalues, CV_OUT Mat& eigenvectors, - int lowindex=-1, int highindex=-1) -{ - return computeEigenvectors ? eigen(src, eigenvalues, eigenvectors, lowindex, highindex) : - eigen(src, eigenvalues, lowindex, highindex); -} - -CV_WRAP static inline void fillConvexPoly(Mat& img, const Mat& points, - const Scalar& color, int lineType=8, - int shift=0) -{ - CV_Assert(points.checkVector(2, CV_32S) >= 0); - fillConvexPoly(img, (const Point*)points.data, points.rows*points.cols*points.channels()/2, color, lineType, shift); -} - -CV_WRAP static inline void fillPoly(Mat& img, const vector& pts, - const Scalar& color, int lineType=8, int shift=0, - Point offset=Point() ) -{ - if( pts.empty() ) - return; - AutoBuffer _ptsptr(pts.size()); - AutoBuffer _npts(pts.size()); - Point** ptsptr = _ptsptr; - int* npts = _npts; - - for( size_t i = 0; i < pts.size(); i++ ) - { - const Mat& p = pts[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)pts.size(), color, lineType, shift, offset); -} - -CV_WRAP static inline void polylines(Mat& img, const vector& pts, - bool isClosed, const Scalar& color, - int thickness=1, int lineType=8, int shift=0 ) -{ - if( pts.empty() ) - return; - AutoBuffer _ptsptr(pts.size()); - AutoBuffer _npts(pts.size()); - Point** ptsptr = _ptsptr; - int* npts = _npts; - - for( size_t i = 0; i < pts.size(); i++ ) - { - const Mat& p = pts[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)pts.size(), isClosed, color, thickness, lineType, shift); -} - -CV_WRAP static inline void PCACompute(const Mat& data, CV_OUT Mat& mean, - CV_OUT Mat& eigenvectors, int maxComponents=0) -{ - PCA pca; - pca.mean = mean; - pca.eigenvectors = eigenvectors; - pca(data, Mat(), 0, maxComponents); - pca.mean.copyTo(mean); - pca.eigenvectors.copyTo(eigenvectors); -} - -CV_WRAP static inline void PCAProject(const Mat& data, const Mat& mean, - const Mat& eigenvectors, CV_OUT Mat& result) -{ - PCA pca; - pca.mean = mean; - pca.eigenvectors = eigenvectors; - pca.project(data, result); -} - -CV_WRAP static inline void PCABackProject(const Mat& data, const Mat& mean, - const Mat& eigenvectors, CV_OUT Mat& result) -{ - PCA pca; - pca.mean = mean; - pca.eigenvectors = eigenvectors; - pca.backProject(data, result); -} - -/////////////////////////// imgproc ///////////////////////////////// - -CV_WRAP static inline void HuMoments(const Moments& m, CV_OUT vector& hu) -{ - hu.resize(7); - HuMoments(m, &hu[0]); -} - -CV_WRAP static inline Mat getPerspectiveTransform(const vector& src, const vector& dst) -{ - CV_Assert(src.size() == 4 && dst.size() == 4); - return getPerspectiveTransform(&src[0], &dst[0]); -} - -CV_WRAP static inline Mat getAffineTransform(const vector& src, const vector& dst) -{ - CV_Assert(src.size() == 3 && dst.size() == 3); - return getAffineTransform(&src[0], &dst[0]); -} - -CV_WRAP static inline void calcHist( const vector& images, const vector& channels, - const Mat& mask, CV_OUT Mat& hist, - const vector& histSize, - const vector& ranges, - bool accumulate=false) -{ - int i, dims = (int)histSize.size(), rsz = (int)ranges.size(), csz = (int)channels.size(); - CV_Assert(images.size() > 0 && dims > 0); - CV_Assert(rsz == dims*2 || (rsz == 0 && images[0].depth() == CV_8U)); - CV_Assert(csz == 0 || csz == dims); - float* _ranges[CV_MAX_DIM]; - if( rsz > 0 ) - { - for( i = 0; i < rsz/2; i++ ) - _ranges[i] = (float*)&ranges[i*2]; - } - calcHist(&images[0], (int)images.size(), csz ? &channels[0] : 0, - mask, hist, dims, &histSize[0], rsz ? (const float**)_ranges : 0, - true, accumulate); -} - - -CV_WRAP void calcBackProject( const vector& images, const vector& channels, - const Mat& hist, CV_OUT Mat& dst, - const vector& ranges, - double scale=1 ) -{ - int i, dims = hist.dims, rsz = (int)ranges.size(), csz = (int)channels.size(); - CV_Assert(images.size() > 0); - CV_Assert(rsz == dims*2 || (rsz == 0 && images[0].depth() == CV_8U)); - CV_Assert(csz == 0 || csz == dims); - float* _ranges[CV_MAX_DIM]; - if( rsz > 0 ) - { - for( i = 0; i < rsz/2; i++ ) - _ranges[i] = (float*)&ranges[i*2]; - } - calcBackProject(&images[0], (int)images.size(), csz ? &channels[0] : 0, - hist, dst, rsz ? (const float**)_ranges : 0, scale, true); -} - - -/////////////////////////////// calib3d /////////////////////////////////////////// - -//! finds circles' grid pattern of the specified size in the image -CV_WRAP static inline void findCirclesGridDefault( InputArray image, Size patternSize, - OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID ) -{ - findCirclesGrid(image, patternSize, centers, flags); -} - -} - -#endif