renamed "None()" to "noArray()" to avoid conflicts with X11 (ticket #1122)

index.rst

@@ -10,10 +10,10 @@ Welcome to opencv documentation!
    :maxdepth: 2
 
    modules/refman.rst
-   doc/opencv1/c/c_index.rst
+   _doc/opencv1/c/c_index.rst
-   doc/opencv1/py/py_index.rst
+   _doc/opencv1/py/py_index.rst
-   doc/user_guide/user_guide.rst
+   _doc/user_guide/user_guide.rst
-   doc/tutorials/tutorials.rst
+   _doc/tutorials/tutorials.rst
 
 Indices and tables
 ==================

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.
 

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 Qx=noArray(),
-                                OutputArray Qy=None(),
+                                OutputArray Qy=noArray(),
-                                OutputArray Qz=None());
+                                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 rotMatrixX=noArray(),
-                                             OutputArray rotMatrixY=None(),
+                                             OutputArray rotMatrixY=noArray(),
-                                             OutputArray rotMatrixZ=None(),
+                                             OutputArray rotMatrixZ=noArray(),
-                                             OutputArray eulerAngles=None() );   
+                                             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 dr3dr1=noArray(), OutputArray dr3dt1=noArray(),
-                             OutputArray dr3dr2=None(), OutputArray dr3dt2=None(),
+                             OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(),
-                             OutputArray dt3dr1=None(), OutputArray dt3dt1=None(),
+                             OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(),
-                             OutputArray dt3dr2=None(), OutputArray dt3dt2=None() );
+                             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,

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;

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.
 

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
 --------------

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.
 

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 neighbors=noArray(),
-                            OutputArray dist=None(),
+                            OutputArray dist=noArray(),
-                            OutputArray labels=None()) const;
+                            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 neighbors=noArray(),
-                                OutputArray labels=None()) const;
+                                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

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);
 }
 
 

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);
 }
 
 

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,

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; }
     
 }
 

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.
 

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.
 

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.
 

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.
 

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<CvHistogram>::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(),
+                      int distType, InputArray cost=noArray(),
-                      float* lowerBound=0, OutputArray flow=None() );
+                      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

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

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 );
 }
 
 

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<int>( 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" );

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