generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

replaced "const InputArray&" => "InputArray"; made InputArray and OutputArray references. added "None()" constant (no array()).

Browse Source
This commit is contained in:
Vadim Pisarevsky
2011-06-06 14:51:27 +00:00
parent 6dc7ae0ff6
commit 0c877f62e9
68 changed files with 757 additions and 750 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
modules/imgproc/src/accum.cpp
View File

@@ -350,7 +350,7 @@ inline int getAccTabIdx(int sdepth, int ddepth)
}
void cv::accumulate( const InputArray& _src, InputOutputArray _dst, const InputArray& _mask )
void cv::accumulate( InputArray _src, InputOutputArray _dst, InputArray _mask )
{
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
int sdepth = src.depth(), ddepth = dst.depth(), cn = src.channels();
@@ -374,7 +374,7 @@ void cv::accumulate( const InputArray& _src, InputOutputArray _dst, const InputA
}
void cv::accumulateSquare( const InputArray& _src, InputOutputArray _dst, const InputArray& _mask )
void cv::accumulateSquare( InputArray _src, InputOutputArray _dst, InputArray _mask )
{
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
int sdepth = src.depth(), ddepth = dst.depth(), cn = src.channels();
@@ -397,8 +397,8 @@ void cv::accumulateSquare( const InputArray& _src, InputOutputArray _dst, const
func(ptrs[0], ptrs[1], ptrs[2], len, cn);
}
void cv::accumulateProduct( const InputArray& _src1, const InputArray& _src2,
InputOutputArray _dst, const InputArray& _mask )
void cv::accumulateProduct( InputArray _src1, InputArray _src2,
InputOutputArray _dst, InputArray _mask )
{
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
int sdepth = src1.depth(), ddepth = dst.depth(), cn = src1.channels();
@@ -423,8 +423,8 @@ void cv::accumulateProduct( const InputArray& _src1, const InputArray& _src2,
}
void cv::accumulateWeighted( const InputArray& _src, CV_IN_OUT InputOutputArray _dst,
double alpha, const InputArray& _mask )
void cv::accumulateWeighted( InputArray _src, CV_IN_OUT InputOutputArray _dst,
double alpha, InputArray _mask )
{
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
int sdepth = src.depth(), ddepth = dst.depth(), cn = src.channels();

2
modules/imgproc/src/canny.cpp
View File

@@ -335,7 +335,7 @@ CV_IMPL void cvCanny( const void* srcarr, void* dstarr,
}
}
void cv::Canny( const InputArray& image, OutputArray _edges,
void cv::Canny( InputArray image, OutputArray _edges,
double threshold1, double threshold2,
int apertureSize, bool L2gradient )
{

2
modules/imgproc/src/color.cpp
View File

@@ -2774,7 +2774,7 @@ struct YUV420i2BGRA8888Invoker
// The main function //
//////////////////////////////////////////////////////////////////////////////////////////
void cv::cvtColor( const InputArray& _src, OutputArray _dst, int code, int dcn )
void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
{
Mat src = _src.getMat(), dst;
Size sz = src.size();

34
modules/imgproc/src/contours.cpp
View File

@@ -1519,13 +1519,13 @@ void cv::findContours( const InputOutputArray _image, OutputArrayOfArrays _conto
void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
int mode, int method, Point offset)
{
findContours(_image, _contours, OutputArrayOfArrays(), mode, method, offset);
findContours(_image, _contours, None(), mode, method, offset);
}
namespace cv
{
static void addChildContour(const InputArrayOfArrays& contours,
static void addChildContour(InputArrayOfArrays contours,
size_t ncontours,
const Vec4i* hierarchy,
int i, vector<CvSeq>& seq,
@@ -1552,9 +1552,9 @@ static void addChildContour(const InputArrayOfArrays& contours,
}
void cv::drawContours( InputOutputArray _image, const InputArrayOfArrays& _contours,
void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours,
int contourIdx, const Scalar& color, int thickness,
int lineType, const InputArray& _hierarchy,
int lineType, InputArray _hierarchy,
int maxLevel, Point offset )
{
Mat image = _image.getMat(), hierarchy = _hierarchy.getMat();
@@ -1632,7 +1632,7 @@ void cv::drawContours( InputOutputArray _image, const InputArrayOfArrays& _conto
}
void cv::approxPolyDP( const InputArray& _curve, OutputArray _approxCurve,
void cv::approxPolyDP( InputArray _curve, OutputArray _approxCurve,
double epsilon, bool closed )
{
Mat curve = _curve.getMat();
@@ -1649,7 +1649,7 @@ void cv::approxPolyDP( const InputArray& _curve, OutputArray _approxCurve,
}
double cv::arcLength( const InputArray& _curve, bool closed )
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));
@@ -1658,7 +1658,7 @@ double cv::arcLength( const InputArray& _curve, bool closed )
}
cv::Rect cv::boundingRect( const InputArray& _points )
cv::Rect cv::boundingRect( InputArray _points )
{
Mat points = _points.getMat();
CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
@@ -1667,7 +1667,7 @@ cv::Rect cv::boundingRect( const InputArray& _points )
}
double cv::contourArea( const InputArray& _contour, bool oriented )
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));
@@ -1676,7 +1676,7 @@ double cv::contourArea( const InputArray& _contour, bool oriented )
}
cv::RotatedRect cv::minAreaRect( const InputArray& _points )
cv::RotatedRect cv::minAreaRect( InputArray _points )
{
Mat points = _points.getMat();
CV_Assert(points.checkVector(2) >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
@@ -1685,7 +1685,7 @@ cv::RotatedRect cv::minAreaRect( const InputArray& _points )
}
void cv::minEnclosingCircle( const InputArray& _points,
void cv::minEnclosingCircle( InputArray _points,
Point2f& center, float& radius )
{
Mat points = _points.getMat();
@@ -1695,8 +1695,8 @@ void cv::minEnclosingCircle( const InputArray& _points,
}
double cv::matchShapes( const InputArray& _contour1,
const InputArray& _contour2,
double cv::matchShapes( InputArray _contour1,
InputArray _contour2,
int method, double parameter )
{
Mat contour1 = _contour1.getMat(), contour2 = _contour2.getMat();
@@ -1709,7 +1709,7 @@ double cv::matchShapes( const InputArray& _contour1,
}
void cv::convexHull( const InputArray& _points, OutputArray _hull, bool clockwise, bool returnPoints )
void cv::convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints )
{
Mat points = _points.getMat();
int nelems = points.checkVector(2), depth = points.depth();
@@ -1730,7 +1730,7 @@ void cv::convexHull( const InputArray& _points, OutputArray _hull, bool clockwis
shull.copyTo(dhull);
}
bool cv::isContourConvex( const InputArray& _contour )
bool cv::isContourConvex( InputArray _contour )
{
Mat contour = _contour.getMat();
CV_Assert(contour.checkVector(2) >= 0 &&
@@ -1739,7 +1739,7 @@ bool cv::isContourConvex( const InputArray& _contour )
return cvCheckContourConvexity(&c) > 0;
}
cv::RotatedRect cv::fitEllipse( const InputArray& _points )
cv::RotatedRect cv::fitEllipse( InputArray _points )
{
Mat points = _points.getMat();
CV_Assert(points.checkVector(2) >= 0 &&
@@ -1749,7 +1749,7 @@ cv::RotatedRect cv::fitEllipse( const InputArray& _points )
}
void cv::fitLine( const InputArray& _points, OutputArray _line, int distType,
void cv::fitLine( InputArray _points, OutputArray _line, int distType,
double param, double reps, double aeps )
{
Mat points = _points.getMat();
@@ -1767,7 +1767,7 @@ void cv::fitLine( const InputArray& _points, OutputArray _line, int distType,
}
double cv::pointPolygonTest( const InputArray& _contour,
double cv::pointPolygonTest( InputArray _contour,
Point2f pt, bool measureDist )
{
Mat contour = _contour.getMat();

8
modules/imgproc/src/corner.cpp
View File

@@ -299,7 +299,7 @@ cornerEigenValsVecs( const Mat& src, Mat& eigenv, int block_size,
}
void cv::cornerMinEigenVal( const InputArray& _src, OutputArray _dst, int blockSize, int ksize, int borderType )
void cv::cornerMinEigenVal( InputArray _src, OutputArray _dst, int blockSize, int ksize, int borderType )
{
Mat src = _src.getMat();
_dst.create( src.size(), CV_32F );
@@ -308,7 +308,7 @@ void cv::cornerMinEigenVal( const InputArray& _src, OutputArray _dst, int blockS
}
void cv::cornerHarris( const InputArray& _src, OutputArray _dst, int blockSize, int ksize, double k, int borderType )
void cv::cornerHarris( InputArray _src, OutputArray _dst, int blockSize, int ksize, double k, int borderType )
{
Mat src = _src.getMat();
_dst.create( src.size(), CV_32F );
@@ -317,7 +317,7 @@ void cv::cornerHarris( const InputArray& _src, OutputArray _dst, int blockSize,
}
void cv::cornerEigenValsAndVecs( const InputArray& _src, OutputArray _dst, int blockSize, int ksize, int borderType )
void cv::cornerEigenValsAndVecs( InputArray _src, OutputArray _dst, int blockSize, int ksize, int borderType )
{
Mat src = _src.getMat();
Size dsz = _dst.size();
@@ -330,7 +330,7 @@ void cv::cornerEigenValsAndVecs( const InputArray& _src, OutputArray _dst, int b
}
void cv::preCornerDetect( const InputArray& _src, OutputArray _dst, int ksize, int borderType )
void cv::preCornerDetect( InputArray _src, OutputArray _dst, int ksize, int borderType )
{
Mat Dx, Dy, D2x, D2y, Dxy, src = _src.getMat();

2
modules/imgproc/src/cornersubpix.cpp
View File

@@ -254,7 +254,7 @@ cvFindCornerSubPix( const void* srcarr, CvPoint2D32f* corners,
}
}
void cv::cornerSubPix( const InputArray& _image, InputOutputArray _corners,
void cv::cornerSubPix( InputArray _image, InputOutputArray _corners,
Size winSize, Size zeroZone,
TermCriteria criteria )
{

6
modules/imgproc/src/deriv.cpp
View File

@@ -470,7 +470,7 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k
#endif
void cv::Sobel( const InputArray& _src, OutputArray _dst, int ddepth, int dx, int dy,
void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
int ksize, double scale, double delta, int borderType )
{
Mat src = _src.getMat();
@@ -503,7 +503,7 @@ void cv::Sobel( const InputArray& _src, OutputArray _dst, int ddepth, int dx, in
}
void cv::Scharr( const InputArray& _src, OutputArray _dst, int ddepth, int dx, int dy,
void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
double scale, double delta, int borderType )
{
Mat src = _src.getMat();
@@ -536,7 +536,7 @@ void cv::Scharr( const InputArray& _src, OutputArray _dst, int ddepth, int dx, i
}
void cv::Laplacian( const InputArray& _src, OutputArray _dst, int ddepth, int ksize,
void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
double scale, double delta, int borderType )
{
Mat src = _src.getMat();

4
modules/imgproc/src/distransform.cpp
View File

@@ -850,7 +850,7 @@ cvDistTransform( const void* srcarr, void* dstarr,
}
}
void cv::distanceTransform( const InputArray& _src, OutputArray _dst, OutputArray _labels,
void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labels,
int distanceType, int maskSize )
{
Mat src = _src.getMat();
@@ -860,7 +860,7 @@ void cv::distanceTransform( const InputArray& _src, OutputArray _dst, OutputArra
cvDistTransform(&c_src, &c_dst, distanceType, maskSize, 0, &c_labels);
}
void cv::distanceTransform( const InputArray& _src, OutputArray _dst,
void cv::distanceTransform( InputArray _src, OutputArray _dst,
int distanceType, int maskSize )
{
Mat src = _src.getMat();

4
modules/imgproc/src/emd.cpp
View File

@@ -1138,8 +1138,8 @@ icvDistC( const float *x, const float *y, void *user_param )
}
float cv::EMD( const InputArray& _signature1, const InputArray& _signature2,
int distType, const InputArray& _cost,
float cv::EMD( InputArray _signature1, InputArray _signature2,
int distType, InputArray _cost,
float* lowerBound, OutputArray _flow )
{
Mat signature1 = _signature1.getMat(), signature2 = _signature2.getMat();

4
modules/imgproc/src/featureselect.cpp
View File

@@ -52,9 +52,9 @@ template<typename T> struct greaterThanPtr
}
void cv::goodFeaturesToTrack( const InputArray& _image, OutputArray _corners,
void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
int maxCorners, double qualityLevel, double minDistance,
const InputArray& _mask, int blockSize,
InputArray _mask, int blockSize,
bool useHarrisDetector, double harrisK )
{
Mat image = _image.getMat(), mask = _mask.getMat();

20
modules/imgproc/src/filter.cpp
View File

@@ -453,7 +453,7 @@ void FilterEngine::apply(const Mat& src, Mat& dst,
* Separable linear filter *
\****************************************************************************************/
int cv::getKernelType(const InputArray& filter_kernel, Point anchor)
int cv::getKernelType(InputArray filter_kernel, Point anchor)
{
Mat _kernel = filter_kernel.getMat();
CV_Assert( _kernel.channels() == 1 );
@@ -2528,7 +2528,7 @@ template<typename ST, typename DT> struct FixedPtCastEx
}
cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType,
const InputArray& _kernel, int anchor,
InputArray _kernel, int anchor,
int symmetryType )
{
Mat kernel = _kernel.getMat();
@@ -2579,7 +2579,7 @@ cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType,
cv::Ptr<cv::BaseColumnFilter> cv::getLinearColumnFilter( int bufType, int dstType,
const InputArray& _kernel, int anchor,
InputArray _kernel, int anchor,
int symmetryType, double delta,
int bits )
{
@@ -2676,7 +2676,7 @@ cv::Ptr<cv::BaseColumnFilter> cv::getLinearColumnFilter( int bufType, int dstTyp
cv::Ptr<cv::FilterEngine> cv::createSeparableLinearFilter(
int _srcType, int _dstType,
const InputArray& __rowKernel, const InputArray& __columnKernel,
InputArray __rowKernel, InputArray __columnKernel,
Point _anchor, double _delta,
int _rowBorderType, int _columnBorderType,
const Scalar& _borderValue )
@@ -2877,7 +2877,7 @@ template<typename ST, class CastOp, class VecOp> struct Filter2D : public BaseFi
}
cv::Ptr<cv::BaseFilter> cv::getLinearFilter(int srcType, int dstType,
const InputArray& filter_kernel, Point anchor,
InputArray filter_kernel, Point anchor,
double delta, int bits)
{
Mat _kernel = filter_kernel.getMat();
@@ -2955,7 +2955,7 @@ cv::Ptr<cv::BaseFilter> cv::getLinearFilter(int srcType, int dstType,
cv::Ptr<cv::FilterEngine> cv::createLinearFilter( int _srcType, int _dstType,
const InputArray& filter_kernel,
InputArray filter_kernel,
Point _anchor, double _delta,
int _rowBorderType, int _columnBorderType,
const Scalar& _borderValue )
@@ -2987,8 +2987,8 @@ cv::Ptr<cv::FilterEngine> cv::createLinearFilter( int _srcType, int _dstType,
}
void cv::filter2D( const InputArray& _src, OutputArray _dst, int ddepth,
const InputArray& _kernel, Point anchor,
void cv::filter2D( InputArray _src, OutputArray _dst, int ddepth,
InputArray _kernel, Point anchor,
double delta, int borderType )
{
Mat src = _src.getMat(), kernel = _kernel.getMat();
@@ -3028,8 +3028,8 @@ void cv::filter2D( const InputArray& _src, OutputArray _dst, int ddepth,
}
void cv::sepFilter2D( const InputArray& _src, OutputArray _dst, int ddepth,
const InputArray& _kernelX, const InputArray& _kernelY, Point anchor,
void cv::sepFilter2D( InputArray _src, OutputArray _dst, int ddepth,
InputArray _kernelX, InputArray _kernelY, Point anchor,
double delta, int borderType )
{
Mat src = _src.getMat(), kernelX = _kernelX.getMat(), kernelY = _kernelY.getMat();

2
modules/imgproc/src/grabcut.cpp
View File

@@ -525,7 +525,7 @@ void estimateSegmentation( GCGraph<double>& graph, Mat& mask )
}
}
void cv::grabCut( const InputArray& _img, InputOutputArray _mask, Rect rect,
void cv::grabCut( InputArray _img, InputOutputArray _mask, Rect rect,
InputOutputArray _bgdModel, InputOutputArray _fgdModel,
int iterCount, int mode )
{

10
modules/imgproc/src/histogram.cpp
View File

@@ -593,7 +593,7 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
}
void cv::calcHist( const Mat* images, int nimages, const int* channels,
const InputArray& _mask, OutputArray _hist, int dims, const int* histSize,
InputArray _mask, OutputArray _hist, int dims, const int* histSize,
const float** ranges, bool uniform, bool accumulate )
{
Mat mask = _mask.getMat();
@@ -816,7 +816,7 @@ static void calcHist( const Mat* images, int nimages, const int* channels,
}
void cv::calcHist( const Mat* images, int nimages, const int* channels,
const InputArray& _mask, SparseMat& hist, int dims, const int* histSize,
InputArray _mask, SparseMat& hist, int dims, const int* histSize,
const float** ranges, bool uniform, bool accumulate )
{
Mat mask = _mask.getMat();
@@ -1120,7 +1120,7 @@ calcBackProj_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
}
void cv::calcBackProject( const Mat* images, int nimages, const int* channels,
const InputArray& _hist, OutputArray _backProject,
InputArray _hist, OutputArray _backProject,
const float** ranges, double scale, bool uniform )
{
Mat hist = _hist.getMat();
@@ -1316,7 +1316,7 @@ void cv::calcBackProject( const Mat* images, int nimages, const int* channels,
////////////////// C O M P A R E H I S T O G R A M S ////////////////////////
double cv::compareHist( const InputArray& _H1, const InputArray& _H2, int method )
double cv::compareHist( InputArray _H1, InputArray _H2, int method )
{
Mat H1 = _H1.getMat(), H2 = _H2.getMat();
const Mat* arrays[] = {&H1, &H2, 0};
@@ -2409,7 +2409,7 @@ CV_IMPL void cvEqualizeHist( const CvArr* srcarr, CvArr* dstarr )
}
void cv::equalizeHist( const InputArray& _src, OutputArray _dst )
void cv::equalizeHist( InputArray _src, OutputArray _dst )
{
Mat src = _src.getMat();
_dst.create( src.size(), src.type() );

8
modules/imgproc/src/hough.cpp
View File

@@ -1090,7 +1090,7 @@ namespace cv
const int STORAGE_SIZE = 1 << 12;
static void seqToMat(const CvSeq* seq, OutputArray& _arr)
static void seqToMat(const CvSeq* seq, OutputArray _arr)
{
if( seq && seq->total > 0 )
{
@@ -1104,7 +1104,7 @@ static void seqToMat(const CvSeq* seq, OutputArray& _arr)
}
void cv::HoughLines( const InputArray& _image, OutputArray _lines,
void cv::HoughLines( InputArray _image, OutputArray _lines,
double rho, double theta, int threshold,
double srn, double stn )
{
@@ -1117,7 +1117,7 @@ void cv::HoughLines( const InputArray& _image, OutputArray _lines,
seqToMat(seq, _lines);
}
void cv::HoughLinesP( const InputArray& _image, OutputArray _lines,
void cv::HoughLinesP( InputArray _image, OutputArray _lines,
double rho, double theta, int threshold,
double minLineLength, double maxGap )
{
@@ -1129,7 +1129,7 @@ void cv::HoughLinesP( const InputArray& _image, OutputArray _lines,
seqToMat(seq, _lines);
}
void cv::HoughCircles( const InputArray& _image, OutputArray _circles,
void cv::HoughCircles( InputArray _image, OutputArray _circles,
int method, double dp, double min_dist,
double param1, double param2,
int minRadius, int maxRadius )

16
modules/imgproc/src/imgwarp.cpp
View File

@@ -1317,7 +1317,7 @@ typedef void (*ResizeAreaFunc)( const Mat& src, Mat& dst,
//////////////////////////////////////////////////////////////////////////////////////////
void cv::resize( const InputArray& _src, OutputArray _dst, Size dsize,
void cv::resize( InputArray _src, OutputArray _dst, Size dsize,
double inv_scale_x, double inv_scale_y, int interpolation )
{
static ResizeFunc linear_tab[] =
@@ -2401,8 +2401,8 @@ typedef void (*RemapFunc)(const Mat& _src, Mat& _dst, const Mat& _xy,
}
void cv::remap( const InputArray& _src, OutputArray _dst,
const InputArray& _map1, const InputArray& _map2,
void cv::remap( InputArray _src, OutputArray _dst,
InputArray _map1, InputArray _map2,
int interpolation, int borderType, const Scalar& borderValue )
{
static RemapNNFunc nn_tab[] =
@@ -2667,7 +2667,7 @@ void cv::remap( const InputArray& _src, OutputArray _dst,
}
void cv::convertMaps( const InputArray& _map1, const InputArray& _map2,
void cv::convertMaps( InputArray _map1, InputArray _map2,
OutputArray _dstmap1, OutputArray _dstmap2,
int dstm1type, bool nninterpolate )
{
@@ -2806,8 +2806,8 @@ void cv::convertMaps( const InputArray& _map1, const InputArray& _map2,
}
void cv::warpAffine( const InputArray& _src, OutputArray _dst,
const InputArray& _M0, Size dsize,
void cv::warpAffine( InputArray _src, OutputArray _dst,
InputArray _M0, Size dsize,
int flags, int borderType, const Scalar& borderValue )
{
Mat src = _src.getMat(), M0 = _M0.getMat();
@@ -2944,7 +2944,7 @@ void cv::warpAffine( const InputArray& _src, OutputArray _dst,
}
void cv::warpPerspective( const InputArray& _src, OutputArray _dst, const InputArray& _M0,
void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0,
Size dsize, int flags, int borderType, const Scalar& borderValue )
{
Mat src = _src.getMat(), M0 = _M0.getMat();
@@ -3146,7 +3146,7 @@ cv::Mat cv::getAffineTransform( const Point2f src[], const Point2f dst[] )
return M;
}
void cv::invertAffineTransform(const InputArray& _matM, OutputArray __iM)
void cv::invertAffineTransform(InputArray _matM, OutputArray __iM)
{
Mat matM = _matM.getMat();
CV_Assert(matM.rows == 2 && matM.cols == 3);

2
modules/imgproc/src/inpaint.cpp
View File

@@ -807,7 +807,7 @@ cvInpaint( const CvArr* _input_img, const CvArr* _inpaint_mask, CvArr* _output_i
}
}
void cv::inpaint( const InputArray& _src, const InputArray& _mask, OutputArray _dst,
void cv::inpaint( InputArray _src, InputArray _mask, OutputArray _dst,
double inpaintRange, int flags )
{
Mat src = _src.getMat(), mask = _mask.getMat();

2
modules/imgproc/src/moments.cpp
View File

@@ -604,7 +604,7 @@ Moments::operator CvMoments() const
}
cv::Moments cv::moments( const InputArray& _array, bool binaryImage )
cv::Moments cv::moments( InputArray _array, bool binaryImage )
{
CvMoments om;
Mat arr = _array.getMat();

16
modules/imgproc/src/morph.cpp
View File

@@ -909,7 +909,7 @@ cv::Ptr<cv::BaseColumnFilter> cv::getMorphologyColumnFilter(int op, int type, in
}
cv::Ptr<cv::BaseFilter> cv::getMorphologyFilter(int op, int type, const InputArray& _kernel, Point anchor)
cv::Ptr<cv::BaseFilter> cv::getMorphologyFilter(int op, int type, InputArray _kernel, Point anchor)
{
Mat kernel = _kernel.getMat();
int depth = CV_MAT_DEPTH(type);
@@ -943,7 +943,7 @@ cv::Ptr<cv::BaseFilter> cv::getMorphologyFilter(int op, int type, const InputArr
}
cv::Ptr<cv::FilterEngine> cv::createMorphologyFilter( int op, int type, const InputArray& _kernel,
cv::Ptr<cv::FilterEngine> cv::createMorphologyFilter( int op, int type, InputArray _kernel,
Point anchor, int _rowBorderType, int _columnBorderType,
const Scalar& _borderValue )
{
@@ -1038,8 +1038,8 @@ cv::Mat cv::getStructuringElement(int shape, Size ksize, Point anchor)
namespace cv
{
static void morphOp( int op, const InputArray& _src, OutputArray& _dst,
const InputArray& _kernel,
static void morphOp( int op, InputArray _src, OutputArray _dst,
InputArray _kernel,
Point anchor, int iterations,
int borderType, const Scalar& borderValue )
{
@@ -1087,7 +1087,7 @@ template<> void Ptr<IplConvKernel>::delete_obj()
}
void cv::erode( const InputArray& src, OutputArray dst, const InputArray& kernel,
void cv::erode( InputArray src, OutputArray dst, InputArray kernel,
Point anchor, int iterations,
int borderType, const Scalar& borderValue )
{
@@ -1095,7 +1095,7 @@ void cv::erode( const InputArray& src, OutputArray dst, const InputArray& kernel
}
void cv::dilate( const InputArray& src, OutputArray dst, const InputArray& kernel,
void cv::dilate( InputArray src, OutputArray dst, InputArray kernel,
Point anchor, int iterations,
int borderType, const Scalar& borderValue )
{
@@ -1103,8 +1103,8 @@ void cv::dilate( const InputArray& src, OutputArray dst, const InputArray& kerne
}
void cv::morphologyEx( const InputArray& _src, OutputArray _dst, int op,
const InputArray& kernel, Point anchor, int iterations,
void cv::morphologyEx( InputArray _src, OutputArray _dst, int op,
InputArray kernel, Point anchor, int iterations,
int borderType, const Scalar& borderValue )
{
Mat src = _src.getMat(), temp;

6
modules/imgproc/src/pyramids.cpp
View File

@@ -401,7 +401,7 @@ typedef void (*PyrFunc)(const Mat&, Mat&);
}
void cv::pyrDown( const InputArray& _src, OutputArray _dst, const Size& _dsz )
void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz )
{
Mat src = _src.getMat();
Size dsz = _dsz == Size() ? Size((src.cols + 1)/2, (src.rows + 1)/2) : _dsz;
@@ -425,7 +425,7 @@ void cv::pyrDown( const InputArray& _src, OutputArray _dst, const Size& _dsz )
func( src, dst );
}
void cv::pyrUp( const InputArray& _src, OutputArray _dst, const Size& _dsz )
void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz )
{
Mat src = _src.getMat();
Size dsz = _dsz == Size() ? Size(src.cols*2, src.rows*2) : _dsz;
@@ -449,7 +449,7 @@ void cv::pyrUp( const InputArray& _src, OutputArray _dst, const Size& _dsz )
func( src, dst );
}
void cv::buildPyramid( const InputArray& _src, OutputArrayOfArrays _dst, int maxlevel )
void cv::buildPyramid( InputArray _src, OutputArrayOfArrays _dst, int maxlevel )
{
Mat src = _src.getMat();
_dst.create( maxlevel + 1, 1, 0 );

2
modules/imgproc/src/samplers.cpp
View File

@@ -868,7 +868,7 @@ cvGetQuadrangleSubPix( const void* srcarr, void* dstarr, const CvMat* mat )
}
void cv::getRectSubPix( const InputArray& _image, Size patchSize, Point2f center,
void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center,
OutputArray _patch, int patchType )
{
Mat image = _image.getMat();

4
modules/imgproc/src/segmentation.cpp
View File

@@ -303,7 +303,7 @@ cvWatershed( const CvArr* srcarr, CvArr* dstarr )
}
void cv::watershed( const InputArray& _src, InputOutputArray markers )
void cv::watershed( InputArray _src, InputOutputArray markers )
{
Mat src = _src.getMat();
CvMat c_src = _src.getMat(), c_markers = markers.getMat();
@@ -526,7 +526,7 @@ cvPyrMeanShiftFiltering( const CvArr* srcarr, CvArr* dstarr,
delete[] dst_pyramid;
}
void cv::pyrMeanShiftFiltering( const InputArray& _src, OutputArray _dst,
void cv::pyrMeanShiftFiltering( InputArray _src, OutputArray _dst,
double sp, double sr, int maxLevel,
TermCriteria termcrit )
{

10
modules/imgproc/src/smooth.cpp
View File

@@ -294,7 +294,7 @@ cv::Ptr<cv::FilterEngine> cv::createBoxFilter( int srcType, int dstType, Size ks
}
void cv::boxFilter( const InputArray& _src, OutputArray _dst, int ddepth,
void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
Size ksize, Point anchor,
bool normalize, int borderType )
{
@@ -316,7 +316,7 @@ void cv::boxFilter( const InputArray& _src, OutputArray _dst, int ddepth,
f->apply( src, dst );
}
void cv::blur( const InputArray& src, OutputArray dst,
void cv::blur( InputArray src, OutputArray dst,
Size ksize, Point anchor, int borderType )
{
boxFilter( src, dst, -1, ksize, anchor, true, borderType );
@@ -410,7 +410,7 @@ cv::Ptr<cv::FilterEngine> cv::createGaussianFilter( int type, Size ksize,
}
void cv::GaussianBlur( const InputArray& _src, OutputArray _dst, Size ksize,
void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
double sigma1, double sigma2,
int borderType )
{
@@ -1219,7 +1219,7 @@ medianBlur_SortNet( const Mat& _src, Mat& _dst, int m )
}
void cv::medianBlur( const InputArray& _src0, OutputArray _dst, int ksize )
void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
{
Mat src0 = _src0.getMat();
_dst.create( src0.size(), src0.type() );
@@ -1518,7 +1518,7 @@ bilateralFilter_32f( const Mat& src, Mat& dst, int d,
}
void cv::bilateralFilter( const InputArray& _src, OutputArray _dst, int d,
void cv::bilateralFilter( InputArray _src, OutputArray _dst, int d,
double sigmaColor, double sigmaSpace,
int borderType )
{

14
modules/imgproc/src/sumpixels.cpp
View File

@@ -225,7 +225,7 @@ typedef void (*IntegralFunc)(const uchar* src, size_t srcstep, uchar* sum, size_
}
void cv::integral( const InputArray& _src, OutputArray _sum, OutputArray _sqsum, OutputArray _tilted, int sdepth )
void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, OutputArray _tilted, int sdepth )
{
Mat src = _src.getMat(), sum, sqsum, tilted;
int depth = src.depth(), cn = src.channels();
@@ -270,14 +270,14 @@ void cv::integral( const InputArray& _src, OutputArray _sum, OutputArray _sqsum,
tilted.data, tilted.step, src.size(), cn );
}
void cv::integral( const InputArray& src, OutputArray sum, int sdepth )
void cv::integral( InputArray src, OutputArray sum, int sdepth )
{
integral( src, sum, OutputArray(), OutputArray(), sdepth );
integral( src, sum, None(), None(), sdepth );
}
void cv::integral( const InputArray& src, OutputArray sum, OutputArray sqsum, int sdepth )
void cv::integral( InputArray src, OutputArray sum, OutputArray sqsum, int sdepth )
{
integral( src, sum, sqsum, OutputArray(), sdepth );
integral( src, sum, sqsum, None(), sdepth );
}
@@ -300,8 +300,8 @@ cvIntegral( const CvArr* image, CvArr* sumImage,
tilted0 = tilted = cv::cvarrToMat(tiltedSumImage);
ptilted = &tilted;
}
cv::integral( src, sum, psqsum ? cv::OutputArray(*psqsum) : cv::OutputArray(),
ptilted ? cv::OutputArray(*ptilted) : cv::OutputArray(), sum.depth() );
cv::integral( src, sum, psqsum ? cv::_OutputArray(*psqsum) : cv::_OutputArray(),
ptilted ? cv::_OutputArray(*ptilted) : cv::_OutputArray(), sum.depth() );
CV_Assert( sum.data == sum0.data && sqsum.data == sqsum0.data && tilted.data == tilted0.data );
}

2
modules/imgproc/src/templmatch.cpp
View File

@@ -232,7 +232,7 @@ cv::crossCorr( const Mat& img, const Mat& templ, Mat& corr,
/*****************************************************************************************/
void cv::matchTemplate( const InputArray& _img, const InputArray& _templ, OutputArray _result, int method )
void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result, int method )
{
CV_Assert( CV_TM_SQDIFF <= method && method <= CV_TM_CCOEFF_NORMED );

4
modules/imgproc/src/thresh.cpp
View File

@@ -498,7 +498,7 @@ getThreshVal_Otsu_8u( const Mat& _src )
}
double cv::threshold( const InputArray& _src, OutputArray _dst, double thresh, double maxval, int type )
double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double maxval, int type )
{
Mat src = _src.getMat();
bool use_otsu = (type & THRESH_OTSU) != 0;
@@ -548,7 +548,7 @@ double cv::threshold( const InputArray& _src, OutputArray _dst, double thresh, d
}
void cv::adaptiveThreshold( const InputArray& _src, OutputArray _dst, double maxValue,
void cv::adaptiveThreshold( InputArray _src, OutputArray _dst, double maxValue,
int method, int type, int blockSize, double delta )
{
Mat src = _src.getMat();

22
modules/imgproc/src/undistort.cpp
View File

@@ -42,7 +42,7 @@
#include "precomp.hpp"
cv::Mat cv::getDefaultNewCameraMatrix( const InputArray& _cameraMatrix, Size imgsize,
cv::Mat cv::getDefaultNewCameraMatrix( InputArray _cameraMatrix, Size imgsize,
bool centerPrincipalPoint )
{
Mat cameraMatrix = _cameraMatrix.getMat();
@@ -59,8 +59,8 @@ cv::Mat cv::getDefaultNewCameraMatrix( const InputArray& _cameraMatrix, Size img
return newCameraMatrix;
}
void cv::initUndistortRectifyMap( const InputArray& _cameraMatrix, const InputArray& _distCoeffs,
const InputArray& _matR, const InputArray& _newCameraMatrix,
void cv::initUndistortRectifyMap( InputArray _cameraMatrix, InputArray _distCoeffs,
InputArray _matR, InputArray _newCameraMatrix,
Size size, int m1type, OutputArray _map1, OutputArray _map2 )
{
Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
@@ -161,8 +161,8 @@ void cv::initUndistortRectifyMap( const InputArray& _cameraMatrix, const InputAr
}
void cv::undistort( const InputArray& _src, OutputArray _dst, const InputArray& _cameraMatrix,
const InputArray& _distCoeffs, const InputArray& _newCameraMatrix )
void cv::undistort( InputArray _src, OutputArray _dst, InputArray _cameraMatrix,
InputArray _distCoeffs, InputArray _newCameraMatrix )
{
Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat();
Mat distCoeffs = _distCoeffs.getMat(), newCameraMatrix = _newCameraMatrix.getMat();
@@ -381,11 +381,11 @@ void cvUndistortPoints( const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatr
}
void cv::undistortPoints( const InputArray& _src, OutputArray _dst,
const InputArray& _cameraMatrix,
const InputArray& _distCoeffs,
const InputArray& _Rmat,
const InputArray& _Pmat )
void cv::undistortPoints( InputArray _src, OutputArray _dst,
InputArray _cameraMatrix,
InputArray _distCoeffs,
InputArray _Rmat,
InputArray _Pmat )
{
Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat();
Mat distCoeffs = _distCoeffs.getMat(), R = _Rmat.getMat(), P = _Pmat.getMat();
@@ -488,7 +488,7 @@ static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType)
}
float cv::initWideAngleProjMap( const InputArray& _cameraMatrix0, const InputArray& _distCoeffs0,
float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeffs0,
Size imageSize, int destImageWidth, int m1type,
OutputArray _map1, OutputArray _map2, int projType, double _alpha )
{

2
modules/imgproc/src/utils.cpp
View File

@@ -197,7 +197,7 @@ static void copyMakeConstBorder_8u( const uchar* src, size_t srcstep, Size srcro
}
void cv::copyMakeBorder( const InputArray& _src, OutputArray _dst, int top, int bottom,
void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
int left, int right, int borderType, const Scalar& value )
{
Mat src = _src.getMat();