From 2d2b8a496eb6fe8740124bbaf69774b760cb8fb8 Mon Sep 17 00:00:00 2001 From: Vadim Pisarevsky Date: Wed, 8 Jun 2011 06:55:04 +0000 Subject: [PATCH] renamed "None()" to "noArray()" to avoid conflicts with X11 (ticket #1122) --- index.rst | 8 ++-- .../camera_calibration_and_3d_reconstruction.rst | 12 +++--- .../calib3d/include/opencv2/calib3d/calib3d.hpp | 34 ++++++++-------- modules/calib3d/src/calibration.cpp | 4 +- modules/core/doc/clustering.rst | 2 +- modules/core/doc/intro.rst | 2 +- modules/core/doc/operations_on_arrays.rst | 28 ++++++------- modules/core/include/opencv2/core/core.hpp | 46 +++++++++++----------- modules/core/src/arithm.cpp | 22 +++++------ modules/core/src/datastructs.cpp | 2 +- modules/core/src/lapack.cpp | 4 +- modules/core/src/matrix.cpp | 2 +- modules/imgproc/doc/feature_detection.rst | 2 +- modules/imgproc/doc/geometric_transformations.rst | 4 +- .../doc/motion_analysis_and_object_tracking.rst | 8 ++-- .../structural_analysis_and_shape_descriptors.rst | 2 +- .../imgproc/include/opencv2/imgproc/imgproc.hpp | 20 +++++----- modules/imgproc/src/contours.cpp | 2 +- modules/imgproc/src/sumpixels.cpp | 4 +- modules/ml/test/test_emknearestkmeans.cpp | 6 +-- modules/python/src2/hdr_parser.py | 2 +- 21 files changed, 108 insertions(+), 108 deletions(-) diff --git a/index.rst b/index.rst index 5b62aa3..bdcbf92 100644 --- a/index.rst +++ b/index.rst @@ -10,10 +10,10 @@ Welcome to opencv documentation! :maxdepth: 2 modules/refman.rst - doc/opencv1/c/c_index.rst - doc/opencv1/py/py_index.rst - doc/user_guide/user_guide.rst - doc/tutorials/tutorials.rst + _doc/opencv1/c/c_index.rst + _doc/opencv1/py/py_index.rst + _doc/user_guide/user_guide.rst + _doc/tutorials/tutorials.rst Indices and tables ================== diff --git a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst index 4656a22..e229b61 100644 --- a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst +++ b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst @@ -221,7 +221,7 @@ The function computes various useful camera characteristics from the previously composeRT ------------- -.. cpp:function:: void composeRT( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=None(), OutputArray dr3dt1=None(), OutputArray dr3dr2=None(), OutputArray dr3dt2=None(), OutputArray dt3dr1=None(), OutputArray dt3dt1=None(), OutputArray dt3dr2=None(), OutputArray dt3dt2=None() ) +.. cpp:function:: void composeRT( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray() ) Combines two rotation-and-shift transformations. @@ -508,7 +508,7 @@ The function estimates the object pose given a set of object points, their corre solvePnPRansac ------------------ -.. cpp:function:: void solvePnPRansac( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount = 100, float reprojectionError = 8.0, int minInliersCount = 100, OutputArray inliers = None() ) +.. cpp:function:: void solvePnPRansac( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount = 100, float reprojectionError = 8.0, int minInliersCount = 100, OutputArray inliers = noArray() ) Finds an object pose from 3D-2D point correspondences using the RANSAC scheme. @@ -543,7 +543,7 @@ The function estimates an object pose given a set of object points, their corres findFundamentalMat ---------------------- -.. cpp:function:: Mat findFundamentalMat( InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=None() ) +.. cpp:function:: Mat findFundamentalMat( InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray() ) Calculates a fundamental matrix from the corresponding points in two images. @@ -605,7 +605,7 @@ corresponding to the specified points. It can also be passed to findHomography ------------------ -.. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=None() ) +.. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() ) Finds a perspective transformation between two planes. @@ -760,7 +760,7 @@ The function computes partial derivatives of the elements of the matrix product projectPoints ----------------- -.. cpp:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray dpdrot=None(), OutputArray dpdt=None(), OutputArray dpdf=None(), OutputArray dpdc=None(), OutputArray dpddist=None(), double aspectRatio=0 ) +.. cpp:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray dpdrot=noArray(), OutputArray dpdt=noArray(), OutputArray dpdf=noArray(), OutputArray dpdc=noArray(), OutputArray dpddist=noArray(), double aspectRatio=0 ) Projects 3D points to an image plane. @@ -870,7 +870,7 @@ that could be used in OpenGL. Rodrigues ------------- -.. cpp:function:: void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=None()) +.. cpp:function:: void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray()) Converts a rotation matrix to a rotation vector or vice versa. diff --git a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp index c45d9ce..652eec4 100644 --- a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp @@ -433,7 +433,7 @@ namespace cv { //! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation -CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=None()); +CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray()); //! type of the robust estimation algorithm enum @@ -445,7 +445,7 @@ enum //! computes the best-fit perspective transformation mapping srcPoints to dstPoints. CV_EXPORTS_W Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, - OutputArray mask=None()); + OutputArray mask=noArray()); //! variant of findHomography for backward compatibility CV_EXPORTS Mat findHomography( InputArray srcPoints, InputArray dstPoints, @@ -453,17 +453,17 @@ CV_EXPORTS Mat findHomography( InputArray srcPoints, InputArray dstPoints, //! Computes RQ decomposition of 3x3 matrix CV_EXPORTS_W Vec3d RQDecomp3x3( InputArray src, OutputArray mtxR, OutputArray mtxQ, - OutputArray Qx=None(), - OutputArray Qy=None(), - OutputArray Qz=None()); + OutputArray Qx=noArray(), + OutputArray Qy=noArray(), + OutputArray Qz=noArray()); //! Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector CV_EXPORTS_W void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, - OutputArray rotMatrixX=None(), - OutputArray rotMatrixY=None(), - OutputArray rotMatrixZ=None(), - OutputArray eulerAngles=None() ); + OutputArray rotMatrixX=noArray(), + OutputArray rotMatrixY=noArray(), + OutputArray rotMatrixZ=noArray(), + OutputArray eulerAngles=noArray() ); //! computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B, @@ -474,17 +474,17 @@ CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B, CV_EXPORTS_W void composeRT( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, - OutputArray dr3dr1=None(), OutputArray dr3dt1=None(), - OutputArray dr3dr2=None(), OutputArray dr3dt2=None(), - OutputArray dt3dr1=None(), OutputArray dt3dt1=None(), - OutputArray dt3dr2=None(), OutputArray dt3dt2=None() ); + OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), + OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), + OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), + OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray() ); //! projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters CV_EXPORTS_W void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, - OutputArray jacobian=None(), + OutputArray jacobian=noArray(), double aspectRatio=0 ); //! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled. @@ -504,7 +504,7 @@ CV_EXPORTS_W void solvePnPRansac( InputArray objectPoints, int iterationsCount = 100, float reprojectionError = 8.0, int minInliersCount = 100, - OutputArray inliers = None() ); + OutputArray inliers = noArray() ); //! initializes camera matrix from a few 3D points and the corresponding projections. CV_EXPORTS_W Mat initCameraMatrix2D( InputArrayOfArrays objectPoints, @@ -646,7 +646,7 @@ enum CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, - OutputArray mask=None()); + OutputArray mask=noArray()); //! variant of findFundamentalMat for backward compatibility CV_EXPORTS Mat findFundamentalMat( InputArray points1, InputArray points2, @@ -730,7 +730,7 @@ protected: //! filters off speckles (small regions of incorrectly computed disparity) CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, - InputOutputArray buf=None() ); + InputOutputArray buf=noArray() ); //! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify()) CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2, diff --git a/modules/calib3d/src/calibration.cpp b/modules/calib3d/src/calibration.cpp index d65db61..91e54f2 100644 --- a/modules/calib3d/src/calibration.cpp +++ b/modules/calib3d/src/calibration.cpp @@ -3339,7 +3339,7 @@ cv::Mat cv::initCameraMatrix2D( InputArrayOfArrays objectPoints, Size imageSize, double aspectRatio ) { Mat objPt, imgPt, npoints, cameraMatrix(3, 3, CV_64F); - collectCalibrationData( objectPoints, imagePoints, None(), + collectCalibrationData( objectPoints, imagePoints, noArray(), objPt, imgPt, 0, npoints ); CvMat _objPt = objPt, _imgPt = imgPt, _npoints = npoints, _cameraMatrix = cameraMatrix; cvInitIntrinsicParams2D( &_objPt, &_imgPt, &_npoints, @@ -3364,7 +3364,7 @@ double cv::calibrateCamera( InputArrayOfArrays _objectPoints, size_t i, nimages = _objectPoints.total(); CV_Assert( nimages > 0 ); Mat objPt, imgPt, npoints, rvecM((int)nimages, 3, CV_64FC1), tvecM((int)nimages, 3, CV_64FC1); - collectCalibrationData( _objectPoints, _imagePoints, None(), + collectCalibrationData( _objectPoints, _imagePoints, noArray(), objPt, imgPt, 0, npoints ); CvMat c_objPt = objPt, c_imgPt = imgPt, c_npoints = npoints; CvMat c_cameraMatrix = cameraMatrix, c_distCoeffs = distCoeffs; diff --git a/modules/core/doc/clustering.rst b/modules/core/doc/clustering.rst index 20fa81d..403aeb6 100644 --- a/modules/core/doc/clustering.rst +++ b/modules/core/doc/clustering.rst @@ -10,7 +10,7 @@ Clustering kmeans ------ -.. cpp:function:: double kmeans( InputArray samples, int clusterCount, InputOutputArray labels, TermCriteria termcrit, int attempts, int flags, OutputArray centers=None() ) +.. cpp:function:: double kmeans( InputArray samples, int clusterCount, InputOutputArray labels, TermCriteria termcrit, int attempts, int flags, OutputArray centers=noArray() ) Finds centers of clusters and groups input samples around the clusters. diff --git a/modules/core/doc/intro.rst b/modules/core/doc/intro.rst index 01266e5..95f8e36 100644 --- a/modules/core/doc/intro.rst +++ b/modules/core/doc/intro.rst @@ -199,7 +199,7 @@ The subset of supported types for each function has been defined from practical InputArray and OutputArray -------------------------- -Many OpenCV functions process dense 2-dimensional or multi-dimensional numerical arrays. Usually, such functions take cpp:class:`Mat` as parameters, but in some cases it's more convenient to use ``std::vector<>`` (for a point set, for example) or ``Matx<>`` (for 3x3 homography matrix and such). To avoid many duplicates in the API, special "proxy" classes have been introduced. The base "proxy" class is ``InputArray``. It is used for passing read-only arrays on a function input. The derived from ``InputArray`` class ``OutputArray`` is used to specify an output array for a function. Normally, you should not care of those intermediate types (and you should not declare variables of those types explicitly) - it will all just work automatically. You can assume that instead of ``InputArray``/``OutputArray`` you can always use ``Mat``, ``std::vector<>``, ``Matx<>``, ``Vec<>`` or ``Scalar``. When a function has an optional input or output array, and you do not have or do not want one, pass ``cv::None()``. +Many OpenCV functions process dense 2-dimensional or multi-dimensional numerical arrays. Usually, such functions take cpp:class:`Mat` as parameters, but in some cases it's more convenient to use ``std::vector<>`` (for a point set, for example) or ``Matx<>`` (for 3x3 homography matrix and such). To avoid many duplicates in the API, special "proxy" classes have been introduced. The base "proxy" class is ``InputArray``. It is used for passing read-only arrays on a function input. The derived from ``InputArray`` class ``OutputArray`` is used to specify an output array for a function. Normally, you should not care of those intermediate types (and you should not declare variables of those types explicitly) - it will all just work automatically. You can assume that instead of ``InputArray``/``OutputArray`` you can always use ``Mat``, ``std::vector<>``, ``Matx<>``, ``Vec<>`` or ``Scalar``. When a function has an optional input or output array, and you do not have or do not want one, pass ``cv::noArray()``. Error Handling -------------- diff --git a/modules/core/doc/operations_on_arrays.rst b/modules/core/doc/operations_on_arrays.rst index 70bd48b..f27359c 100644 --- a/modules/core/doc/operations_on_arrays.rst +++ b/modules/core/doc/operations_on_arrays.rst @@ -67,7 +67,7 @@ See Also: :cpp:func:`abs` add ------- -.. cpp:function:: void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=None(), int dtype=-1) +.. cpp:function:: void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) Computes the per-element sum of two arrays or an array and a scalar. @@ -166,7 +166,7 @@ See Also: bitwise_and ----------- -.. cpp:function:: void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=None()) +.. cpp:function:: void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar. @@ -208,7 +208,7 @@ In case of floating-point arrays, their machine-specific bit representations (us bitwise_not ----------- -.. cpp:function:: void bitwise_not(InputArray src, OutputArray dst, InputArray mask=None()) +.. cpp:function:: void bitwise_not(InputArray src, OutputArray dst, InputArray mask=noArray()) Inverts every bit of an array. @@ -230,7 +230,7 @@ In case of a floating-point source array, its machine-specific bit representatio bitwise_or ---------- -.. cpp:function:: void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=None()) +.. cpp:function:: void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar. @@ -273,7 +273,7 @@ The function computes the per-element bit-wise logical disjunction: bitwise_xor ----------- -.. cpp:function:: void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=None()) +.. cpp:function:: void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar. @@ -1513,7 +1513,7 @@ See Also: mean ---- -.. cpp:function:: Scalar mean(InputArray mtx, InputArray mask=None()) +.. cpp:function:: Scalar mean(InputArray mtx, InputArray mask=noArray()) Calculates an average (mean) of array elements. @@ -1540,7 +1540,7 @@ See Also: meanStdDev ---------- -.. cpp:function:: void meanStdDev(InputArray mtx, OutputArray mean, OutputArray stddev, InputArray mask=None()) +.. cpp:function:: void meanStdDev(InputArray mtx, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) Calculates mean and standard deviation of array elements. @@ -1656,7 +1656,7 @@ See Also: minMaxLoc --------- -.. cpp:function:: void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=None()) +.. cpp:function:: void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray()) .. cpp:function:: void minMaxLoc(const SparseMat& src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0) @@ -1824,7 +1824,7 @@ See Also: mulTransposed ------------- -.. cpp:function:: void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=None(), double scale=1, int rtype=-1) +.. cpp:function:: void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int rtype=-1) Calculates the product of a matrix and its transposition. @@ -1834,7 +1834,7 @@ mulTransposed :param aTa: Flag specifying the multiplication ordering. See the description below. - :param delta: Optional delta matrix subtracted from ``src`` before the multiplication. When the matrix is empty ( ``delta=None()`` ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as ``src`` , it is simply subtracted. Otherwise, it is "repeated" (see :cpp:func:`repeat` ) to cover the full ``src`` and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created destination matrix. See the ``rtype`` description. + :param delta: Optional delta matrix subtracted from ``src`` before the multiplication. When the matrix is empty ( ``delta=noArray()`` ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as ``src`` , it is simply subtracted. Otherwise, it is "repeated" (see :cpp:func:`repeat` ) to cover the full ``src`` and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created destination matrix. See the ``rtype`` description. :param scale: Optional scale factor for the matrix product. @@ -1867,9 +1867,9 @@ See Also: norm ---- -.. cpp:function:: double norm(InputArray src1, int normType=NORM_L2, InputArray mask=None()) +.. cpp:function:: double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) -.. cpp:function:: double norm(InputArray src1, InputArray src2, int normType, InputArray mask=None()) +.. cpp:function:: double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray()) .. cpp:function:: double norm( const SparseMat& src, int normType ) @@ -1918,7 +1918,7 @@ A multi-channel source arrays are treated as a single-channel, that is, the resu normalize --------- -.. cpp:function:: void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=None()) +.. cpp:function:: void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=noArray()) .. cpp:function:: void normalize(const SparseMat& src, SparseMat& dst, double alpha, int normType) @@ -2938,7 +2938,7 @@ See Also: subtract -------- -.. cpp:function:: void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=None(), int dtype=-1) +.. cpp:function:: void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) Calculates the per-element difference between two arrays or array and a scalar. diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 8eeb069..0bde697 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/modules/core/include/opencv2/core/core.hpp @@ -1338,7 +1338,7 @@ typedef const _OutputArray& OutputArray; typedef OutputArray OutputArrayOfArrays; typedef OutputArray InputOutputArray; -CV_EXPORTS OutputArray None(); +CV_EXPORTS OutputArray noArray(); /////////////////////////////////////// Mat /////////////////////////////////////////// @@ -1659,7 +1659,7 @@ public: //! sets every matrix element to s Mat& operator = (const Scalar& s); //! sets some of the matrix elements to s, according to the mask - Mat& setTo(const Scalar& s, InputArray mask=None()); + Mat& setTo(const Scalar& s, InputArray mask=noArray()); //! creates alternative matrix header for the same data, with different // number of channels and/or different number of rows. see cvReshape. Mat reshape(int _cn, int _rows=0) const; @@ -1975,10 +1975,10 @@ CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1); //! adds one matrix to another (dst = src1 + src2) CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, - InputArray mask=None(), int dtype=-1); + InputArray mask=noArray(), int dtype=-1); //! subtracts one matrix from another (dst = src1 - src2) CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, - InputArray mask=None(), int dtype=-1); + InputArray mask=noArray(), int dtype=-1); //! computes element-wise weighted product of the two arrays (dst = scale*src1*src2) CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, @@ -2011,25 +2011,25 @@ CV_EXPORTS_W Scalar sum(InputArray src); //! computes the number of nonzero array elements CV_EXPORTS_W int countNonZero( InputArray src ); //! computes mean value of selected array elements -CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask=None()); +CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask=noArray()); //! computes mean value and standard deviation of all or selected array elements CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, - InputArray mask=None()); + InputArray mask=noArray()); //! computes norm of the selected array part -CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=None()); +CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray()); //! computes norm of selected part of the difference between two arrays CV_EXPORTS_W double norm(InputArray src1, InputArray src2, - int normType=NORM_L2, InputArray mask=None()); + int normType=NORM_L2, InputArray mask=noArray()); //! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values CV_EXPORTS_W void normalize( InputArray src, OutputArray dst, double alpha=1, double beta=0, - int norm_type=NORM_L2, int dtype=-1, InputArray mask=None()); + int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray()); //! finds global minimum and maximum array elements and returns their values and their locations CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal, CV_OUT double* maxVal=0, CV_OUT Point* minLoc=0, - CV_OUT Point* maxLoc=0, InputArray mask=None()); + CV_OUT Point* maxLoc=0, InputArray mask=noArray()); CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal, - int* minIdx=0, int* maxIdx=0, InputArray mask=None()); + int* minIdx=0, int* maxIdx=0, InputArray mask=noArray()); //! transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1); @@ -2067,16 +2067,16 @@ CV_EXPORTS_W void vconcat(InputArray src, OutputArray dst); //! computes bitwise conjunction of the two arrays (dst = src1 & src2) CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, - OutputArray dst, InputArray mask=None()); + OutputArray dst, InputArray mask=noArray()); //! computes bitwise disjunction of the two arrays (dst = src1 | src2) CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, - OutputArray dst, InputArray mask=None()); + OutputArray dst, InputArray mask=noArray()); //! computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, - OutputArray dst, InputArray mask=None()); + OutputArray dst, InputArray mask=noArray()); //! inverts each bit of array (dst = ~src) CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst, - InputArray mask=None()); + InputArray mask=noArray()); //! computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst); //! set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb) @@ -2130,7 +2130,7 @@ CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, int flags=0); //! multiplies matrix by its transposition from the left or from the right CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa, - InputArray delta=None(), + InputArray delta=noArray(), double scale=1, int dtype=-1 ); //! transposes the matrix CV_EXPORTS_W void transpose(InputArray src, OutputArray dst); @@ -2331,7 +2331,7 @@ enum //! clusters the input data using k-Means algorithm CV_EXPORTS_W double kmeans( InputArray data, int K, CV_OUT InputOutputArray bestLabels, TermCriteria criteria, int attempts, - int flags, OutputArray centers=None() ); + int flags, OutputArray centers=noArray() ); //! returns the thread-local Random number generator CV_EXPORTS RNG& theRNG(); @@ -3662,18 +3662,18 @@ public: //! finds the K nearest neighbors of "vec" while looking at Emax (at most) leaves CV_WRAP int findNearest(InputArray vec, int K, int Emax, OutputArray neighborsIdx, - OutputArray neighbors=None(), - OutputArray dist=None(), - OutputArray labels=None()) const; + OutputArray neighbors=noArray(), + OutputArray dist=noArray(), + OutputArray labels=noArray()) const; //! finds all the points from the initial set that belong to the specified box CV_WRAP void findOrthoRange(InputArray minBounds, InputArray maxBounds, OutputArray neighborsIdx, - OutputArray neighbors=None(), - OutputArray labels=None()) const; + OutputArray neighbors=noArray(), + OutputArray labels=noArray()) const; //! returns vectors with the specified indices CV_WRAP void getPoints(InputArray idx, OutputArray pts, - OutputArray labels=None()) const; + OutputArray labels=noArray()) const; //! return a vector with the specified index const float* getPoint(int ptidx, int* label=0) const; //! returns the search space dimensionality diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index a2a5d1c..b155e7a 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -1156,36 +1156,36 @@ void cv::bitwise_not(InputArray a, OutputArray c, InputArray mask) void cv::max( InputArray src1, InputArray src2, OutputArray dst ) { - binary_op(src1, src2, dst, None(), maxTab, false ); + binary_op(src1, src2, dst, noArray(), maxTab, false ); } void cv::min( InputArray src1, InputArray src2, OutputArray dst ) { - binary_op(src1, src2, dst, None(), minTab, false ); + binary_op(src1, src2, dst, noArray(), minTab, false ); } void cv::max(const Mat& src1, const Mat& src2, Mat& dst) { OutputArray _dst(dst); - binary_op(src1, src2, _dst, None(), maxTab, false ); + binary_op(src1, src2, _dst, noArray(), maxTab, false ); } void cv::min(const Mat& src1, const Mat& src2, Mat& dst) { OutputArray _dst(dst); - binary_op(src1, src2, _dst, None(), minTab, false ); + binary_op(src1, src2, _dst, noArray(), minTab, false ); } void cv::max(const Mat& src1, double src2, Mat& dst) { OutputArray _dst(dst); - binary_op(src1, src2, _dst, None(), maxTab, false ); + binary_op(src1, src2, _dst, noArray(), maxTab, false ); } void cv::min(const Mat& src1, double src2, Mat& dst) { OutputArray _dst(dst); - binary_op(src1, src2, _dst, None(), minTab, false ); + binary_op(src1, src2, _dst, noArray(), minTab, false ); } /****************************************************************************************\ @@ -1466,7 +1466,7 @@ void cv::subtract( InputArray src1, InputArray src2, OutputArray dst, void cv::absdiff( InputArray src1, InputArray src2, OutputArray dst ) { - arithm_op(src1, src2, dst, None(), -1, absdiffTab); + arithm_op(src1, src2, dst, noArray(), -1, absdiffTab); } /****************************************************************************************\ @@ -1779,19 +1779,19 @@ static BinaryFunc recipTab[] = void cv::multiply(InputArray src1, InputArray src2, OutputArray dst, double scale, int dtype) { - arithm_op(src1, src2, dst, None(), dtype, mulTab, true, &scale); + arithm_op(src1, src2, dst, noArray(), dtype, mulTab, true, &scale); } void cv::divide(InputArray src1, InputArray src2, OutputArray dst, double scale, int dtype) { - arithm_op(src1, src2, dst, None(), dtype, divTab, true, &scale); + arithm_op(src1, src2, dst, noArray(), dtype, divTab, true, &scale); } void cv::divide(double scale, InputArray src2, OutputArray dst, int dtype) { - arithm_op(src2, src2, dst, None(), dtype, recipTab, true, &scale); + arithm_op(src2, src2, dst, noArray(), dtype, recipTab, true, &scale); } /****************************************************************************************\ @@ -1944,7 +1944,7 @@ void cv::addWeighted( InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype ) { double scalars[] = {alpha, beta, gamma}; - arithm_op(src1, src2, dst, None(), dtype, addWeightedTab, true, scalars); + arithm_op(src1, src2, dst, noArray(), dtype, addWeightedTab, true, scalars); } diff --git a/modules/core/src/datastructs.cpp b/modules/core/src/datastructs.cpp index 8c11306..917c6ea 100644 --- a/modules/core/src/datastructs.cpp +++ b/modules/core/src/datastructs.cpp @@ -3639,7 +3639,7 @@ computeSums( const Mat& points, const size_t* ofs, int a, int b, double* sums ) void KDTree::build(InputArray _points, bool _copyData) { - build(_points, None(), _copyData); + build(_points, noArray(), _copyData); } diff --git a/modules/core/src/lapack.cpp b/modules/core/src/lapack.cpp index 4aca201..03785f9 100644 --- a/modules/core/src/lapack.cpp +++ b/modules/core/src/lapack.cpp @@ -1435,7 +1435,7 @@ static bool eigen( InputArray _src, OutputArray _evals, OutputArray _evects, boo bool cv::eigen( InputArray src, OutputArray evals, int lowindex, int highindex ) { - return eigen(src, evals, None(), false, lowindex, highindex); + return eigen(src, evals, noArray(), false, lowindex, highindex); } bool cv::eigen( InputArray src, OutputArray evals, OutputArray evects, @@ -1522,7 +1522,7 @@ void SVD::compute( InputArray a, OutputArray w, OutputArray u, OutputArray vt, i void SVD::compute( InputArray a, OutputArray w, int flags ) { - _SVDcompute(a, w, None(), None(), flags); + _SVDcompute(a, w, noArray(), noArray(), flags); } void SVD::backSubst( InputArray _w, InputArray _u, InputArray _vt, diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index a0bb553..0d9fa80 100644 --- a/modules/core/src/matrix.cpp +++ b/modules/core/src/matrix.cpp @@ -1399,7 +1399,7 @@ Mat& _OutputArray::getMatRef(int i) const } static _OutputArray _none; -OutputArray None() { return _none; } +OutputArray noArray() { return _none; } } diff --git a/modules/imgproc/doc/feature_detection.rst b/modules/imgproc/doc/feature_detection.rst index 3afc1c0..9784f5f 100644 --- a/modules/imgproc/doc/feature_detection.rst +++ b/modules/imgproc/doc/feature_detection.rst @@ -193,7 +193,7 @@ The algorithm sets the center of the neighborhood window at this new center goodFeaturesToTrack ------------------- -.. cpp:function:: void goodFeaturesToTrack( InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=None(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ) +.. cpp:function:: void goodFeaturesToTrack( InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ) Determines strong corners on an image. diff --git a/modules/imgproc/doc/geometric_transformations.rst b/modules/imgproc/doc/geometric_transformations.rst index dcd38a2..8528c7b 100644 --- a/modules/imgproc/doc/geometric_transformations.rst +++ b/modules/imgproc/doc/geometric_transformations.rst @@ -519,7 +519,7 @@ By default, the undistortion functions in OpenCV (see undistort ------------- -.. cpp:function:: void undistort( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=None() ) +.. cpp:function:: void undistort( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray() ) Transforms an image to compensate for lens distortion. @@ -554,7 +554,7 @@ The camera matrix and the distortion parameters can be determined using undistortPoints ------------------- -.. cpp:function:: void undistortPoints( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=None(), InputArray P=None()) +.. cpp:function:: void undistortPoints( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) Computes the ideal point coordinates from the observed point coordinates. diff --git a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst index 1284d22..e590033 100644 --- a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst +++ b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst @@ -7,7 +7,7 @@ Motion Analysis and Object Tracking accumulate -------------- -.. cpp:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=None() ) +.. cpp:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) Adds an image to the accumulator. @@ -36,7 +36,7 @@ See Also: accumulateSquare -------------------- -.. cpp:function:: void accumulateSquare( InputArray src, InputOutputArray dst, InputArray mask=None() ) +.. cpp:function:: void accumulateSquare( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) Adds the square of a source image to the accumulator. @@ -63,7 +63,7 @@ See Also: accumulateProduct --------------------- -.. cpp:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=None() ) +.. cpp:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray() ) Adds the per-element product of two input images to the accumulator. @@ -92,7 +92,7 @@ See Also: accumulateWeighted ---------------------- -.. cpp:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=None() ) +.. cpp:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray() ) Updates a running average. diff --git a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst index 0eca66a..7352c1d 100644 --- a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst +++ b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst @@ -150,7 +150,7 @@ Source ``image`` is modified by this function. drawContours ---------------- -.. cpp:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=None(), int maxLevel=INT_MAX, Point offset=Point() ) +.. cpp:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() ) Draws contours outlines or filled contours. diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp index ecc4b76..84f3e1f 100644 --- a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp @@ -462,7 +462,7 @@ CV_EXPORTS void cornerSubPix( InputArray image, InputOutputArray corners, //! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, - InputArray mask=None(), int blockSize=3, + InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ); //! finds lines in the black-n-white image using the standard or pyramid Hough transform @@ -574,16 +574,16 @@ CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum, //! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. CV_EXPORTS_W void accumulate( InputArray src, CV_IN_OUT InputOutputArray dst, - InputArray mask=None() ); + InputArray mask=noArray() ); //! adds squared src image to the accumulator (dst += src*src). CV_EXPORTS_W void accumulateSquare( InputArray src, CV_IN_OUT InputOutputArray dst, - InputArray mask=None() ); + InputArray mask=noArray() ); //! adds product of the 2 images to the accumulator (dst += src1*src2). CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2, - CV_IN_OUT InputOutputArray dst, InputArray mask=None() ); + CV_IN_OUT InputOutputArray dst, InputArray mask=noArray() ); //! updates the running average (dst = dst*(1-alpha) + src*alpha) CV_EXPORTS_W void accumulateWeighted( InputArray src, CV_IN_OUT InputOutputArray dst, - double alpha, InputArray mask=None() ); + double alpha, InputArray mask=noArray() ); //! type of the threshold operation enum { THRESH_BINARY=CV_THRESH_BINARY, THRESH_BINARY_INV=CV_THRESH_BINARY_INV, @@ -617,7 +617,7 @@ CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst, int maxle CV_EXPORTS_W void undistort( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, - InputArray newCameraMatrix=None() ); + InputArray newCameraMatrix=noArray() ); //! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image CV_EXPORTS_W void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs, @@ -643,7 +643,7 @@ CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsiz //! returns points' coordinates after lens distortion correction CV_EXPORTS void undistortPoints( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, - InputArray R=None(), InputArray P=None()); + InputArray R=noArray(), InputArray P=noArray()); template<> CV_EXPORTS void Ptr::delete_obj(); @@ -682,8 +682,8 @@ CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int met CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst ); CV_EXPORTS float EMD( InputArray signature1, InputArray signature2, - int distType, InputArray cost=None(), - float* lowerBound=0, OutputArray flow=None() ); + int distType, InputArray cost=noArray(), + float* lowerBound=0, OutputArray flow=noArray() ); //! segments the image using watershed algorithm CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers ); @@ -818,7 +818,7 @@ CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contou CV_EXPORTS void drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, - InputArray hierarchy=None(), + InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() ); //! approximates contour or a curve using Douglas-Peucker algorithm diff --git a/modules/imgproc/src/contours.cpp b/modules/imgproc/src/contours.cpp index abe6562..2a729fa 100644 --- a/modules/imgproc/src/contours.cpp +++ b/modules/imgproc/src/contours.cpp @@ -1519,7 +1519,7 @@ void cv::findContours( const InputOutputArray _image, OutputArrayOfArrays _conto void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours, int mode, int method, Point offset) { - findContours(_image, _contours, None(), mode, method, offset); + findContours(_image, _contours, noArray(), mode, method, offset); } namespace cv diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index ba81ca5..eb9a70f 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -272,12 +272,12 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output void cv::integral( InputArray src, OutputArray sum, int sdepth ) { - integral( src, sum, None(), None(), sdepth ); + integral( src, sum, noArray(), noArray(), sdepth ); } void cv::integral( InputArray src, OutputArray sum, OutputArray sqsum, int sdepth ) { - integral( src, sum, sqsum, None(), sdepth ); + integral( src, sum, sqsum, noArray(), sdepth ); } diff --git a/modules/ml/test/test_emknearestkmeans.cpp b/modules/ml/test/test_emknearestkmeans.cpp index 0421af7..b9ddfca 100644 --- a/modules/ml/test/test_emknearestkmeans.cpp +++ b/modules/ml/test/test_emknearestkmeans.cpp @@ -203,7 +203,7 @@ void CV_KMeansTest::run( int /*start_from*/ ) int code = cvtest::TS::OK; Mat bestLabels; // 1. flag==KMEANS_PP_CENTERS - kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_PP_CENTERS, None() ); + kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_PP_CENTERS, noArray() ); if( calcErr( bestLabels, labels, sizes, false ) > 0.01f ) { ts->printf( cvtest::TS::LOG, "bad accuracy if flag==KMEANS_PP_CENTERS" ); @@ -211,7 +211,7 @@ void CV_KMeansTest::run( int /*start_from*/ ) } // 2. flag==KMEANS_RANDOM_CENTERS - kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_RANDOM_CENTERS, None() ); + kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_RANDOM_CENTERS, noArray() ); if( calcErr( bestLabels, labels, sizes, false ) > 0.01f ) { ts->printf( cvtest::TS::LOG, "bad accuracy if flag==KMEANS_PP_CENTERS" ); @@ -223,7 +223,7 @@ void CV_KMeansTest::run( int /*start_from*/ ) RNG rng; for( int i = 0; i < 0.5f * pointsCount; i++ ) bestLabels.at( rng.next() % pointsCount, 0 ) = rng.next() % 3; - kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_USE_INITIAL_LABELS, None() ); + kmeans( data, 3, bestLabels, TermCriteria( TermCriteria::COUNT, iters, 0.0), 0, KMEANS_USE_INITIAL_LABELS, noArray() ); if( calcErr( bestLabels, labels, sizes, false ) > 0.01f ) { ts->printf( cvtest::TS::LOG, "bad accuracy if flag==KMEANS_PP_CENTERS" ); diff --git a/modules/python/src2/hdr_parser.py b/modules/python/src2/hdr_parser.py index 756f059..b5a84a6 100755 --- a/modules/python/src2/hdr_parser.py +++ b/modules/python/src2/hdr_parser.py @@ -457,7 +457,7 @@ class CppHeaderParser(object): ("InputArray", "Mat"), ("InputOutputArray", "Mat"), ("OutputArray", "Mat"), - ("None", arg_type)]).strip() + ("noArray", arg_type)]).strip() args.append([arg_type, arg_name, defval, modlist]) npos = arg_start-1 -- 2.7.4