mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-24 11:10:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Vadim Pisarevsky 2011-06-08 06:55:04 +00:00
parent aad9b3219c
commit 2d2b8a496e
21 changed files with 108 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
index.rst
View File

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

12
modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst
View File

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

34
modules/calib3d/include/opencv2/calib3d/calib3d.hpp
View File

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

4
modules/calib3d/src/calibration.cpp
View File

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

2
modules/core/doc/clustering.rst
View File

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

2
modules/core/doc/intro.rst
View File

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

28
modules/core/doc/operations_on_arrays.rst
View File

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

46
modules/core/include/opencv2/core/core.hpp
View File

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

22
modules/core/src/arithm.cpp
View File

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

2
modules/core/src/datastructs.cpp
View File

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

4
modules/core/src/lapack.cpp
View File

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

2
modules/core/src/matrix.cpp
View File

@ -1399,7 +1399,7 @@ Mat& _OutputArray::getMatRef(int i) const
}
static _OutputArray _none;
OutputArray None() { return _none; }
OutputArray noArray() { return _none; }
}

2
modules/imgproc/doc/feature_detection.rst
View File

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

4
modules/imgproc/doc/geometric_transformations.rst
View File

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

8
modules/imgproc/doc/motion_analysis_and_object_tracking.rst
View File

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

2
modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst
View File

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

20
modules/imgproc/include/opencv2/imgproc/imgproc.hpp
View File

@ -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(),
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

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

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

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

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

6
modules/ml/test/test_emknearestkmeans.cpp
View File

@ -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" );

2
modules/python/src2/hdr_parser.py
View File

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