The function converts 2D or 3D points from/to homogeneous coordinates by calling either :cpp:func:`convertPointsToHomogeneous` or :cpp:func:`convertPointsFromHomogeneous`. The function is obsolete; use one of the previous two instead.
The function converts 2D or 3D points from/to homogeneous coordinates by calling either :ocv:func:`convertPointsToHomogeneous` or :ocv:func:`convertPointsFromHomogeneous`. The function is obsolete; use one of the previous two instead.
..index:: decomposeProjectionMatrix
@ -337,7 +337,7 @@ The function converts 2D or 3D points from/to homogeneous coordinates by calling
:param corners:Array of detected corners, the output of ``findChessboardCorners``.
:param patternWasFound:Parameter indicating whether the complete board was found or not. The return value of :cpp:func:`findChessboardCorners` should be passed here.
:param patternWasFound:Parameter indicating whether the complete board was found or not. The return value of :ocv:func:`findChessboardCorners` should be passed here.
The function draws individual chessboard corners detected either as red circles if the board was not found, or as colored corners connected with lines if the board was found.
@ -386,7 +386,7 @@ The function draws individual chessboard corners detected either as red circles
Computes disparity using the BM algorithm for a rectified stereo pair.
@ -1008,9 +1008,9 @@ The class implements the modified H. Hirschmuller algorithm HH08 that differs fr
StereoSGBM::StereoSGBM
--------------------------
..cpp:function:: StereoSGBM::StereoSGBM()
..ocv:function:: StereoSGBM::StereoSGBM()
..cpp:function:: StereoSGBM::StereoSGBM( int minDisparity, int numDisparities, int SADWindowSize, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, bool fullDP=false)
..ocv:function:: StereoSGBM::StereoSGBM( int minDisparity, int numDisparities, int SADWindowSize, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, bool fullDP=false)
The constructor.
@ -1041,7 +1041,7 @@ The first constructor initializes ``StereoSGBM`` with all the default parameters
Template "trait" class for OpenCV primitive data types. A primitive OpenCV data type is one of ``unsigned char``, ``bool``, ``signed char``, ``unsigned short``, ``signed short``, ``int``, ``float``, ``double``, or a tuple of values of one of these types, where all the values in the tuple have the same type. Any primitive type from the list can be defined by an identifier in the form ``CV_<bit-depth>{U|S|F}C(<number_of_channels>)``, for example: ``uchar`` ~ ``CV_8UC1``, 3-element floating-point tuple ~ ``CV_32FC3``, and so on. A universal OpenCV structure that is able to store a single instance of such a primitive data type is
:cpp:class:`Vec`. Multiple instances of such a type can be stored in a ``std::vector``, ``Mat``, ``Mat_``, ``SparseMat``, ``SparseMat_``, or any other container that is able to store ``Vec`` instances.
:ocv:class:`Vec`. Multiple instances of such a type can be stored in a ``std::vector``, ``Mat``, ``Mat_``, ``SparseMat``, ``SparseMat_``, or any other container that is able to store ``Vec`` instances.
The ``DataType`` class is basically used to provide a description of such primitive data types without adding any fields or methods to the corresponding classes (and it is actually impossible to add anything to primitive C/C++ data types). This technique is known in C++ as class traits. It is not ``DataType`` itself that is used but its specialized versions, such as: ::
@ -47,7 +47,7 @@ So, such traits are used to tell OpenCV which data type you are working with, ev
Point\_
-------
..cpp:class:: Point_
..ocv:class:: Point_
Template class for 2D points specified by its coordinates
:math:`x` and
@ -82,7 +82,7 @@ Example: ::
Point3\_
--------
..cpp:class:: Point3_
..ocv:class:: Point3_
Template class for 3D points specified by its coordinates
:math:`x`,
@ -98,7 +98,7 @@ The following ``Point3_<>`` aliases are available: ::
Size\_
------
..cpp:class:: Size_
..ocv:class:: Size_
Template class for specfying the size of an image or rectangle. The class includes two members called ``width`` and ``height``. The structure can be converted to and from the old OpenCV structures
``CvSize`` and ``CvSize2D32f`` . The same set of arithmetic and comparison operations as for ``Point_`` is available.
@ -111,7 +111,7 @@ OpenCV defines the following ``Size_<>`` aliases: ::
Rect\_
------
..cpp:class:: Rect_
..ocv:class:: Rect_
Template class for 2D rectangles, described by the following parameters::
@ -169,20 +169,20 @@ For your convenience, the ``Rect_<>`` alias is available: ::
RotatedRect
-----------
..cpp:class:: RotatedRect
..ocv:class:: RotatedRect
Template class for rotated rectangles specified by the center, size, and the rotation angle in degrees.
TermCriteria
------------
..cpp:class:: TermCriteria
..ocv:class:: TermCriteria
Template class defining termination criteria for iterative algorithms.
Matx
----
..cpp:class:: Matx
..ocv:class:: Matx
Template class for small matrices whose type and size are known at compilation time: ::
@ -206,7 +206,7 @@ Template class for small matrices whose type and size are known at compilation t
typedef Matx<float, 6, 6> Matx66f;
typedef Matx<double, 6, 6> Matx66d;
If you need a more flexible type, use :cpp:class:`Mat` . The elements of the matrix ``M`` are accessible using the ``M(i,j)`` notation. Most of the common matrix operations (see also
If you need a more flexible type, use :ocv:class:`Mat` . The elements of the matrix ``M`` are accessible using the ``M(i,j)`` notation. Most of the common matrix operations (see also
:ref:`MatrixExpressions` ) are available. To do an operation on ``Matx`` that is not implemented, you can easily convert the matrix to
``Mat`` and backwards. ::
@ -218,9 +218,9 @@ If you need a more flexible type, use :cpp:class:`Mat` . The elements of the mat
Vec
---
..cpp:class:: Vec
..ocv:class:: Vec
Template class for short numerical vectors, a partial case of :cpp:class:`Matx`: ::
Template class for short numerical vectors, a partial case of :ocv:class:`Matx`: ::
template<typename _Tp, int n> class Vec : public Matx<_Tp, n, 1> {...};
@ -246,7 +246,7 @@ Template class for short numerical vectors, a partial case of :cpp:class:`Matx`:
typedef Vec<double, 4> Vec4d;
typedef Vec<double, 6> Vec6d;
It is possible to convert ``Vec<T,2>`` to/from ``Point_``, ``Vec<T,3>`` to/from ``Point3_`` , and ``Vec<T,4>`` to ``CvScalar`` or :cpp:class:`Scalar`. Use ``operator[]`` to access the elements of ``Vec``.
It is possible to convert ``Vec<T,2>`` to/from ``Point_``, ``Vec<T,3>`` to/from ``Point3_`` , and ``Vec<T,4>`` to ``CvScalar`` or :ocv:class:`Scalar`. Use ``operator[]`` to access the elements of ``Vec``.
All the expected vector operations are also implemented:
@ -259,11 +259,11 @@ All the expected vector operations are also implemented:
* ``v1 == v2, v1 != v2``
* ``norm(v1)`` (euclidean norm)
The ``Vec`` class is commonly used to describe pixel types of multi-channel arrays. See :cpp:class:`Mat` for details.
The ``Vec`` class is commonly used to describe pixel types of multi-channel arrays. See :ocv:class:`Mat` for details.
Scalar\_
--------
..cpp:class:: Scalar_
..ocv:class:: Scalar_
Template class for a 4-element vector derived from Vec. ::
@ -275,7 +275,7 @@ Being derived from ``Vec<_Tp, 4>`` , ``Scalar_`` and ``Scalar`` can be used just
Range
-----
..cpp:class:: Range
..ocv:class:: Range
Template class specifying a continuous subsequence (slice) of a sequence. ::
@ -287,7 +287,7 @@ Template class specifying a continuous subsequence (slice) of a sequence. ::
};
The class is used to specify a row or a column span in a matrix (
:cpp:class:`Mat` ) and for many other purposes. ``Range(a,b)`` is basically the same as ``a:b`` in Matlab or ``a..b`` in Python. As in Python, ``start`` is an inclusive left boundary of the range and ``end`` is an exclusive right boundary of the range. Such a half-opened interval is usually denoted as
:ocv:class:`Mat` ) and for many other purposes. ``Range(a,b)`` is basically the same as ``a:b`` in Matlab or ``a..b`` in Python. As in Python, ``start`` is an inclusive left boundary of the range and ``end`` is an exclusive right boundary of the range. Such a half-opened interval is usually denoted as
:math:`[start,end)` .
The static method ``Range::all()`` returns a special variable that means "the whole sequence" or "the whole range", just like " ``:`` " in Matlab or " ``...`` " in Python. All the methods and functions in OpenCV that take ``Range`` support this special ``Range::all()`` value. But, of course, in case of your own custom processing, you will probably have to check and handle it explicitly: ::
@ -305,7 +305,7 @@ The static method ``Range::all()`` returns a special variable that means "the wh
Ptr
---
..cpp:class:: Ptr
..ocv:class:: Ptr
Template class for smart reference-counting pointers ::
@ -389,11 +389,11 @@ However, if the object is deallocated in a different way, the specialized method
// the file will be closed automatically by the Ptr<FILE> destructor.
..note:: The reference increment/decrement operations are implemented as atomic operations, and therefore it is normally safe to use the classes in multi-threaded applications. The same is true for :cpp:class:`Mat` and other C++ OpenCV classes that operate on the reference counters.
..note:: The reference increment/decrement operations are implemented as atomic operations, and therefore it is normally safe to use the classes in multi-threaded applications. The same is true for :ocv:class:`Mat` and other C++ OpenCV classes that operate on the reference counters.
Mat
---
..cpp:class:: Mat
..ocv:class:: Mat
OpenCV C++ n-dimensional dense array class ::
@ -588,7 +588,7 @@ There are many different ways to create a ``Mat`` object. The most popular optio
..
With this approach, you first call a constructor of the :cpp:class:`Mat_` class with the proper parameters, and then you just put ``<<`` operator followed by comma-separated values that can be constants, variables, expressions, and so on. Also, note the extra parentheses required to avoid compilation errors.
With this approach, you first call a constructor of the :ocv:class:`Mat_` class with the proper parameters, and then you just put ``<<`` operator followed by comma-separated values that can be constants, variables, expressions, and so on. Also, note the extra parentheses required to avoid compilation errors.
Once the array is created, it is automatically managed via a reference-counting mechanism. If the array header is built on top of user-allocated data, you should handle the data by yourself.
The array data is deallocated when no one points to it. If you want to release the data pointed by a array header before the array destructor is called, use ``Mat::release()`` .
@ -688,7 +688,7 @@ for a scalar ( ``Scalar`` ),
any function of matrix or matrices and scalars that returns a matrix or a scalar, such as ``norm``, ``mean``, ``sum``, ``countNonZero``, ``trace``, ``determinant``, ``repeat``, and others.
*
Matrix initializers ( ``eye(), zeros(), ones()`` ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :cpp:class:`Mat` description).
Matrix initializers ( ``eye(), zeros(), ones()`` ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :ocv:class:`Mat` description).
*
``Mat_<destination_type>()`` constructors to cast the result to the proper type.
@ -699,45 +699,45 @@ Below is the formal description of the ``Mat`` methods.
Mat::Mat
------------
..cpp:function:: Mat::Mat()
..ocv:function:: Mat::Mat()
..cpp:function:: Mat::Mat(int rows, int cols, int type)
..ocv:function:: Mat::Mat(int rows, int cols, int type)
..cpp:function:: Mat::Mat(Size size, int type)
..ocv:function:: Mat::Mat(Size size, int type)
..cpp:function:: Mat::Mat(int rows, int cols, int type, const Scalar& s)
..ocv:function:: Mat::Mat(int rows, int cols, int type, const Scalar& s)
..cpp:function:: Mat::Mat(Size size, int type, const Scalar& s)
..ocv:function:: Mat::Mat(Size size, int type, const Scalar& s)
..cpp:function:: Mat::Mat(const Mat& m)
..ocv:function:: Mat::Mat(const Mat& m)
..cpp:function:: Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP)
..ocv:function:: Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP)
..cpp:function:: Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP)
..ocv:function:: Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP)
..cpp:function:: Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange)
..ocv:function:: Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange)
..cpp:function:: Mat::Mat(const Mat& m, const Rect& roi)
..ocv:function:: Mat::Mat(const Mat& m, const Rect& roi)
..cpp:function:: Mat::Mat(const CvMat* m, bool copyData=false)
..ocv:function:: Mat::Mat(const CvMat* m, bool copyData=false)
..cpp:function:: Mat::Mat(const Mat& m, const Range* ranges)
..ocv:function:: Mat::Mat(const Mat& m, const Range* ranges)
Provides various array constructors.
@ -757,7 +757,7 @@ Mat::Mat
:param data:Pointer to the user data. Matrix constructors that take ``data`` and ``step`` parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically deallocated, so you should take care of it.
:param step:Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to ``AUTO_STEP`` ), no padding is assumed and the actual step is calculated as ``cols*elemSize()`` . See :cpp:func:`Mat::elemSize` .
:param step:Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to ``AUTO_STEP`` ), no padding is assumed and the actual step is calculated as ``cols*elemSize()`` . See :ocv:func:`Mat::elemSize` .
:param steps:Array of ``ndims-1`` steps in case of a multi-dimensional array (the last step is always set to the element size). If not specified, the matrix is assumed to be continuous.
@ -765,7 +765,7 @@ Mat::Mat
:param img:Pointer to the old-style ``IplImage`` image structure. By default, the data is shared between the original image and the new matrix. But when ``copyData`` is set, the full copy of the image data is created.
:param vec:STL vector whose elements form the matrix. The matrix has a single column and the number of rows equal to the number of vector elements. Type of the matrix matches the type of vector elements. The constructor can handle arbitrary types, for which there is a properly declared :cpp:class:`DataType` . This means that the vector elements must be primitive numbers or uni-type numerical tuples of numbers. Mixed-type structures are not supported. The corresponding constructor is explicit. Since STL vectors are not automatically converted to ``Mat`` instances, you should write ``Mat(vec)`` explicitly. Unless you copy the data into the matrix ( ``copyData=true`` ), no new elements will be added to the vector because it can potentially yield vector data reallocation, and, thus, the matrix data pointer will be invalid.
:param vec:STL vector whose elements form the matrix. The matrix has a single column and the number of rows equal to the number of vector elements. Type of the matrix matches the type of vector elements. The constructor can handle arbitrary types, for which there is a properly declared :ocv:class:`DataType` . This means that the vector elements must be primitive numbers or uni-type numerical tuples of numbers. Mixed-type structures are not supported. The corresponding constructor is explicit. Since STL vectors are not automatically converted to ``Mat`` instances, you should write ``Mat(vec)`` explicitly. Unless you copy the data into the matrix ( ``copyData=true`` ), no new elements will be added to the vector because it can potentially yield vector data reallocation, and, thus, the matrix data pointer will be invalid.
:param copyData:Flag to specify whether the underlying data of the STL vector or the old-style ``CvMat`` or ``IplImage`` should be copied to (``true``) or shared with (``false``) the newly constructed matrix. When the data is copied, the allocated buffer is managed using ``Mat`` reference counting mechanism. While the data is shared, the reference counter is NULL, and you should not deallocate the data until the matrix is not destructed.
@ -779,30 +779,30 @@ Mat::Mat
These are various constructors that form a matrix. As noted in the :ref:`AutomaticAllocation`,
often the default constructor is enough, and the proper matrix will be allocated by an OpenCV function. The constructed matrix can further be assigned to another matrix or matrix expression or can be allocated with
:cpp:func:`Mat::create` . In the former case, the old content is de-referenced.
:ocv:func:`Mat::create` . In the former case, the old content is de-referenced.
Mat::~Mat
------------
..cpp:function:: Mat::~Mat()
..ocv:function:: Mat::~Mat()
Provides a matrix destructor.
The matrix destructor calls
:cpp:func:`Mat::release` .
:ocv:func:`Mat::release` .
Mat::operator =
-------------------
..cpp:function:: Mat& Mat::operator = (const Mat& m)
..ocv:function:: Mat& Mat::operator = (const Mat& m)
:param m:Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via :cpp:func:`Mat::release` .
:param m:Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via :ocv:func:`Mat::release` .
:param expr:Assigned matrix expression object. As opposite to the first form of the assignment operation, the second form can reuse already allocated matrix if it has the right size and type to fit the matrix expression result. It is automatically handled by the real function that the matrix expressions is expanded to. For example, ``C=A+B`` is expanded to ``add(A, B, C)`` , and :func:`add` takes care of automatic ``C`` reallocation.
@ -813,7 +813,7 @@ These are available assignment operators. Since they all are very different, mak
Provides a ``Mat`` -to- ``MatExpr`` cast operator.
@ -822,7 +822,7 @@ The cast operator should not be called explicitly. It is used internally by the
Mat::row
------------
..cpp:function:: Mat Mat::row(int i) const
..ocv:function:: Mat Mat::row(int i) const
Creates a matrix header for the specified matrix row.
@ -846,7 +846,7 @@ The method makes a new header for the specified matrix row and returns it. This
This happens because ``A.row(i)`` forms a temporary header that is further assigned to another header. Remember that each of these operations is O(1), that is, no data is copied. Thus, the above assignment is not true if you may have expected the j-th row to be copied to the i-th row. To achieve that, you should either turn this simple assignment into an expression or use the
:cpp:func:`Mat::copyTo` method: ::
:ocv:func:`Mat::copyTo` method: ::
Mat A;
...
@ -858,21 +858,21 @@ The method makes a new header for the specified matrix row and returns it. This
Mat::col
------------
..cpp:function:: Mat Mat::col(int j) const
..ocv:function:: Mat Mat::col(int j) const
Creates a matrix header for the specified matrix column.
:param j:A 0-based column index.
The method makes a new header for the specified matrix column and returns it. This is an O(1) operation, regardless of the matrix size. The underlying data of the new matrix is shared with the original matrix. See also the
:cpp:func:`Mat::row` description.
:ocv:func:`Mat::row` description.
Mat::rowRange
-----------------
..cpp:function:: Mat Mat::rowRange(int startrow, int endrow) const
..ocv:function:: Mat Mat::rowRange(int startrow, int endrow) const
..cpp:function:: Mat Mat::rowRange(const Range& r) const
..ocv:function:: Mat Mat::rowRange(const Range& r) const
Creates a matrix header for the specified row span.
@ -880,17 +880,17 @@ Mat::rowRange
:param endrow:A 0-based ending index of the row span.
:param r::cpp:class:`Range` structure containing both the start and the end indices.
:param r::ocv:class:`Range` structure containing both the start and the end indices.
The method makes a new header for the specified row span of the matrix. Similarly to
:cpp:func:`Mat::row` and
:cpp:func:`Mat::col` , this is an O(1) operation.
:ocv:func:`Mat::row` and
:ocv:func:`Mat::col` , this is an O(1) operation.
Mat::colRange
-----------------
..cpp:function:: Mat Mat::colRange(int startcol, int endcol) const
..ocv:function:: Mat Mat::colRange(int startcol, int endcol) const
..cpp:function:: Mat Mat::colRange(const Range& r) const
..ocv:function:: Mat Mat::colRange(const Range& r) const
Creates a matrix header for the specified row span.
@ -898,17 +898,17 @@ Mat::colRange
:param endcol:A 0-based ending index of the column span.
:param r::cpp:class:`Range` structure containing both the start and the end indices.
:param r::ocv:class:`Range` structure containing both the start and the end indices.
The method makes a new header for the specified column span of the matrix. Similarly to
:cpp:func:`Mat::row` and
:cpp:func:`Mat::col` , this is an O(1) operation.
:ocv:func:`Mat::row` and
:ocv:func:`Mat::col` , this is an O(1) operation.
Mat::diag
-------------
..cpp:function:: Mat Mat::diag(int d) const
..ocv:function:: Mat Mat::diag(int d) const
..cpp:function:: static Mat Mat::diag(const Mat& matD)
..ocv:function:: static Mat Mat::diag(const Mat& matD)
Extracts a diagonal from a matrix, or creates a diagonal matrix.
@ -923,12 +923,12 @@ Mat::diag
:param matD:Single-column matrix that forms a diagonal matrix.
The method makes a new header for the specified matrix diagonal. The new matrix is represented as a single-column matrix. Similarly to
:cpp:func:`Mat::row` and
:cpp:func:`Mat::col` , this is an O(1) operation.
:ocv:func:`Mat::row` and
:ocv:func:`Mat::col` , this is an O(1) operation.
Mat::clone
--------------
..cpp:function:: Mat Mat::clone() const
..ocv:function:: Mat Mat::clone() const
Creates a full copy of the array and the underlying data.
@ -937,8 +937,8 @@ The method creates a full copy of the array. The original ``step[]`` is not take
Mat::copyTo
---------------
..cpp:function:: void Mat::copyTo( OutputArray m ) const
..cpp:function:: void Mat::copyTo( OutputArray m, InputArray mask ) const
..ocv:function:: void Mat::copyTo( OutputArray m ) const
..ocv:function:: void Mat::copyTo( OutputArray m, InputArray mask ) const
Copies the matrix to another one.
@ -957,7 +957,7 @@ When the operation mask is specified, and the ``Mat::create`` call shown above r
Mat::convertTo
------------------
..cpp:function:: void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const
..ocv:function:: void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const
Converts an array to another datatype with optional scaling.
@ -978,7 +978,7 @@ The method converts source pixel values to the target datatype. ``saturate_cast<
Mat::assignTo
-----------------
..cpp:function:: void Mat::assignTo( Mat& m, int type=-1 ) const
..ocv:function:: void Mat::assignTo( Mat& m, int type=-1 ) const
Provides a functional form of ``convertTo``.
@ -991,7 +991,7 @@ This is an internally used method called by the
Sets all or some of the array elements to the specified value.
@ -1002,7 +1002,7 @@ Mat::setTo
Mat::reshape
----------------
..cpp:function:: Mat Mat::reshape(int cn, int rows=0) const
..ocv:function:: Mat Mat::reshape(int cn, int rows=0) const
Changes the shape and/or the number of channels of a 2D matrix without copying the data.
@ -1017,7 +1017,7 @@ The method makes a new matrix header for ``*this`` elements. The new matrix may
*
No data is copied. That is, this is an O(1) operation. Consequently, if you change the number of rows, or the operation changes the indices of elements row in some other way, the matrix must be continuous. See
:cpp:func:`Mat::isContinuous` .
:ocv:func:`Mat::isContinuous` .
For example, if there is a set of 3D points stored as an STL vector, and you want to represent the points as a ``3xN`` matrix, do the following: ::
@ -1035,7 +1035,7 @@ For example, if there is a set of 3D points stored as an STL vector, and you wan
Mat::t
----------
..cpp:function:: MatExpr Mat::t() const
..ocv:function:: MatExpr Mat::t() const
Transposes a matrix.
@ -1047,7 +1047,7 @@ The method performs matrix transposition by means of matrix expressions. It does
@ -1064,7 +1064,7 @@ The method performs a matrix inversion by means of matrix expressions. This mean
Mat::mul
------------
..cpp:function:: MatExpr Mat::mul(InputArray m, double scale=1) const
..ocv:function:: MatExpr Mat::mul(InputArray m, double scale=1) const
Performs an element-wise multiplication or division of the two matrices.
@ -1081,7 +1081,7 @@ Example: ::
Mat::cross
--------------
..cpp:function:: Mat Mat::cross(InputArray m) const
..ocv:function:: Mat Mat::cross(InputArray m) const
Computes a cross-product of two 3-element vectors.
@ -1092,7 +1092,7 @@ The method computes a cross-product of two 3-element vectors. The vectors must b
Mat::dot
------------
..cpp:function:: double Mat::dot(InputArray m) const
..ocv:function:: double Mat::dot(InputArray m) const
Computes a dot-product of two vectors.
@ -1103,9 +1103,9 @@ The method computes a dot-product of two matrices. If the matrices are not singl
Mat::zeros
--------------
..cpp:function:: static MatExpr Mat::zeros(int rows, int cols, int type)
..cpp:function:: static MatExpr Mat::zeros(Size size, int type)
..cpp:function:: static MatExpr Mat::zeros(int ndims, const int* sizes, int type)
..ocv:function:: static MatExpr Mat::zeros(int rows, int cols, int type)
..ocv:function:: static MatExpr Mat::zeros(Size size, int type)
..ocv:function:: static MatExpr Mat::zeros(int ndims, const int* sizes, int type)
Returns a zero array of the specified size and type.
@ -1132,9 +1132,9 @@ In the example above, a new matrix is allocated only if ``A`` is not a 3x3 float
Mat::ones
-------------
..cpp:function:: static MatExpr Mat::ones(int rows, int cols, int type)
..cpp:function:: static MatExpr Mat::ones(Size size, int type)
..cpp:function:: static MatExpr Mat::ones(int ndims, const int* sizes, int type)
..ocv:function:: static MatExpr Mat::ones(int rows, int cols, int type)
..ocv:function:: static MatExpr Mat::ones(Size size, int type)
..ocv:function:: static MatExpr Mat::ones(int ndims, const int* sizes, int type)
Returns an array of all 1's of the specified size and type.
@ -1151,7 +1151,7 @@ Mat::ones
:param type:Created matrix type.
The method returns a Matlab-style 1's array initializer, similarly to
:cpp:func:`Mat::zeros`. Note that using this method you can initialize an array with an arbitrary value, using the following Matlab idiom:::
:ocv:func:`Mat::zeros`. Note that using this method you can initialize an array with an arbitrary value, using the following Matlab idiom:::
Mat A = Mat::ones(100, 100, CV_8U)*3; // make 100x100 matrix filled with 3.
@ -1161,8 +1161,8 @@ The above operation does not form a 100x100 matrix of 1's and then multiply it b
Mat::eye
------------
..cpp:function:: static MatExpr Mat::eye(int rows, int cols, int type)
..cpp:function:: static MatExpr Mat::eye(Size size, int type)
..ocv:function:: static MatExpr Mat::eye(int rows, int cols, int type)
..ocv:function:: static MatExpr Mat::eye(Size size, int type)
Returns an identity matrix of the specified size and type.
@ -1175,8 +1175,8 @@ Mat::eye
:param type:Created matrix type.
The method returns a Matlab-style identity matrix initializer, similarly to
:cpp:func:`Mat::zeros`. Similarly to
:cpp:func:`Mat::ones`, you can use a scale operation to create a scaled identity matrix efficiently:::
:ocv:func:`Mat::zeros`. Similarly to
:ocv:func:`Mat::ones`, you can use a scale operation to create a scaled identity matrix efficiently:::
// make a 4x4 diagonal matrix with 0.1's on the diagonal.
Mat A = Mat::eye(4, 4, CV_32F)*0.1;
@ -1184,9 +1184,9 @@ The method returns a Matlab-style identity matrix initializer, similarly to
Mat::create
---------------
..cpp:function:: void Mat::create(int rows, int cols, int type)
..cpp:function:: void Mat::create(Size size, int type)
..cpp:function:: void Mat::create(int ndims, const int* sizes, int type)
..ocv:function:: void Mat::create(int rows, int cols, int type)
..ocv:function:: void Mat::create(Size size, int type)
..ocv:function:: void Mat::create(int ndims, const int* sizes, int type)
Allocates new array data if needed.
@ -1206,7 +1206,7 @@ This is one of the key ``Mat`` methods. Most new-style OpenCV functions and meth
#.
If the current array shape and the type match the new ones, return immediately. Otherwise, de-reference the previous data by calling
:cpp:func:`Mat::release`.
:ocv:func:`Mat::release`.
#.
Initialize the new header.
@ -1238,29 +1238,29 @@ because ``cvtColor`` , as well as the most of OpenCV functions, calls ``Mat::cre
Mat::addref
---------------
..cpp:function:: void Mat::addref()
..ocv:function:: void Mat::addref()
Increments the reference counter.
The method increments the reference counter associated with the matrix data. If the matrix header points to an external data set (see
:cpp:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. Normally, to avoid memory leaks, the method should not be called explicitly. It is called implicitly by the matrix assignment operator. The reference counter increment is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads.
:ocv:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. Normally, to avoid memory leaks, the method should not be called explicitly. It is called implicitly by the matrix assignment operator. The reference counter increment is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads.
Mat::release
----------------
..cpp:function:: void Mat::release()
..ocv:function:: void Mat::release()
Decrements the reference counter and deallocates the matrix if needed.
The method decrements the reference counter associated with the matrix data. When the reference counter reaches 0, the matrix data is deallocated and the data and the reference counter pointers are set to NULL's. If the matrix header points to an external data set (see
:cpp:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case.
:ocv:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case.
This method can be called manually to force the matrix data deallocation. But since this method is automatically called in the destructor, or by any other method that changes the data pointer, it is usually not needed. The reference counter decrement and check for 0 is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads.
Mat::resize
---------------
..cpp:function:: void Mat::resize( size_t sz )
..cpp:function:: void Mat::resize( size_t sz, const Scalar& s )
..ocv:function:: void Mat::resize( size_t sz )
..ocv:function:: void Mat::resize( size_t sz, const Scalar& s )
Changes the number of matrix rows.
@ -1272,7 +1272,7 @@ The methods change the number of matrix rows. If the matrix is reallocated, the
Mat::reserve
---------------
..cpp:function:: void Mat::reserve( size_t sz )
..ocv:function:: void Mat::reserve( size_t sz )
Reserves space for the certain number of rows.
@ -1282,8 +1282,8 @@ The method reserves space for ``sz`` rows. If the matrix already has enough spac
:param ofs:Output parameter that contains an offset of ``*this`` inside the whole matrix.
After you extracted a submatrix from a matrix using
:cpp:func:`Mat::row`,
:cpp:func:`Mat::col`,
:cpp:func:`Mat::rowRange`,
:cpp:func:`Mat::colRange` , and others, the resultant submatrix points just to the part of the original big matrix. However, each submatrix contains information (represented by ``datastart`` and ``dataend`` fields) that helps reconstruct the original matrix size and the position of the extracted submatrix within the original matrix. The method ``locateROI`` does exactly that.
:ocv:func:`Mat::row`,
:ocv:func:`Mat::col`,
:ocv:func:`Mat::rowRange`,
:ocv:func:`Mat::colRange` , and others, the resultant submatrix points just to the part of the original big matrix. However, each submatrix contains information (represented by ``datastart`` and ``dataend`` fields) that helps reconstruct the original matrix size and the position of the extracted submatrix within the original matrix. The method ``locateROI`` does exactly that.
Mat::adjustROI
------------------
..cpp:function:: Mat& Mat::adjustROI( int dtop, int dbottom, int dleft, int dright )
..ocv:function:: Mat& Mat::adjustROI( int dtop, int dbottom, int dleft, int dright )
Adjusts a submatrix size and position within the parent matrix.
@ -1334,7 +1334,7 @@ Mat::adjustROI
:param dright:Shift of the right submatrix boundary to the right.
The method is complimentary to
:cpp:func:`Mat::locateROI` . The typical use of these functions is to determine the submatrix position within the parent matrix and then shift the position somehow. Typically, it can be required for filtering operations when pixels outside of the ROI should be taken into account. When all the method parameters are positive, the ROI needs to grow in all directions by the specified amount, for example:::
:ocv:func:`Mat::locateROI` . The typical use of these functions is to determine the submatrix position within the parent matrix and then shift the position somehow. Typically, it can be required for filtering operations when pixels outside of the ROI should be taken into account. When all the method parameters are positive, the ROI needs to grow in all directions by the specified amount, for example:::
A.adjustROI(2, 2, 2, 2);
@ -1344,19 +1344,19 @@ In this example, the matrix size is increased by 4 elements in each direction. T
It is your responsibility to make sure ``adjustROI`` does not cross the parent matrix boundary. If it does, the function signals an error.
The function is used internally by the OpenCV filtering functions, like
:cpp:func:`filter2D` , morphological operations, and so on.
:ocv:func:`filter2D` , morphological operations, and so on.
See Also:
:cpp:func:`copyMakeBorder`
:ocv:func:`copyMakeBorder`
Mat::operator()
-------------------
..cpp:function:: Mat Mat::operator()( Range rowRange, Range colRange ) const
..ocv:function:: Mat Mat::operator()( Range rowRange, Range colRange ) const
..cpp:function:: Mat Mat::operator()( const Rect& roi ) const
..ocv:function:: Mat Mat::operator()( const Rect& roi ) const
..cpp:function:: Mat Mat::operator()( const Ranges* ranges ) const
..ocv:function:: Mat Mat::operator()( const Ranges* ranges ) const
Extracts a rectangular submatrix.
@ -1369,15 +1369,15 @@ Mat::operator()
:param ranges:Array of selected ranges along each array dimension.
The operators make a new header for the specified sub-array of ``*this`` . They are the most generalized forms of
:cpp:func:`Mat::row`,
:cpp:func:`Mat::col`,
:cpp:func:`Mat::rowRange`, and
:cpp:func:`Mat::colRange` . For example, ``A(Range(0, 10), Range::all())`` is equivalent to ``A.rowRange(0, 10)`` . Similarly to all of the above, the operators are O(1) operations, that is, no matrix data is copied.
:ocv:func:`Mat::row`,
:ocv:func:`Mat::col`,
:ocv:func:`Mat::rowRange`, and
:ocv:func:`Mat::colRange` . For example, ``A(Range(0, 10), Range::all())`` is equivalent to ``A.rowRange(0, 10)`` . Similarly to all of the above, the operators are O(1) operations, that is, no matrix data is copied.
Mat::operator CvMat
-----------------------
..cpp:function:: Mat::operator CvMat() const
..ocv:function:: Mat::operator CvMat() const
Creates the ``CvMat`` header for the matrix.
@ -1395,7 +1395,7 @@ where ``mycvOldFunc`` is a function written to work with OpenCV 1.x data structu
Mat::operator IplImage
--------------------------
..cpp:function:: Mat::operator IplImage() const
..ocv:function:: Mat::operator IplImage() const
Creates the ``IplImage`` header for the matrix.
@ -1403,7 +1403,7 @@ The operator creates the ``IplImage`` header for the matrix without copying the
Mat::total
--------------
..cpp:function:: size_t Mat::total() const
..ocv:function:: size_t Mat::total() const
Returns the total number of array elements.
@ -1411,14 +1411,14 @@ The method returns the number of array elements (a number of pixels if the array
Mat::isContinuous
---------------------
..cpp:function:: bool Mat::isContinuous() const
..ocv:function:: bool Mat::isContinuous() const
Reports whether the matrix is continuous or not.
The method returns ``true`` if the matrix elements are stored continuously without gaps at the end of each row. Otherwise, it returns ``false``. Obviously, ``1x1`` or ``1xN`` matrices are always continuous. Matrices created with
:cpp:func:`Mat::create` are always continuous. But if you extract a part of the matrix using
:cpp:func:`Mat::col`,
:cpp:func:`Mat::diag` , and so on, or constructed a matrix header for externally allocated data, such matrices may no longer have this property.
:ocv:func:`Mat::create` are always continuous. But if you extract a part of the matrix using
:ocv:func:`Mat::col`,
:ocv:func:`Mat::diag` , and so on, or constructed a matrix header for externally allocated data, such matrices may no longer have this property.
The continuity flag is stored as a bit in the ``Mat::flags`` field and is computed automatically when you construct a matrix header. Thus, the continuity check is a very fast operation, though theoretically it could be done as follows: ::
@ -1477,12 +1477,12 @@ The method is used in quite a few of OpenCV functions. The point is that element
This approach, while being very simple, can boost the performance of a simple element-operation by 10-20 percents, especially if the image is rather small and the operation is quite simple.
Another OpenCV idiom in this function, a call of
:cpp:func:`Mat::create` for the destination array, that allocates the destination array unless it already has the proper size and type. And while the newly allocated arrays are always continuous, you still need to check the destination array because :cpp:func:`create` does not always allocate a new matrix.
:ocv:func:`Mat::create` for the destination array, that allocates the destination array unless it already has the proper size and type. And while the newly allocated arrays are always continuous, you still need to check the destination array because :ocv:func:`create` does not always allocate a new matrix.
Mat::elemSize
-----------------
..cpp:function:: size_t Mat::elemSize(void) const
..ocv:function:: size_t Mat::elemSize(void) const
Returns the matrix element size in bytes.
@ -1491,7 +1491,7 @@ The method returns the matrix element size in bytes. For example, if the matrix
Mat::elemSize1
------------------
..cpp:function:: size_t Mat::elemSize() const
..ocv:function:: size_t Mat::elemSize() const
Returns the size of each matrix element channel in bytes.
@ -1500,7 +1500,7 @@ The method returns the matrix element channel size in bytes, that is, it ignores
Mat::type
-------------
..cpp:function:: int Mat::type() const
..ocv:function:: int Mat::type() const
Returns the type of a matrix element.
@ -1509,7 +1509,7 @@ The method returns a matrix element type. This is an identifier compatible with
Mat::depth
--------------
..cpp:function:: int Mat::depth() const
..ocv:function:: int Mat::depth() const
Returns the depth of a matrix element.
@ -1532,7 +1532,7 @@ The method returns the identifier of the matrix element depth (the type of each
Mat::channels
-----------------
..cpp:function:: int Mat::channels() const
..ocv:function:: int Mat::channels() const
Returns the number of matrix channels.
@ -1541,17 +1541,17 @@ The method returns the number of matrix channels.
Mat::step1
--------------
..cpp:function:: size_t Mat::step1() const
..ocv:function:: size_t Mat::step1() const
Returns a normalized step.
The method returns a matrix step divided by
:cpp:func:`Mat::elemSize1()` . It can be useful to quickly access an arbitrary matrix element.
:ocv:func:`Mat::elemSize1()` . It can be useful to quickly access an arbitrary matrix element.
Mat::size
-------------
..cpp:function:: Size Mat::size() const
..ocv:function:: Size Mat::size() const
Returns a matrix size.
@ -1560,7 +1560,7 @@ The method returns a matrix size: ``Size(cols, rows)`` .
Mat::empty
--------------
..cpp:function:: bool Mat::empty() const
..ocv:function:: bool Mat::empty() const
Returns ``true`` if the array has no elemens.
@ -1569,43 +1569,43 @@ The method returns ``true`` if ``Mat::total()`` is 0 or if ``Mat::data`` is NULL
The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements of any type that
:cpp:class:`Mat` can store. *Sparse* means that only non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its stored elements can actually become 0. It is up to you to detect such elements and delete them using ``SparseMat::erase`` ). The non-zero elements are stored in a hash table that grows when it is filled so that the search time is O(1) in average (regardless of whether element is there or not). Elements can be accessed using the following methods:
:ocv:class:`Mat` can store. *Sparse* means that only non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its stored elements can actually become 0. It is up to you to detect such elements and delete them using ``SparseMat::erase`` ). The non-zero elements are stored in a hash table that grows when it is filled so that the search time is O(1) in average (regardless of whether element is there or not). Elements can be accessed using the following methods:
*
Query operations ( ``SparseMat::ptr`` and the higher-level ``SparseMat::ref``, ``SparseMat::value`` and ``SparseMat::find`` ), for example:
@ -2020,7 +2020,7 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su
..
*
Sparse matrix iterators. They are similar to ``MatIterator`` but different from :cpp:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users:
Sparse matrix iterators. They are similar to ``MatIterator`` but different from :ocv:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users:
::
@ -2080,10 +2080,10 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su
SparseMat\_
-----------
..cpp:class:: SparseMat_
..ocv:class:: SparseMat_
Template sparse n-dimensional array class derived from
:cpp:class:`SparseMat` ::
:ocv:class:`SparseMat` ::
template<typename _Tp> class SparseMat_ : public SparseMat
{
@ -2133,7 +2133,7 @@ Template sparse n-dimensional array class derived from
SparseMatConstIterator_<_Tp> end() const;
};
``SparseMat_`` is a thin wrapper on top of :cpp:class:`SparseMat` created in the same way as ``Mat_`` .
``SparseMat_`` is a thin wrapper on top of :ocv:class:`SparseMat` created in the same way as ``Mat_`` .
@ -10,7 +10,7 @@ with ``CV_RGB`` or the :ref:`Scalar` constructor
) for color
images and brightness for grayscale images. For color images, the channel ordering
is normally *Blue, Green, Red*.
This is what :cpp:func:`imshow`, :cpp:func:`imread`, and :cpp:func:`imwrite` expect.
This is what :ocv:func:`imshow`, :ocv:func:`imread`, and :ocv:func:`imwrite` expect.
So, if you form a color using the
:ref:`Scalar` constructor, it should look like:
@ -19,7 +19,7 @@ So, if you form a color using the
\texttt{Scalar} (blue \_ component, green \_ component, red \_ component[, alpha \_ component])
If you are using your own image rendering and I/O functions, you can use any channel ordering. The drawing functions process each channel independently and do not depend on the channel order or even on the used color space. The whole image can be converted from BGR to RGB or to a different color space using
:cpp:func:`cvtColor` .
:ocv:func:`cvtColor` .
If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also, many drawing functions can handle pixel coordinates specified with sub-pixel accuracy. This means that the coordinates can be passed as fixed-point numbers encoded as integers. The number of fractional bits is specified by the ``shift`` parameter and the real point coordinates are calculated as
:math:`\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})` . This feature is especially effective when rendering antialiased shapes.
@ -32,7 +32,7 @@ The functions do not support alpha-transparency when the target image is 4-chann
circle
----------
..cpp:function:: void circle(Mat& img, Point center, int radius, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..ocv:function:: void circle(Mat& img, Point center, int radius, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
Draws a circle.
@ -46,7 +46,7 @@ circle
:param thickness:Thickness of the circle outline if positive. Negative thickness means that a filled circle is to be drawn.
:param lineType:Type of the circle boundary. See :cpp:func:`line` description.
:param lineType:Type of the circle boundary. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the center's coordinates and in the radius value.
@ -56,9 +56,9 @@ The function ``circle`` draws a simple or filled circle with a given center and
@ -77,9 +77,9 @@ They return ``false`` if the line segment is completely outside the rectangle. O
ellipse
-----------
..cpp:function:: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..ocv:function:: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..cpp:function:: void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, int thickness=1, int lineType=8)
..ocv:function:: void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, int thickness=1, int lineType=8)
Draws a simple or thick elliptic arc or fills an ellipse sector.
@ -101,15 +101,15 @@ ellipse
:param thickness:Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
:param lineType:Type of the ellipse boundary. See :cpp:func:`line` description.
:param lineType:Type of the ellipse boundary. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the center's coordinates and axes' values.
The functions ``ellipse`` with less parameters draw an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector.
A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using
:cpp:func:`ellipse2Poly` and then render it with
:cpp:func:`polylines` or fill it with
:cpp:func:`fillPoly` . If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass ``startAngle=0`` and ``endAngle=360`` . The picture below explains the meaning of the parameters.
:ocv:func:`ellipse2Poly` and then render it with
:ocv:func:`polylines` or fill it with
:ocv:func:`fillPoly` . If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass ``startAngle=0`` and ``endAngle=360`` . The picture below explains the meaning of the parameters.
**Figure 1. Parameters of Elliptic Arc**
@ -119,15 +119,15 @@ A piecewise-linear curve is used to approximate the elliptic arc boundary. If yo
ellipse2Poly
----------------
..cpp:function:: void ellipse2Poly( Point center, Size axes, int angle, int startAngle, int endAngle, int delta, vector<Point>& pts )
..ocv:function:: void ellipse2Poly( Point center, Size axes, int angle, int startAngle, int endAngle, int delta, vector<Point>& pts )
Approximates an elliptic arc with a polyline.
:param center:Center of the arc.
:param axes:Half-sizes of the arc. See :cpp:func:`ellipse` for details.
:param axes:Half-sizes of the arc. See :ocv:func:`ellipse` for details.
:param angle: Rotation angle of the ellipse in degrees. See :cpp:func:`ellipse` for details.
:param angle: Rotation angle of the ellipse in degrees. See :ocv:func:`ellipse` for details.
:param startAngle: Starting angle of the elliptic arc in degrees.
@ -138,13 +138,13 @@ ellipse2Poly
:param pts:Output vector of polyline vertices.
The function ``ellipse2Poly`` computes the vertices of a polyline that approximates the specified elliptic arc. It is used by
:cpp:func:`ellipse` .
:ocv:func:`ellipse` .
..index:: fillConvexPoly
fillConvexPoly
------------------
..cpp:function:: void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0)
..ocv:function:: void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0)
Fills a convex polygon.
@ -156,7 +156,7 @@ fillConvexPoly
:param color:Polygon color.
:param lineType:Type of the polygon boundaries. See :cpp:func:`line` description.
:param lineType:Type of the polygon boundaries. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the vertex coordinates.
@ -168,7 +168,7 @@ that is, a polygon whose contour intersects every horizontal line (scan line) tw
fillPoly
------------
..cpp:function:: void fillPoly(Mat& img, const Point** pts, const int* npts, int ncontours, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() )
..ocv:function:: void fillPoly(Mat& img, const Point** pts, const int* npts, int ncontours, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() )
Fills the area bounded by one or more polygons.
@ -182,7 +182,7 @@ fillPoly
:param color:Polygon color.
:param lineType:Type of the polygon boundaries. See :cpp:func:`line` description.
:param lineType:Type of the polygon boundaries. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the vertex coordinates.
@ -193,17 +193,17 @@ areas with holes, contours with self-intersections (some of thier parts), and so
getTextSize
---------------
..cpp:function:: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine)
..ocv:function:: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine)
Calculates the width and height of a text string.
:param text:Input text string.
:param fontFace:Font to use. See :cpp:func:`putText` for details.
:param fontFace:Font to use. See :ocv:func:`putText` for details.
:param fontScale: Font scale. See :cpp:func:`putText` for details.
:param fontScale: Font scale. See :ocv:func:`putText` for details.
:param thickness: Thickness of lines used to render the text. See :cpp:func:`putText` for details.
:param thickness: Thickness of lines used to render the text. See :ocv:func:`putText` for details.
:param baseLine: Output parameter - y-coordinate of the baseline relative to the bottom-most text point.
@ -244,7 +244,7 @@ That is, the following code renders some text, the tight box surrounding it, and
line
--------
..cpp:function:: void line(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..ocv:function:: void line(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
Draws a line segment connecting two points.
@ -321,9 +321,9 @@ The number of pixels along the line is stored in ``LineIterator::count`` . ::
rectangle
-------------
..cpp:function:: void rectangle(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..ocv:function:: void rectangle(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..cpp:function:: void rectangle(Mat& img, Rect r, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
..ocv:function:: void rectangle(Mat& img, Rect r, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
Draws a simple, thick, or filled up-right rectangle.
@ -339,7 +339,7 @@ rectangle
:param thickness:Thickness of lines that make up the rectangle. Negative values, like ``CV_FILLED`` , mean that the function has to draw a filled rectangle.
:param lineType:Type of the line. See :cpp:func:`line` description.
:param lineType:Type of the line. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the point coordinates.
@ -349,7 +349,7 @@ The function ``rectangle`` draws a rectangle outline or a filled rectangle whose
polylines
-------------
..cpp:function:: void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
..ocv:function:: void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
Draws several polygonal curves.
@ -367,7 +367,7 @@ polylines
:param thickness:Thickness of the polyline edges.
:param lineType:Type of the line segments. See :cpp:func:`line` description.
:param lineType:Type of the line segments. See :ocv:func:`line` description.
:param shift:Number of fractional bits in the vertex coordinates.
@ -377,7 +377,7 @@ The function ``polylines`` draws one or more polygonal curves.
putText
-----------
..cpp:function:: void putText( Mat& img, const string& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false )
..ocv:function:: void putText( Mat& img, const string& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false )
Draws a text string.
@ -403,5 +403,5 @@ putText
The function ``putText`` renders the specified text string in the image.
Symbols that cannot be rendered using the specified font are
replaced by question marks. See
:cpp:func:`getTextSize` for a text rendering code example.
:ocv:func:`getTextSize` for a text rendering code example.
The generic function ``deallocate`` deallocates the buffer allocated with
:cpp:func:`allocate` . The number of elements must match the number passed to
:cpp:func:`allocate` .
:ocv:func:`allocate` . The number of elements must match the number passed to
:ocv:func:`allocate` .
..index:: CV_Assert
@ -73,7 +73,7 @@ The generic function ``deallocate`` deallocates the buffer allocated with
CV_Assert
---------
..cpp:function:: CV_Assert(expr)
..ocv:function:: CV_Assert(expr)
Checks a condition at runtime. ::
@ -84,17 +84,17 @@ CV_Assert
:param expr:Expression to check.
The macros ``CV_Assert`` and ``CV_DbgAssert`` evaluate the specified expression. If it is 0, the macros raise an error (see
:cpp:func:`error` ). The macro ``CV_Assert`` checks the condition in both Debug and Release configurations, while ``CV_DbgAssert`` is only retained in the Debug configuration.
:ocv:func:`error` ). The macro ``CV_Assert`` checks the condition in both Debug and Release configurations, while ``CV_DbgAssert`` is only retained in the Debug configuration.
@ -148,13 +148,13 @@ Exception class passed to error ::
};
The class ``Exception`` encapsulates all or almost all the necessary information about the error happened in the program. The exception is usually constructed and thrown implicitly via ``CV_Error`` and ``CV_Error_`` macros. See
:cpp:func:`error` .
:ocv:func:`error` .
..index:: fastMalloc
fastMalloc
--------------
..cpp:function:: void* fastMalloc(size_t size)
..ocv:function:: void* fastMalloc(size_t size)
Allocates an aligned memory buffer.
@ -166,74 +166,74 @@ The function allocates the buffer of the specified size and returns it. When the
fastFree
------------
..cpp:function:: void fastFree(void* ptr)
..ocv:function:: void fastFree(void* ptr)
Deallocates a memory buffer.
:param ptr:Pointer to the allocated buffer.
The function deallocates the buffer allocated with
:cpp:func:`fastMalloc` .
:ocv:func:`fastMalloc` .
If NULL pointer is passed, the function does nothing.
The function acts like ``sprintf`` but forms and returns an STL string. It can be used to form an error message in the
:cpp:func:`Exception` constructor.
:ocv:func:`Exception` constructor.
..index:: getNumThreads
getNumThreads
-----------------
..cpp:function:: int getNumThreads()
..ocv:function:: int getNumThreads()
Returns the number of threads used by OpenCV.
The function returns the number of threads that is used by OpenCV.
See Also:
:cpp:func:`setNumThreads`,
:cpp:func:`getThreadNum`
:ocv:func:`setNumThreads`,
:ocv:func:`getThreadNum`
..index:: getThreadNum
getThreadNum
----------------
..cpp:function:: int getThreadNum()
..ocv:function:: int getThreadNum()
Returns the index of the currently executed thread.
The function returns a 0-based index of the currently executed thread. The function is only valid inside a parallel OpenMP region. When OpenCV is built without OpenMP support, the function always returns 0.
See Also:
:cpp:func:`setNumThreads`,
:cpp:func:`getNumThreads` .
:ocv:func:`setNumThreads`,
:ocv:func:`getNumThreads` .
..index:: getTickCount
getTickCount
----------------
..cpp:function:: int64 getTickCount()
..ocv:function:: int64 getTickCount()
Returns the number of ticks.
The function returns the number of ticks after the certain event (for example, when the machine was turned on).
It can be used to initialize
:cpp:func:`RNG` or to measure a function execution time by reading the tick count before and after the function call. See also the tick frequency.
:ocv:func:`RNG` or to measure a function execution time by reading the tick count before and after the function call. See also the tick frequency.
..index:: getTickFrequency
getTickFrequency
--------------------
..cpp:function:: double getTickFrequency()
..ocv:function:: double getTickFrequency()
Returns the number of ticks per second.
@ -248,7 +248,7 @@ That is, the following code computes the execution time in seconds: ::
getCPUTickCount
----------------
..cpp:function:: int64 getCPUTickCount()
..ocv:function:: int64 getCPUTickCount()
Returns the number of CPU ticks.
@ -258,7 +258,7 @@ The function returns the current number of CPU ticks on some architectures (such
setNumThreads
-----------------
..cpp:function:: void setNumThreads(int nthreads)
..ocv:function:: void setNumThreads(int nthreads)
Sets the number of threads used by OpenCV.
@ -267,14 +267,14 @@ setNumThreads
The function sets the number of threads used by OpenCV in parallel OpenMP regions. If ``nthreads=0`` , the function uses the default number of threads that is usually equal to the number of the processing cores.
See Also:
:cpp:func:`getNumThreads`,
:cpp:func:`getThreadNum`
:ocv:func:`getNumThreads`,
:ocv:func:`getThreadNum`
..index:: setUseOptimized
setUseOptimized
-----------------
..cpp:function:: void setUseOptimized(bool onoff)
..ocv:function:: void setUseOptimized(bool onoff)
Enables or disables the optimized code.
@ -288,7 +288,7 @@ By default, the optimized code is enabled (unless you disable it in CMake). The
Adds descriptors to train a descriptor collection. If the collection ``trainDescCollectionis`` is not empty, the new descriptors are added to existing train descriptors.
Trains a descriptor matcher (for example, the flann index). In all methods to match, the method ``train()`` is run every time before matching. Some descriptor matchers (for example, ``BruteForceMatcher``) have an empty implementation of this method. Other matchers really train their inner structures (for example, ``FlannBasedMatcher`` trains ``flann::Index`` ).
Finds the k best matches for each descriptor from a query set.
@ -200,15 +200,15 @@ DescriptorMatcher::knnMatch
:param compactResult:Parameter that is used when the mask (or masks) is not empty. If ``compactResult`` is false, the ``matches`` vector has the same size as ``queryDescriptors`` rows. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
These extended variants of :cpp:func:`DescriptorMatcher::match` methods find several best matches for each query descriptor. The matches are returned in the distance increasing order. See :cpp:func:`DescriptorMatcher::match` for the details about query and train descriptors.
These extended variants of :ocv:func:`DescriptorMatcher::match` methods find several best matches for each query descriptor. The matches are returned in the distance increasing order. See :ocv:func:`DescriptorMatcher::match` for the details about query and train descriptors.
Creates a descriptor matcher of a given type with the default parameters (using default constructor).
@ -353,7 +353,7 @@ FlannBasedMatcher
-----------------
..c:type:: FlannBasedMatcher
Flann-based descriptor matcher. This matcher trains :ref:`flann::Index` on a train descriptor collection and calls its nearest search methods to find the best matches. So, this matcher may be faster when matching a large train collection than the brute force matcher. ``FlannBasedMatcher`` does not support masking permissible matches of descriptor sets because :cpp:func:`flann::Index` does not support this. ::
Flann-based descriptor matcher. This matcher trains :ref:`flann::Index` on a train descriptor collection and calls its nearest search methods to find the best matches. So, this matcher may be faster when matching a large train collection than the brute force matcher. ``FlannBasedMatcher`` does not support masking permissible matches of descriptor sets because :ocv:func:`flann::Index` does not support this. ::
class FlannBasedMatcher : public DescriptorMatcher
@ -175,7 +175,7 @@ for example: ``"GridFAST"``, ``"PyramidSTAR"`` .
FastFeatureDetector
-------------------
..cpp:class:: FastFeatureDetector
..ocv:class:: FastFeatureDetector
Wrapping class for feature detection using the
:ref:`FAST` method ::
@ -197,7 +197,7 @@ Wrapping class for feature detection using the
GoodFeaturesToTrackDetector
---------------------------
..cpp:class:: GoodFeaturesToTrackDetector
..ocv:class:: GoodFeaturesToTrackDetector
Wrapping class for feature detection using the
:ref:`goodFeaturesToTrack` function ::
@ -240,7 +240,7 @@ Wrapping class for feature detection using the
MserFeatureDetector
-------------------
..cpp:class:: MserFeatureDetector
..ocv:class:: MserFeatureDetector
Wrapping class for feature detection using the
:ref:`MSER` class ::
@ -266,7 +266,7 @@ Wrapping class for feature detection using the
StarFeatureDetector
-------------------
..cpp:class:: StarFeatureDetector
..ocv:class:: StarFeatureDetector
Wrapping class for feature detection using the
:ref:`StarDetector` class ::
@ -290,7 +290,7 @@ Wrapping class for feature detection using the
SiftFeatureDetector
-------------------
..cpp:class:: SiftFeatureDetector
..ocv:class:: SiftFeatureDetector
Wrapping class for feature detection using the
:ref:`SIFT` class ::
@ -319,7 +319,7 @@ Wrapping class for feature detection using the
SurfFeatureDetector
-------------------
..cpp:class:: SurfFeatureDetector
..ocv:class:: SurfFeatureDetector
Wrapping class for feature detection using the
:ref:`SURF` class ::
@ -342,7 +342,7 @@ Wrapping class for feature detection using the
OrbFeatureDetector
-------------------
..cpp:class:: OrbFeatureDetector
..ocv:class:: OrbFeatureDetector
Wrapping class for feature detection using the
:ref:`ORB` class ::
@ -364,7 +364,7 @@ Wrapping class for feature detection using the
SimpleBlobDetector
-------------------
..cpp:class:: SimpleBlobDetector
..ocv:class:: SimpleBlobDetector
Class for extracting blobs from an image ::
@ -402,7 +402,7 @@ Class for extracting blobs from an image ::
...
};
The class implements a simple algorithm for extracting blobs from an image. It converts the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds. Then connected components are extracted from every binary image by :cpp:func:`findContours` and their centers are calculated. Centers from several binary images are grouped by their coordinates. Close centers form one group that corresponds to one blob and this is controled by the ``minDistBetweenBlobs`` parameter. Then final centers of blobs and their radiuses are estimated from these groups and returned as locations and sizes of keypoints.
The class implements a simple algorithm for extracting blobs from an image. It converts the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds. Then connected components are extracted from every binary image by :ocv:func:`findContours` and their centers are calculated. Centers from several binary images are grouped by their coordinates. Close centers form one group that corresponds to one blob and this is controled by the ``minDistBetweenBlobs`` parameter. Then final centers of blobs and their radiuses are estimated from these groups and returned as locations and sizes of keypoints.
This class performs several filtrations of returned blobs. You should set ``filterBy*`` to true/false to turn on/off corresponding filtration. Available filtrations:
@ -426,7 +426,7 @@ Default values of parameters are tuned to extract dark circular blobs.
GridAdaptedFeatureDetector
--------------------------
..cpp:class:: GridAdaptedFeatureDetector
..ocv:class:: GridAdaptedFeatureDetector
Class adapting a detector to partition the source image into a grid and detect points in each cell ::
@ -456,7 +456,7 @@ Class adapting a detector to partition the source image into a grid and detect p
PyramidAdaptedFeatureDetector
-----------------------------
..cpp:class:: PyramidAdaptedFeatureDetector
..ocv:class:: PyramidAdaptedFeatureDetector
Class adapting a detector to detect points over multiple levels of a Gaussian pyramid. Consider using this class for detectors that are not inherently scaled. ::
@ -477,7 +477,7 @@ Class adapting a detector to detect points over multiple levels of a Gaussian py
DynamicAdaptedFeatureDetector
-----------------------------
..cpp:class:: DynamicAdaptedFeatureDetector
..ocv:class:: DynamicAdaptedFeatureDetector
Adaptively adjusting detector that iteratively detects features until the desired number is found ::
@ -522,7 +522,7 @@ Example of creating ``DynamicAdaptedFeatureDetector`` : ::
..cpp:function:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjuster, int min_features, int max_features, int max_iters )
..ocv:function:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>& adjuster, int min_features, int max_features, int max_iters )
Class providing an interface for adjusting parameters of a feature detector. This interface is used by :ref:`DynamicAdaptedFeatureDetector` . It is a wrapper for :ref:`FeatureDetector` that enables adjusting parameters after feature detection. ::
@ -563,7 +563,7 @@ See
AdjusterAdapter::tooFew
---------------------------
..cpp:function:: void AdjusterAdapter::tooFew(int min, int n_detected)
..ocv:function:: void AdjusterAdapter::tooFew(int min, int n_detected)
Adjusts the detector parameters to detect more features.
@ -583,7 +583,7 @@ Example: ::
AdjusterAdapter::tooMany
----------------------------
..cpp:function:: void AdjusterAdapter::tooMany(int max, int n_detected)
..ocv:function:: void AdjusterAdapter::tooMany(int max, int n_detected)
Adjusts the detector parameters to detect less features.
@ -7,15 +7,15 @@ Matchers of keypoint descriptors in OpenCV have wrappers with a common interface
between different algorithms solving the same problem. This section is devoted to matching descriptors
that cannot be represented as vectors in a multidimensional space. ``GenericDescriptorMatcher`` is a more generic interface for descriptors. It does not make any assumptions about descriptor representation.
Every descriptor with the
:cpp:class:`DescriptorExtractor` interface has a wrapper with the ``GenericDescriptorMatcher`` interface (see
:cpp:class:`VectorDescriptorMatcher` ).
:ocv:class:`DescriptorExtractor` interface has a wrapper with the ``GenericDescriptorMatcher`` interface (see
:ocv:class:`VectorDescriptorMatcher` ).
There are descriptors such as the One-way descriptor and Ferns that have the ``GenericDescriptorMatcher`` interface implemented but do not support ``DescriptorExtractor``.
..index:: GenericDescriptorMatcher
GenericDescriptorMatcher
------------------------
..cpp:class:: GenericDescriptorMatcher
..ocv:class:: GenericDescriptorMatcher
Abstract interface for extracting and matching a keypoint descriptor. There are also :ref:`DescriptorExtractor` and :ref:`DescriptorMatcher` for these purposes but their interfaces are intended for descriptors represented as vectors in a multidimensional space. ``GenericDescriptorMatcher`` is a more generic interface for descriptors. :ref:`DescriptorMatcher` and ``GenericDescriptorMatcher`` have two groups of match methods: for matching keypoints of an image with another image or with an image set. ::
@ -83,7 +83,7 @@ Abstract interface for extracting and matching a keypoint descriptor. There are
Returns a signature for an image patch similarly to ``getSignature`` but uses a threshold for removing all signature elements below the threshold so that the signature is compressed.
Returns the count of all descriptors stored in the training set.
@ -67,11 +67,11 @@ BOWTrainer::descripotorsCount
BOWTrainer::cluster
-----------------------
..cpp:function:: Mat BOWTrainer::cluster() const
..ocv:function:: Mat BOWTrainer::cluster() const
Clusters train descriptors. The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first variant of the method, train descriptors stored in the object are clustered. In the second variant, input descriptors are clustered.
..cpp:function:: Mat BOWTrainer::cluster( const Mat& descriptors ) const
..ocv:function:: Mat BOWTrainer::cluster( const Mat& descriptors ) const
:param descriptors:Descriptors to cluster. Each row of the ``descriptors`` matrix is a descriptor. Descriptors are not added to the inner train descriptor set.
@ -81,7 +81,7 @@ BOWTrainer::cluster
BOWKMeansTrainer
----------------
..cpp:class:: BOWKMeansTrainer
..ocv:class:: BOWKMeansTrainer
:ref:`kmeans` -based class to train visual vocabulary using the *bag of visual words* approach ::
@ -111,7 +111,7 @@ arguments.
BOWImgDescriptorExtractor
-------------------------
..cpp:class:: BOWImgDescriptorExtractor
..ocv:class:: BOWImgDescriptorExtractor
Class to compute an image descriptor using the ''bag of visual words''. Such a computation consists of the following steps:
@ -146,7 +146,7 @@ Here is the class declaration ::
..cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
..ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
..cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F)
..ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F)
Enables the ``StereoBeliefPropagation`` constructors.
For more details, see [Pedro F. Felzenszwalb and Daniel P. Huttenlocher. Efficient belief propagation for early vision. International Journal of Computer Vision, 70(1), October 2006].
By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement:
By default, :ocv:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement:
..math::
@ -211,7 +211,7 @@ By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics
..cpp:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels)
..ocv:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels)
Uses a heuristic method to compute the recommended parameters (``ndisp``, ``iters`` and ``levels``) for the specified image size (``width`` and ``height``).
..cpp:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F)
..ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F)
..cpp:function:: StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F)
..ocv:function:: StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F)
Enables the StereoConstantSpaceBP constructors.
@ -355,7 +355,7 @@ By default, ``StereoConstantSpaceBP`` uses floating-point arithmetics and the ``
..cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
..ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
..cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
..ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
Enables the ``DisparityBilateralFilter`` constructors.
This lightweight class encapsulates pitched memory on a GPU and is passed to nvcc-compiled code (CUDA kernels). Typically, it is used internally by OpenCV and by users who write device code. You can call its members from both host and device code. ::
@ -44,10 +44,10 @@ This lightweight class encapsulates pitched memory on a GPU and is passed to nvc
gpu::PtrStep\_
--------------
..cpp:class:: gpu::PtrStep\_
..ocv:class:: gpu::PtrStep\_
This structure is similar to
:cpp:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code.
:ocv:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code.
::
template<typename T> struct PtrStep_
@ -75,10 +75,10 @@ This structure is similar to
gpu::PtrElemStrp\_
------------------
..cpp:class:: gpu::PtrElemStrp\_
..ocv:class:: gpu::PtrElemStrp\_
This structure is similar to
:cpp:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code.
:ocv:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code.
::
template<typename T> struct PtrElemStep_ : public PtrStep_<T>
@ -93,7 +93,7 @@ This structure is similar to
gpu::GpuMat
-----------
..cpp:class:: gpu::GpuMat
..ocv:class:: gpu::GpuMat
This is a base storage class for GPU memory with reference counting. Its interface matches the
:c:type:`Mat` interface with the following limitations:
@ -105,7 +105,7 @@ This is a base storage class for GPU memory with reference counting. Its interfa
*
no expression templates technique support
Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :cpp:class:`gpu::DevMem2D_` and :cpp:class:`gpu::PtrStep_` so it can be passed directly to kernel.
Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :ocv:class:`gpu::DevMem2D_` and :ocv:class:`gpu::PtrStep_` so it can be passed directly to kernel.
**Note:**
@ -148,16 +148,16 @@ In contrast with :c:type:`Mat`, in most cases ``GpuMat::isContinuous() == false`
You are not recommended to leave static or global ``GpuMat`` variables allocated, that is to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
See Also:
:cpp:func:`Mat`
:ocv:func:`Mat`
..index:: gpu::CudaMem
gpu::CudaMem
------------
..cpp:class:: gpu::CudaMem
..ocv:class:: gpu::CudaMem
This class with reference counting wraps special memory type allocation functions from CUDA. Its interface is also
:cpp:func:`Mat`-like but with additional memory type parameters.
:ocv:func:`Mat`-like but with additional memory type parameters.
*
``ALLOC_PAGE_LOCKED``: Sets a page locked memory type, used commonly for fast and asynchronous uploading/downloading data from/to GPU.
@ -206,24 +206,24 @@ Allocation size of such memory types is usually limited. For more details, see "
gpu::CudaMem::createMatHeader
---------------------------------
..cpp:function:: Mat gpu::CudaMem::createMatHeader() const
..ocv:function:: Mat gpu::CudaMem::createMatHeader() const
Creates a header without reference counting to :cpp:class:`gpu::CudaMem` data.
Creates a header without reference counting to :ocv:class:`gpu::CudaMem` data.
Maps CPU memory to GPU address space and creates the :cpp:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy).
Maps CPU memory to GPU address space and creates the :ocv:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy).
Returns ``true`` if the current hardware supports address space mapping and ``ALLOC_ZEROCOPY`` memory allocation.
@ -231,9 +231,9 @@ gpu::CudaMem::canMapHostMemory
gpu::Stream
-----------
..cpp:class:: gpu::Stream
..ocv:class:: gpu::Stream
This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :cpp:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :cpp:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :cpp:class:`gpu::CudaMem`.
This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :ocv:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :ocv:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :ocv:class:`gpu::CudaMem`.
**Note:**
@ -279,7 +279,7 @@ Currently, you may face problems if an operation is enqueued twice with differen
Blocks the current CPU thread until all operations in the stream are complete.
@ -295,9 +295,9 @@ gpu::Stream::waitForCompletion
gpu::StreamAccessor
-------------------
..cpp:class:: gpu::StreamAccessor
..ocv:class:: gpu::StreamAccessor
This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code.
This class enables getting ``cudaStream_t`` from :ocv:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code.
::
struct StreamAccessor
@ -310,7 +310,7 @@ This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is
gpu::createContinuous
-------------------------
..cpp:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
..ocv:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
Creates a continuous matrix in the GPU memory.
@ -325,11 +325,11 @@ gpu::createContinuous
The following wrappers are also available:
* .. cpp:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
* .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
* .. cpp:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
* .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
* .. cpp:function:: GpuMat gpu::createContinuous(Size size, int type)
* .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
Matrix is called continuous if its elements are stored continuously, that is without gaps in the end of each row.
@ -337,9 +337,9 @@ gpu::createContinuous
gpu::ensureSizeIsEnough
---------------------------
..cpp:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
..ocv:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
..cpp:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m)
..ocv:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m)
Ensures that the size of a matrix is big enough and the matrix has a proper type. The function does not reallocate memory if the matrix has proper attributes already.
This class is used for extracting Speeded Up Robust Features (SURF) from an image.
::
@ -93,7 +93,7 @@ See Also: :c:type:`SURF`
gpu::BruteForceMatcher_GPU
--------------------------
..cpp:class:: gpu::BruteForceMatcher_GPU
..ocv:class:: gpu::BruteForceMatcher_GPU
This is a brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets. ::
@ -188,20 +188,20 @@ See Also: :c:type:`DescriptorMatcher`, :c:type:`BruteForceMatcher`
Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
:param queryDescs: Query set of descriptors.
:param trainCollection: :cpp:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors.
:param trainCollection: :ocv:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors.
:param trainIdx: The output single-row ``CV_32SC1`` matrix that contains the best train index for each query. If some query descriptors are masked out in ``maskCollection`` , it contains -1.
:param distance: The output single-row ``CV_32FC1`` matrix that contains the best distance for each query. If some query descriptors are masked out in ``maskCollection`` , it contains ``FLT_MAX``.
:param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector<GpuMat>`` by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask.
:param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector<GpuMat>`` by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask.
Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance.
Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance. Results will be stored in the GPU memory.
Downloads ``trainIdx`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
Downloads ``trainIdx`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
For each query descriptor, finds the best matches with a distance less than a given threshold. The function returns detected matches in the increasing order by distance.
For each query descriptor, finds the best matches with a distance less than a given threshold (``maxDistance``). The results are stored in the GPU memory.
:param mask:Mask specifying permissible matches between the input query and train matrices of descriptors.
In contrast to :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1.
In contrast to :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1.
Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
This is a base class for linear or non-linear filters that processes rows of 2D arrays. Such filters are used for the "horizontal" filtering passes in separable filters. ::
@ -27,13 +27,13 @@ This is a base class for linear or non-linear filters that processes rows of 2D
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
..index:: gpu::BaseColumnFilter_GPU
gpu::BaseColumnFilter_GPU
-------------------------
..cpp:class:: gpu::BaseColumnFilter_GPU
..ocv:class:: gpu::BaseColumnFilter_GPU
This is a base class for linear or non-linear filters that processes columns of 2D arrays. Such filters are used for the "vertical" filtering passes in separable filters. ::
@ -49,13 +49,13 @@ This is a base class for linear or non-linear filters that processes columns of
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
..index:: gpu::BaseFilter_GPU
gpu::BaseFilter_GPU
-------------------
..cpp:class:: gpu::BaseFilter_GPU
..ocv:class:: gpu::BaseFilter_GPU
This is a base class for non-separable 2D filters. ::
@ -72,13 +72,13 @@ This is a base class for non-separable 2D filters. ::
**Note:**
This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`.
This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
..index:: gpu::FilterEngine_GPU
gpu::FilterEngine_GPU
---------------------
..cpp:class:: gpu::FilterEngine_GPU
..ocv:class:: gpu::FilterEngine_GPU
This is a base class for Filter Engine. ::
@ -93,7 +93,7 @@ This is a base class for Filter Engine. ::
The class can be used to apply an arbitrary filtering operation to an image. It contains all the necessary intermediate buffers. Pointers to the initialized ``FilterEngine_GPU`` instances are returned by various ``create*Filter_GPU`` functions (see below), and they are used inside high-level functions such as
:cpp:func:`gpu::filter2D`, :cpp:func:`gpu::erode`, :cpp:func:`gpu::Sobel` , and others.
:ocv:func:`gpu::filter2D`, :ocv:func:`gpu::erode`, :ocv:func:`gpu::Sobel` , and others.
By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary memory allocation for intermediate buffers and get much better performance:
::
@ -124,13 +124,13 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem
..cpp:function:: Ptr<FilterEngine_GPU> gpu::createFilter2D_GPU( const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType)
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createFilter2D_GPU( const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType)
Creates a non-separable filter engine with the specified filter.
@ -140,13 +140,13 @@ gpu::createFilter2D_GPU
:param dstType:Output image type. It must be supported by ``filter2D`` .
Usually this function is used inside such high-level functions as :cpp:func:`gpu::createLinearFilter_GPU`, :cpp:func:`gpu::createBoxFilter_GPU`.
Usually this function is used inside such high-level functions as :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`.
..index:: gpu::createSeparableFilter_GPU
gpu::createSeparableFilter_GPU
----------------------------------
..cpp:function:: Ptr<FilterEngine_GPU> gpu::createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>& rowFilter, const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType)
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>& rowFilter, const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType)
Creates a separable filter engine with the specified filters.
..cpp:function:: Ptr<BaseFilter_GPU> gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1))
..ocv:function:: Ptr<BaseFilter_GPU> gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1))
:param srcType:Input image type. ``CV_8UC1`` and ``CV_8UC4`` types are supported.
@ -407,13 +407,13 @@ gpu::createLinearFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`createLinearFilter`
See Also: :ocv:func:`createLinearFilter`
..index:: gpu::filter2D
gpu::filter2D
-----------------
..cpp:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1))
..ocv:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1))
Applies the non-separable 2D linear filter to an image.
@ -431,13 +431,13 @@ gpu::filter2D
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`filter2D`
See Also: :ocv:func:`filter2D`
..index:: gpu::Laplacian
gpu::Laplacian
------------------
..cpp:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1)
..ocv:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1)
Applies the Laplacian operator to an image.
@ -447,21 +447,21 @@ gpu::Laplacian
:param ddepth:Desired depth of the destination image. It supports only the same depth as the source image depth.
:param ksize:Aperture size used to compute the second-derivative filters (see :cpp:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param ksize:Aperture size used to compute the second-derivative filters (see :ocv:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param scale:Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :cpp:func:`getDerivKernels` ).
:param scale:Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :ocv:func:`getDerivKernels` ).
**Note:**
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :cpp:func:`Laplacian`,:cpp:func:`gpu::filter2D` .
See Also: :ocv:func:`Laplacian`,:ocv:func:`gpu::filter2D` .
..index:: gpu::getLinearRowFilter_GPU
gpu::getLinearRowFilter_GPU
-------------------------------
..cpp:function:: Ptr<BaseRowFilter_GPU> gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
..ocv:function:: Ptr<BaseRowFilter_GPU> gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates a primitive row filter with the specified kernel.
@ -473,19 +473,19 @@ gpu::getLinearRowFilter_GPU
:param anchor:Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType:Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`. For details on limitations, see below.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``,``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside the image.
See Also:,:cpp:func:`createSeparableLinearFilter` .
See Also:,:ocv:func:`createSeparableLinearFilter` .
..index:: gpu::getLinearColumnFilter_GPU
gpu::getLinearColumnFilter_GPU
----------------------------------
..cpp:function:: Ptr<BaseColumnFilter_GPU> gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
..ocv:function:: Ptr<BaseColumnFilter_GPU> gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates a primitive column filter with the specified kernel.
:param anchor:Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType:Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` . For details on limitations, see below.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` . For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
..index:: gpu::createSeparableLinearFilter_GPU
gpu::createSeparableLinearFilter_GPU
----------------------------------------
..cpp:function:: Ptr<FilterEngine_GPU> gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
:param anchor:Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center.
:param rowBorderType, columnBorderType:Pixel extrapolation method in the horizontal and vertical directions For details, see :cpp:func:`borderInterpolate`. For details on limitations, see :cpp:func:`gpu::getLinearRowFilter_GPU`, cpp:cpp:func:`gpu::getLinearColumnFilter_GPU`.
:param rowBorderType, columnBorderType:Pixel extrapolation method in the horizontal and vertical directions For details, see :ocv:func:`borderInterpolate`. For details on limitations, see :ocv:func:`gpu::getLinearRowFilter_GPU`, cpp:ocv:func:`gpu::getLinearColumnFilter_GPU`.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`gpu::getLinearColumnFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`gpu::getLinearColumnFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
..index:: gpu::sepFilter2D
gpu::sepFilter2D
--------------------
..cpp:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Applies a separable 2D linear filter to an image.
@ -544,15 +544,15 @@ gpu::sepFilter2D
:param anchor:Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center.
:param rowBorderType, columnBorderType:Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`.
:param rowBorderType, columnBorderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`sepFilter2D`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`sepFilter2D`
..index:: gpu::createDerivFilter_GPU
gpu::createDerivFilter_GPU
------------------------------
..cpp:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates a filter engine for the generalized Sobel operator.
@ -564,17 +564,17 @@ gpu::createDerivFilter_GPU
:param dy:Derivative order in respect of y.
:param ksize:Aperture size. See :cpp:func:`getDerivKernels` for details.
:param ksize:Aperture size. See :ocv:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createDerivFilter`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createDerivFilter`
..index:: gpu::Sobel
gpu::Sobel
--------------
..cpp:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Applies the generalized Sobel operator to an image.
@ -590,17 +590,17 @@ gpu::Sobel
:param ksize:Size of the extended Sobel kernel. Possible valies are 1, 3, 5 or 7.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :cpp:func:`getDerivKernels` .
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` .
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Sobel`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Sobel`
..index:: gpu::Scharr
gpu::Scharr
---------------
..cpp:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Calculates the first x- or y- image derivative using the Scharr operator.
@ -614,37 +614,37 @@ gpu::Scharr
:param yorder:Order of the derivative y.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` and :cpp:func:`Scharr` .
:param rowBorderType, columnBorderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` and :ocv:func:`Scharr` .
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Scharr`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Scharr`
..index:: gpu::createGaussianFilter_GPU
gpu::createGaussianFilter_GPU
---------------------------------
..cpp:function:: Ptr<FilterEngine_GPU> gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates a Gaussian filter engine.
:param type:Source and destination image type. ``CV_8UC1``, ``CV_8UC4``, ``CV_16SC1``, ``CV_16SC2``, ``CV_32SC1``, ``CV_32FC1`` are supported.
:param ksize:Aperture size. See :cpp:func:`getGaussianKernel` for details.
:param ksize:Aperture size. See :ocv:func:`getGaussianKernel` for details.
:param sigmaX:Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` for details.
:param sigmaX:Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` for details.
:param sigmaY:Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` .
:param rowBorderType, columnBorderType:Border type to use. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Border type to use. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createGaussianFilter`
See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createGaussianFilter`
:param ksize:Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigmaX`` and ``sigmaY`` .
:param sigmaX, sigmaY:Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` .
:param sigmaX, sigmaY:Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` .
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createGaussianFilter_GPU`, :cpp:func:`GaussianBlur`
See Also: :ocv:func:`gpu::createGaussianFilter_GPU`, :ocv:func:`GaussianBlur`
..index:: gpu::getMaxFilter_GPU
gpu::getMaxFilter_GPU
-------------------------
..cpp:function:: Ptr<BaseFilter_GPU> gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
..ocv:function:: Ptr<BaseFilter_GPU> gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
Creates the maximum filter.
@ -684,7 +684,7 @@ gpu::getMaxFilter_GPU
gpu::getMinFilter_GPU
-------------------------
..cpp:function:: Ptr<BaseFilter_GPU> gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
..ocv:function:: Ptr<BaseFilter_GPU> gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
..cpp:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
..ocv:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
Performs mean-shift filtering for each point of the source image. It maps each point of the source image into another point. As a result, you have a new color and new position of each point.
@ -19,13 +19,13 @@ gpu::meanShiftFiltering
:param sr:Color window radius.
:param criteria:Termination criteria. See :cpp:class:`TermCriteria`.
:param criteria:Termination criteria. See :ocv:class:`TermCriteria`.
Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix. Use to handle real matrices (``CV32FC1``) and complex matrices in the interleaved format (``CV32FC2``).
@ -237,15 +237,15 @@ gpu::dft
If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width.
Applies a generic geometrical transformation to an image.
@ -354,15 +354,15 @@ gpu::remap
Values of pixels with non-integer coordinates are computed using bilinear the interpolation.
See Also: :cpp:func:`remap`
See Also: :ocv:func:`remap`
..index:: gpu::cvtColor
gpu::cvtColor
-----------------
..cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0)
..ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0)
..cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream)
..ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream)
Converts an image from one color space to another.
@ -370,7 +370,7 @@ gpu::cvtColor
:param dst:Destination image with the same size and depth as ``src`` .
:param code:Color space conversion code. For details, see :cpp:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported.
:param code:Color space conversion code. For details, see :ocv:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported.
:param dcn:Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from ``src`` and the ``code`` .
@ -379,15 +379,15 @@ gpu::cvtColor
3-channel color spaces (like ``HSV``, ``XYZ``, and so on) can be stored in a 4-channel image for better perfomance.
:param interpolation:Interpolation method. Only ``INTER_NEAREST`` and ``INTER_LINEAR`` are supported.
See Also: :cpp:func:`resize`
See Also: :ocv:func:`resize`
..index:: gpu::warpAffine
gpu::warpAffine
-------------------
..cpp:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
..ocv:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
Applies an affine transformation to an image.
@ -457,16 +457,16 @@ gpu::warpAffine
:param dsize:Size of the destination image.
:param flags:Combination of interpolation methods (see :cpp:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
:param flags:Combination of interpolation methods (see :ocv:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
See Also:
:cpp:func:`warpAffine`
:ocv:func:`warpAffine`
..index:: gpu::warpPerspective
gpu::warpPerspective
------------------------
..cpp:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
..ocv:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR)
Applies a perspective transformation to an image.
@ -478,16 +478,16 @@ gpu::warpPerspective
:param dsize:Size of the destination image.
:param flags:Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
:param flags:Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
Returns the number of installed CUDA-enabled devices. Use this function before any other GPU functions calls. If OpenCV is compiled without GPU support, this function returns 0.
@ -15,7 +15,7 @@ gpu::getCudaEnabledDeviceCount
gpu::setDevice
------------------
..cpp:function:: void setDevice(int device)
..ocv:function:: void setDevice(int device)
Sets a device and initializes it for the current thread. If the call of this function is omitted, a default device is initialized at the fist GPU usage.
@ -25,7 +25,7 @@ gpu::setDevice
gpu::getDevice
------------------
..cpp:function:: int getDevice()
..ocv:function:: int getDevice()
Returns the current device index that was set by ``{gpu::getDevice}`` or initialized by default.
@ -33,7 +33,7 @@ gpu::getDevice
gpu::GpuFeature
---------------
..cpp:class:: gpu::GpuFeature
..ocv:class:: gpu::GpuFeature
This class provides GPU computing features.
::
@ -51,7 +51,7 @@ This class provides GPU computing features.
gpu::DeviceInfo
---------------
..cpp:class:: gpu::DeviceInfo
..ocv:class:: gpu::DeviceInfo
This class provides functionality for querying the specified GPU properties.
::
@ -82,9 +82,9 @@ This class provides functionality for querying the specified GPU properties.
Checks the GPU module and device compatibility. This function returns ``true`` if the GPU module can be run on the specified device. Otherwise, it returns false.
@ -15,9 +15,9 @@ The GPU module depends on the CUDA Toolkit and NVIDIA Performance Primitives lib
The OpenCV GPU module is designed for ease of use and does not require any knowledge of CUDA. Though, such a knowledge will certainly be useful to handle non-trivial cases or achieve the highest performance. It is helpful to understand the cost of various operations, what the GPU does, what the preferred data formats are, and so on. The GPU module is an effective instrument for quick implementation of GPU-accelerated computer vision algorithms. However, if your algorithm involves many simple operations, then, for the best possible performance, you may still need to write your own kernels to avoid extra write and read operations on the intermediate results.
To enable CUDA support, configure OpenCV using ``CMake`` with ``WITH_CUDA=ON`` . When the flag is set and if CUDA is installed, the full-featured OpenCV GPU module is built. Otherwise, the module is still built, but at runtime all functions from the module throw
:cpp:func:`Exception` with ``CV_GpuNotSupported`` error code, except for
:cpp:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the
:cpp:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly.
:ocv:func:`Exception` with ``CV_GpuNotSupported`` error code, except for
:ocv:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the
:ocv:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly.
Compilation for Different NVIDIA* Platforms
-------------------------------------------
@ -34,12 +34,12 @@ By default, the OpenCV GPU module includes:
PTX code for compute capabilities 1.1 and 1.3 (controlled by ``CUDA_ARCH_PTX`` in ``CMake``)
This means that for devices with CC 1.3 and 2.0 binary images are ready to run. For all newer platforms, the PTX code for 1.3 is JIT'ed to a binary image. For devices with CC 1.1 and 1.2, the PTX for 1.1 is JIT'ed. For devices with CC 1.0, no code is available and the functions throw
:cpp:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow.
:ocv:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow.
On a GPU with CC 1.0, you can still compile the GPU module and most of the functions will run flawlessly. To achieve this, add "1.0" to the list of binaries, for example, ``CUDA_ARCH_BIN="1.0 1.3 2.0"`` . The functions that cannot be run on CC 1.0 GPUs throw an exception.
You can always determine at runtime whether the OpenCV GPU-built binaries (or PTX code) are compatible with your GPU. The function
:cpp:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false).
:ocv:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false).
Threading and Multi-threading
------------------------------
@ -57,7 +57,7 @@ In the current version, each of the OpenCV GPU algorithms can use only a single
*
If you use only synchronous functions, create several CPU threads (one per each GPU) and from within each thread create a CUDA context for the corresponding GPU using
:cpp:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU.
:ocv:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU.
*
If you use asynchronous functions, you can use the Driver API to create several CUDA contexts associated with different GPUs but attached to one CPU thread. Within the thread you can switch from one GPU to another by making the corresponding context "current". With non-blocking GPU calls, managing algorithm is clear.
This class provides a histogram of Oriented Gradients [Navneet Dalal and Bill Triggs. Histogram of oriented gradients for human detection. 2005.] descriptor and detector.
::
@ -67,7 +67,7 @@ Interfaces of all methods are kept similar to the ``CPU HOG`` descriptor and det
:param scale0:Coefficient of the detection window increase.
:param group_threshold:Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :cpp:func:`groupRectangles` .
:param group_threshold:Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :ocv:func:`groupRectangles` .
@ -62,7 +62,7 @@ The following code is an example used to generate the figure. ::
setWindowProperty
---------------------
..cpp:function:: void setWindowProperty(const string& name, int prop_id, double prop_value)
..ocv:function:: void setWindowProperty(const string& name, int prop_id, double prop_value)
Changes parameters of a window dynamically.
@ -96,7 +96,7 @@ The function ``setWindowProperty`` enables changing properties of a window.
getWindowProperty
---------------------
..cpp:function:: void getWindowProperty(const string& name, int prop_id)
..ocv:function:: void getWindowProperty(const string& name, int prop_id)
Provides parameters of a window.
@ -122,7 +122,7 @@ The function ``getWindowProperty`` returns properties of a window.
fontQt
----------
..cpp:function:: CvFont fontQt(const string& nameFont, int pointSize = -1, Scalar color = Scalar::all(0), int weight = CV_FONT_NORMAL, int style = CV_STYLE_NORMAL, int spacing = 0)
..ocv:function:: CvFont fontQt(const string& nameFont, int pointSize = -1, Scalar color = Scalar::all(0), int weight = CV_FONT_NORMAL, int style = CV_STYLE_NORMAL, int spacing = 0)
Creates the font to draw a text on an image.
@ -167,7 +167,7 @@ A basic usage of this function is the following: ::
Finds edges in an image using the Canny algorithm.
@ -19,7 +19,7 @@ Canny
:param threshold2:The second threshold for the hysteresis procedure.
:param apertureSize:Aperture size for the :cpp:func:`Sobel` operator.
:param apertureSize:Aperture size for the :ocv:func:`Sobel` operator.
:param L2gradient:Flag indicating whether a more accurate :math:`L_2` norm :math:`=\sqrt{(dI/dx)^2 + (dI/dy)^2}` should be used to compute the image gradient magnitude ( ``L2gradient=true`` ), or a faster default :math:`L_1` norm :math:`=|dI/dx|+|dI/dy|` is enough ( ``L2gradient=false`` ).
:param maxCorners:Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned.
:param qualityLevel:Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see :cpp:func:`cornerMinEigenVal` ) or the Harris function response (see :cpp:func:`cornerHarris` ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the ``qualityLevel=0.01`` , then all the corners with the quality measure less than 15 are rejected.
:param qualityLevel:Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see :ocv:func:`cornerMinEigenVal` ) or the Harris function response (see :ocv:func:`cornerHarris` ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the ``qualityLevel=0.01`` , then all the corners with the quality measure less than 15 are rejected.
:param minDistance:Minimum possible Euclidean distance between the returned corners.
:param mask:Optional region of interest. If the image is not empty (it needs to have the type ``CV_8UC1`` and the same size as ``image`` ), it specifies the region in which the corners are detected.
:param blockSize:Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See :cpp:func:`cornerEigenValsAndVecs` .
:param blockSize:Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See :ocv:func:`cornerEigenValsAndVecs` .
:param useHarrisDetector:Parameter indicating whether to use a Harris detector (see :cpp:func:`cornerHarris`) or :cpp:func:`cornerMinEigenVal`.
:param useHarrisDetector:Parameter indicating whether to use a Harris detector (see :ocv:func:`cornerHarris`) or :ocv:func:`cornerMinEigenVal`.
:param k:Free parameter of the Harris detector.
@ -219,8 +219,8 @@ The function finds the most prominent corners in the image or in the specified i
#.
Function calculates the corner quality measure at every source image pixel using the
:cpp:func:`cornerMinEigenVal` or
:cpp:func:`cornerHarris` .
:ocv:func:`cornerMinEigenVal` or
:ocv:func:`cornerHarris` .
#.
Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are retained).
@ -239,19 +239,19 @@ The function can be used to initialize a point-based tracker of an object.
**Note**: If the function is called with different values ``A`` and ``B`` of the parameter ``qualityLevel`` , and ``A`` > {B}, the vector of returned corners with ``qualityLevel=A`` will be the prefix of the output vector with ``qualityLevel=B`` .
See Also: :cpp:func:`cornerMinEigenVal`,
:cpp:func:`cornerHarris`,
:cpp:func:`calcOpticalFlowPyrLK`,
:cpp:func:`estimateRigidMotion`,
:cpp:func:`PlanarObjectDetector`,
:cpp:func:`OneWayDescriptor`
See Also: :ocv:func:`cornerMinEigenVal`,
:ocv:func:`cornerHarris`,
:ocv:func:`calcOpticalFlowPyrLK`,
:ocv:func:`estimateRigidMotion`,
:ocv:func:`PlanarObjectDetector`,
:ocv:func:`OneWayDescriptor`
..index:: HoughCircles
HoughCircles
------------
..cpp:function:: void HoughCircles( InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )
..ocv:function:: void HoughCircles( InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )
Finds circles in a grayscale image using the Hough transform.
@ -265,7 +265,7 @@ HoughCircles
:param minDist:Minimum distance between the centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed.
:param param1:The first method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the higher threshold of the two passed to the :cpp:func:`Canny` edge detector (the lower one is twice smaller).
:param param1:The first method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the higher threshold of the two passed to the :ocv:func:`Canny` edge detector (the lower one is twice smaller).
:param param2:The second method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first
@ -309,15 +309,15 @@ The function finds circles in a grayscale image using a modification of the Houg
**Note**: Usually the function detects the centers of circles well. However, it may fail to find correct radii. You can assist to the function by specifying the radius range ( ``minRadius`` and ``maxRadius`` ) if you know it. Or, you may ignore the returned radius, use only the center, and find the correct radius using an additional procedure.
Functions and classes described in this section are used to perform various linear or non-linear filtering operations on 2D images (represented as
:cpp:func:`Mat`'s). It means that for each pixel location
:ocv:func:`Mat`'s). It means that for each pixel location
:math:`(x,y)` in the source image (normally, rectangular), its neighborhood is considered and used to compute the response. In case of a linear filter, it is a weighted sum of pixel values. In case of morphological operations, it is the minimum or maximum values, and so on. The computed response is stored in the destination image at the same location
:math:`(x,y)` . It means that the output image will be of the same size as the input image. Normally, the functions support multi-channel arrays, in which case every channel is processed independently. Therefore, the output image will also have the same number of channels as the input one.
Another common feature of the functions and classes described in this section is that, unlike simple arithmetic functions, they need to extrapolate values of some non-existing pixels. For example, if you want to smooth an image using a Gaussian
:math:`3 \times 3` filter, then, when processing the left-most pixels in each row, you need pixels to the left of them, that is, outside of the image. You can let these pixels be the same as the left-most image pixels ("replicated border" extrapolation method), or assume that all the non-existing pixels are zeros ("contant border" extrapolation method), and so on.
OpenCV enables you to specify the extrapolation method. For details, see the function :cpp:func:`borderInterpolate` and discussion of the ``borderType`` parameter in various functions below.
OpenCV enables you to specify the extrapolation method. For details, see the function :ocv:func:`borderInterpolate` and discussion of the ``borderType`` parameter in various functions below.
..index:: BaseColumnFilter
BaseColumnFilter
----------------
..cpp:class:: BaseColumnFilter
..ocv:class:: BaseColumnFilter
Base class for filters with single-column kernels ::
@ -53,21 +53,21 @@ The class ``BaseColumnFilter`` is a base class for filtering data using single-c
where
:math:`F` is a filtering function but, as it is represented as a class, it can produce any side effects, memorize previously processed data, and so on. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the
:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
See Also:
:cpp:func:`BaseRowFilter`,
:cpp:func:`BaseFilter`,
:cpp:func:`FilterEngine`,
:cpp:func:`getColumnSumFilter`,
:cpp:func:`getLinearColumnFilter`,
:cpp:func:`getMorphologyColumnFilter`
:ocv:func:`BaseRowFilter`,
:ocv:func:`BaseFilter`,
:ocv:func:`FilterEngine`,
:ocv:func:`getColumnSumFilter`,
:ocv:func:`getLinearColumnFilter`,
:ocv:func:`getMorphologyColumnFilter`
..index:: BaseFilter
BaseFilter
----------
..cpp:class:: BaseFilter
..ocv:class:: BaseFilter
Base class for 2D image filters ::
@ -103,20 +103,20 @@ The class ``BaseFilter`` is a base class for filtering data using 2D kernels. Fi
where
:math:`F` is a filtering function. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the
:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
See Also:
:cpp:func:`BaseColumnFilter`,
:cpp:func:`BaseRowFilter`,
:cpp:func:`FilterEngine`,
:cpp:func:`getLinearFilter`,
:cpp:func:`getMorphologyFilter`
:ocv:func:`BaseColumnFilter`,
:ocv:func:`BaseRowFilter`,
:ocv:func:`FilterEngine`,
:ocv:func:`getLinearFilter`,
:ocv:func:`getMorphologyFilter`
..index:: BaseRowFilter
BaseRowFilter
-------------
..cpp:class:: BaseRowFilter
..ocv:class:: BaseRowFilter
Base class for filters with single-row kernels ::
@ -144,21 +144,21 @@ The class ``BaseRowFilter`` is a base class for filtering data using single-row
where
:math:`F` is a filtering function. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the
:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
See Also:
:cpp:func:`BaseColumnFilter`,
:cpp:func:`Filter`,
:cpp:func:`FilterEngine`,
:cpp:func:`getLinearRowFilter`,
:cpp:func:`getMorphologyRowFilter`,
:cpp:func:`getRowSumFilter`
:ocv:func:`BaseColumnFilter`,
:ocv:func:`Filter`,
:ocv:func:`FilterEngine`,
:ocv:func:`getLinearRowFilter`,
:ocv:func:`getMorphologyRowFilter`,
:ocv:func:`getRowSumFilter`
..index:: FilterEngine
FilterEngine
------------
..cpp:class:: FilterEngine
..ocv:class:: FilterEngine
Generic image filtering class ::
@ -231,12 +231,12 @@ The class ``FilterEngine`` can be used to apply an arbitrary filtering operation
It contains all the necessary intermediate buffers, computes extrapolated values
of the "virtual" pixels outside of the image, and so on. Pointers to the initialized ``FilterEngine`` instances
are returned by various ``create*Filter`` functions (see below) and they are used inside high-level functions such as
:cpp:func:`filter2D`,
:cpp:func:`erode`,
:cpp:func:`dilate`, and others. Thus, the class plays a key role in many of OpenCV filtering functions.
:ocv:func:`filter2D`,
:ocv:func:`erode`,
:ocv:func:`dilate`, and others. Thus, the class plays a key role in many of OpenCV filtering functions.
This class makes it easier to combine filtering operations with other operations, such as color space conversions, thresholding, arithmetic operations, and others. By combining several operations together you can get much better performance because your data will stay in cache. For example, see below the implementation of the Laplace operator for floating-point images, which is a simplified implementation of
:cpp:func:`Laplacian` :::
:ocv:func:`Laplacian` :::
void laplace_f(const Mat& src, Mat& dst)
{
@ -347,7 +347,7 @@ Unlike the earlier versions of OpenCV, now the filtering operations fully suppor
Explore the data types. As it was mentioned in the
:cpp:func:`BaseFilter` description, the specific filters can process data of any type, despite that ``Base*Filter::operator()`` only takes ``uchar`` pointers and no information about the actual types. To make it all work, the following rules are used:
:ocv:func:`BaseFilter` description, the specific filters can process data of any type, despite that ``Base*Filter::operator()`` only takes ``uchar`` pointers and no information about the actual types. To make it all work, the following rules are used:
*
In case of separable filtering, ``FilterEngine::rowFilter`` is applied first. It transforms the input image data (of type ``srcType`` ) to the intermediate results stored in the internal buffers (of type ``bufType`` ). Then, these intermediate results are processed as
@ -358,21 +358,21 @@ Explore the data types. As it was mentioned in the
In case of non-separable filtering, ``bufType`` must be the same as ``srcType`` . The source data is copied to the temporary buffer, if needed, and then just passed to ``FilterEngine::filter2D`` . That is, the input type for ``filter2D`` is ``srcType`` (= ``bufType`` ) and the output type is ``dstType`` .
See Also:
:cpp:func:`BaseColumnFilter`,
:cpp:func:`BaseFilter`,
:cpp:func:`BaseRowFilter`,
:cpp:func:`createBoxFilter`,
:cpp:func:`createDerivFilter`,
:cpp:func:`createGaussianFilter`,
:cpp:func:`createLinearFilter`,
:cpp:func:`createMorphologyFilter`,
:cpp:func:`createSeparableLinearFilter`
:ocv:func:`BaseColumnFilter`,
:ocv:func:`BaseFilter`,
:ocv:func:`BaseRowFilter`,
:ocv:func:`createBoxFilter`,
:ocv:func:`createDerivFilter`,
:ocv:func:`createGaussianFilter`,
:ocv:func:`createLinearFilter`,
:ocv:func:`createMorphologyFilter`,
:ocv:func:`createSeparableLinearFilter`
..index:: bilateralFilter
bilateralFilter
-------------------
..cpp:function:: void bilateralFilter( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT )
..ocv:function:: void bilateralFilter( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT )
..cpp:function:: void blur( InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT )
..ocv:function:: void blur( InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT )
Smoothes an image using the normalized box filter.
@ -416,16 +416,16 @@ The function smoothes an image using the kernel:
The call ``blur(src, dst, ksize, anchor, borderType)`` is equivalent to ``boxFilter(src, dst, src.type(), anchor, true, borderType)`` .
See Also:
:cpp:func:`boxFilter`,
:cpp:func:`bilateralFilter`,
:cpp:func:`GaussianBlur`,
:cpp:func:`medianBlur`
:ocv:func:`boxFilter`,
:ocv:func:`bilateralFilter`,
:ocv:func:`GaussianBlur`,
:ocv:func:`medianBlur`
..index:: borderInterpolate
borderInterpolate
---------------------
..cpp:function:: int borderInterpolate( int p, int len, int borderType )
..ocv:function:: int borderInterpolate( int p, int len, int borderType )
Computes the source location of an extrapolated pixel.
@ -442,18 +442,18 @@ The function computes and returns the coordinate of the donor pixel, correspondi
Normally, the function is not called directly. It is used inside
:cpp:func:`FilterEngine` and
:cpp:func:`copyMakeBorder` to compute tables for quick extrapolation.
:ocv:func:`FilterEngine` and
:ocv:func:`copyMakeBorder` to compute tables for quick extrapolation.
See Also:
:cpp:func:`FilterEngine`,
:cpp:func:`copyMakeBorder`
:ocv:func:`FilterEngine`,
:ocv:func:`copyMakeBorder`
..index:: boxFilter
boxFilter
-------------
..cpp:function:: void boxFilter( InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT )
..ocv:function:: void boxFilter( InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT )
Smoothes an image using the box filter.
@ -483,24 +483,24 @@ where
Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms,
and so on). If you need to compute pixel sums over variable-size windows, use
:cpp:func:`integral` .
:ocv:func:`integral` .
See Also:
:cpp:func:`boxFilter`,
:cpp:func:`bilateralFilter`,
:cpp:func:`GaussianBlur`,
:cpp:func:`medianBlur`,
:cpp:func:`integral`
:ocv:func:`boxFilter`,
:ocv:func:`bilateralFilter`,
:ocv:func:`GaussianBlur`,
:ocv:func:`medianBlur`,
:ocv:func:`integral`
..index:: buildPyramid
buildPyramid
----------------
..cpp:function:: void buildPyramid( InputArray src, OutputArrayOfArrays dst, int maxlevel )
..ocv:function:: void buildPyramid( InputArray src, OutputArrayOfArrays dst, int maxlevel )
Constructs the Gaussian pyramid for an image.
:param src:Source image. Check :cpp:func:`pyrDown` for the list of supported types.
:param src:Source image. Check :ocv:func:`pyrDown` for the list of supported types.
:param dst:Destination vector of ``maxlevel+1`` images of the same type as ``src`` . ``dst[0]`` will be the same as ``src`` . ``dst[1]`` is the next pyramid layer,
a smoothed and down-sized ``src`` , and so on.
@ -508,13 +508,13 @@ buildPyramid
:param maxlevel:0-based index of the last (the smallest) pyramid layer. It must be non-negative.
The function constructs a vector of images and builds the Gaussian pyramid by recursively applying
:cpp:func:`pyrDown` to the previously built pyramid layers, starting from ``dst[0]==src`` .
:ocv:func:`pyrDown` to the previously built pyramid layers, starting from ``dst[0]==src`` .
..index:: copyMakeBorder
copyMakeBorder
------------------
..cpp:function:: void copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value=Scalar() )
..ocv:function:: void copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value=Scalar() )
Forms a border around an image.
@ -524,12 +524,12 @@ copyMakeBorder
:param top, bottom, left, right:Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate. For example, ``top=1, bottom=1, left=1, right=1`` mean that 1 pixel-wide border needs to be built.
:param borderType:Border type. See :cpp:func:`borderInterpolate` for details.
:param borderType:Border type. See :ocv:func:`borderInterpolate` for details.
:param value:Border value if ``borderType==BORDER_CONSTANT`` .
The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what
:cpp:func:`FilterEngine` or filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling.
:ocv:func:`FilterEngine` or filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling.
The function supports the mode when ``src`` is already in the middle of ``dst`` . In this case, the function does not copy ``src`` itself but simply constructs the border, for example: ::
@ -549,16 +549,16 @@ The function supports the mode when ``src`` is already in the middle of ``dst``
See Also:
:cpp:func:`borderInterpolate`
:ocv:func:`borderInterpolate`
..index:: createBoxFilter
createBoxFilter
-------------------
..cpp:function:: Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
..ocv:function:: Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
..cpp:function:: Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1)
..ocv:function:: Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1)
..cpp:function:: Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
..ocv:function:: Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
Returns a box filter engine.
@ -572,31 +572,31 @@ createBoxFilter
:param anchor:Anchor position with the kernel. Negative values mean that the anchor is at the kernel center.
:param normalize:Flag specifying whether the sums are normalized or not. See :cpp:func:`boxFilter` for details.
:param normalize:Flag specifying whether the sums are normalized or not. See :ocv:func:`boxFilter` for details.
:param scale:Another way to specify normalization in lower-level ``getColumnSumFilter`` .
:param borderType:Border type to use. See :cpp:func:`borderInterpolate` .
:param borderType:Border type to use. See :ocv:func:`borderInterpolate` .
The function is a convenience function that retrieves the horizontal sum primitive filter with
:cpp:func:`getRowSumFilter` , vertical sum filter with
:cpp:func:`getColumnSumFilter` , constructs new
:cpp:func:`FilterEngine` , and passes both of the primitive filters there. The constructed filter engine can be used for image filtering with normalized or unnormalized box filter.
:ocv:func:`getRowSumFilter` , vertical sum filter with
:ocv:func:`getColumnSumFilter` , constructs new
:ocv:func:`FilterEngine` , and passes both of the primitive filters there. The constructed filter engine can be used for image filtering with normalized or unnormalized box filter.
The function itself is used by
:cpp:func:`blur` and
:cpp:func:`boxFilter` .
:ocv:func:`blur` and
:ocv:func:`boxFilter` .
See Also:
:cpp:func:`FilterEngine`,
:cpp:func:`blur`,
:cpp:func:`boxFilter`
:ocv:func:`FilterEngine`,
:ocv:func:`blur`,
:ocv:func:`boxFilter`
..index:: createDerivFilter
createDerivFilter
---------------------
..cpp:function:: Ptr<FilterEngine> createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT )
..ocv:function:: Ptr<FilterEngine> createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT )
Returns an engine for computing image derivatives.
@ -608,57 +608,57 @@ createDerivFilter
:param dy:Derivative order in respect of y.
:param ksize:Aperture size See :cpp:func:`getDerivKernels` .
:param ksize:Aperture size See :ocv:func:`getDerivKernels` .
:param borderType:Border type to use. See :cpp:func:`borderInterpolate` .
:param borderType:Border type to use. See :ocv:func:`borderInterpolate` .
The function :cpp:func:`createDerivFilter` is a small convenience function that retrieves linear filter coefficients for computing image derivatives using
:cpp:func:`getDerivKernels` and then creates a separable linear filter with
:cpp:func:`createSeparableLinearFilter` . The function is used by
:cpp:func:`Sobel` and
:cpp:func:`Scharr` .
The function :ocv:func:`createDerivFilter` is a small convenience function that retrieves linear filter coefficients for computing image derivatives using
:ocv:func:`getDerivKernels` and then creates a separable linear filter with
:ocv:func:`createSeparableLinearFilter` . The function is used by
:ocv:func:`Sobel` and
:ocv:func:`Scharr` .
See Also:
:cpp:func:`createSeparableLinearFilter`,
:cpp:func:`getDerivKernels`,
:cpp:func:`Scharr`,
:cpp:func:`Sobel`
:ocv:func:`createSeparableLinearFilter`,
:ocv:func:`getDerivKernels`,
:ocv:func:`Scharr`,
:ocv:func:`Sobel`
..index:: createGaussianFilter
createGaussianFilter
------------------------
..cpp:function:: Ptr<FilterEngine> createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
..ocv:function:: Ptr<FilterEngine> createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
Returns an engine for smoothing images with the Gaussian filter.
:param type:Source and destination image type.
:param ksize:Aperture size. See :cpp:func:`getGaussianKernel` .
:param ksize:Aperture size. See :ocv:func:`getGaussianKernel` .
:param sigmaX:Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` .
:param sigmaX:Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` .
:param sigmaY:Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` .
:param borderType:Border type to use. See :cpp:func:`borderInterpolate` .
:param borderType:Border type to use. See :ocv:func:`borderInterpolate` .
The function :cpp:func:`createGaussianFilter` computes Gaussian kernel coefficients and then returns a separable linear filter for that kernel. The function is used by
:cpp:func:`GaussianBlur` . Note that while the function takes just one data type, both for input and output, you can pass this limitation by calling
:cpp:func:`getGaussianKernel` and then
:cpp:func:`createSeparableFilter` directly.
The function :ocv:func:`createGaussianFilter` computes Gaussian kernel coefficients and then returns a separable linear filter for that kernel. The function is used by
:ocv:func:`GaussianBlur` . Note that while the function takes just one data type, both for input and output, you can pass this limitation by calling
:ocv:func:`getGaussianKernel` and then
:ocv:func:`createSeparableFilter` directly.
See Also:
:cpp:func:`createSeparableLinearFilter`,
:cpp:func:`getGaussianKernel`,
:cpp:func:`GaussianBlur`
:ocv:func:`createSeparableLinearFilter`,
:ocv:func:`getGaussianKernel`,
:ocv:func:`GaussianBlur`
..index:: createLinearFilter
createLinearFilter
----------------------
..cpp:function:: Ptr<FilterEngine> createLinearFilter(int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar())
..ocv:function:: Ptr<FilterEngine> createLinearFilter(int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar())
..cpp:function:: Ptr<BaseFilter> getLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
..ocv:function:: Ptr<BaseFilter> getLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
Creates a non-separable linear filter engine.
@ -674,30 +674,30 @@ createLinearFilter
:param bits:Number of the fractional bits. the parameter is used when the kernel is an integer matrix representing fixed-point filter coefficients.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border vaule used in case of a constant border.
The function returns a pointer to a 2D linear filter for the specified kernel, the source array type, and the destination array type. The function is a higher-level function that calls ``getLinearFilter`` and passes the retrieved 2D filter to the
:cpp:func:`FilterEngine` constructor.
:ocv:func:`FilterEngine` constructor.
See Also:
:cpp:func:`createSeparableLinearFilter`,
:cpp:func:`FilterEngine`,
:cpp:func:`filter2D`
:ocv:func:`createSeparableLinearFilter`,
:ocv:func:`FilterEngine`,
:ocv:func:`filter2D`
..index:: createMorphologyFilter
createMorphologyFilter
--------------------------
..cpp:function:: Ptr<FilterEngine> createMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar& borderValue=morphologyDefaultBorderValue())
..ocv:function:: Ptr<FilterEngine> createMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar& borderValue=morphologyDefaultBorderValue())
..cpp:function:: Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1))
..ocv:function:: Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1))
..cpp:function:: Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int esize, int anchor=-1)
..ocv:function:: Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int esize, int anchor=-1)
..cpp:function:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1)
..ocv:function:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1)
Creates an engine for non-separable morphological operations.
@ -711,32 +711,32 @@ createMorphologyFilter
:param anchor:Anchor position within the structuring element. Negative values mean that the anchor is at the kernel center.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border value in case of a constant border. The default value, \ ``morphologyDefaultBorderValue`` , has a special meaning. It is transformed :math:`+\inf` for the erosion and to :math:`-\inf` for the dilation, which means that the minimum (maximum) is effectively computed only over the pixels that are inside the image.
The functions construct primitive morphological filtering operations or a filter engine based on them. Normally it is enough to use
:cpp:func:`createMorphologyFilter` or even higher-level
:cpp:func:`erode`,
:cpp:func:`dilate` , or
:cpp:func:`morphologyEx` .
:ocv:func:`createMorphologyFilter` or even higher-level
:ocv:func:`erode`,
:ocv:func:`dilate` , or
:ocv:func:`morphologyEx` .
Note that
:cpp:func:`createMorphologyFilter` analyzes the structuring element shape and builds a separable morphological filter engine when the structuring element is square.
:ocv:func:`createMorphologyFilter` analyzes the structuring element shape and builds a separable morphological filter engine when the structuring element is square.
See Also:
:cpp:func:`erode`,
:cpp:func:`dilate`,
:cpp:func:`morphologyEx`,
:cpp:func:`FilterEngine`
:ocv:func:`erode`,
:ocv:func:`dilate`,
:ocv:func:`morphologyEx`,
:ocv:func:`FilterEngine`
..index:: createSeparableLinearFilter
createSeparableLinearFilter
-------------------------------
..cpp:function:: Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar())
..ocv:function:: Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar())
..cpp:function:: Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType, InputArray columnKernel, int anchor, int symmetryType, double delta=0, int bits=0)
..ocv:function:: Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType, InputArray columnKernel, int anchor, int symmetryType, double delta=0, int bits=0)
..cpp:function:: Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType, InputArray rowKernel, int anchor, int symmetryType)
..ocv:function:: Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType, InputArray rowKernel, int anchor, int symmetryType)
Creates an engine for a separable linear filter.
@ -756,28 +756,28 @@ createSeparableLinearFilter
:param bits:Number of the fractional bits. The parameter is used when the kernel is an integer matrix representing fixed-point filter coefficients.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details.
:param rowBorderType, columnBorderType:Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border value used in case of a constant border.
:param symmetryType:Type of each row and column kernel. See :cpp:func:`getKernelType` .
:param symmetryType:Type of each row and column kernel. See :ocv:func:`getKernelType` .
The functions construct primitive separable linear filtering operations or a filter engine based on them. Normally it is enough to use
:cpp:func:`createSeparableLinearFilter` or even higher-level
:cpp:func:`sepFilter2D` . The function
:cpp:func:`createMorphologyFilter` is smart enough to figure out the ``symmetryType`` for each of the two kernels, the intermediate ``bufType`` and, if filtering can be done in integer arithmetics, the number of ``bits`` to encode the filter coefficients. If it does not work for you, it is possible to call ``getLinearColumnFilter``,``getLinearRowFilter`` directly and then pass them to the
:cpp:func:`FilterEngine` constructor.
:ocv:func:`createSeparableLinearFilter` or even higher-level
:ocv:func:`sepFilter2D` . The function
:ocv:func:`createMorphologyFilter` is smart enough to figure out the ``symmetryType`` for each of the two kernels, the intermediate ``bufType`` and, if filtering can be done in integer arithmetics, the number of ``bits`` to encode the filter coefficients. If it does not work for you, it is possible to call ``getLinearColumnFilter``,``getLinearRowFilter`` directly and then pass them to the
:ocv:func:`FilterEngine` constructor.
See Also:
:cpp:func:`sepFilter2D`,
:cpp:func:`createLinearFilter`,
:cpp:func:`FilterEngine`,
:cpp:func:`getKernelType`
:ocv:func:`sepFilter2D`,
:ocv:func:`createLinearFilter`,
:ocv:func:`FilterEngine`,
:ocv:func:`getKernelType`
..index:: dilate
dilate
----------
..cpp:function:: void dilate( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
..ocv:function:: void dilate( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
Dilates an image by using a specific structuring element.
@ -791,9 +791,9 @@ dilate
:param iterations:Number of times dilation is applied.
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphologyFilter` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphologyFilter` for details.
The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:
@ -804,14 +804,14 @@ The function dilates the source image using the specified structuring element th
The function supports the in-place mode. Dilation can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently.
See Also:
:cpp:func:`erode`,
:cpp:func:`morphologyEx`,
:cpp:func:`createMorphologyFilter`
:ocv:func:`erode`,
:ocv:func:`morphologyEx`,
:ocv:func:`createMorphologyFilter`
..index:: erode
erode
---------
..cpp:function:: void erode( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
..ocv:function:: void erode( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
Erodes an image by using a specific structuring element.
@ -825,9 +825,9 @@ erode
:param iterations:Number of times erosion is applied.
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphoogyFilter` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphoogyFilter` for details.
The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:
@ -838,15 +838,15 @@ The function erodes the source image using the specified structuring element tha
The function supports the in-place mode. Erosion can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently.
See Also:
:cpp:func:`dilate`,
:cpp:func:`morphologyEx`,
:cpp:func:`createMorphologyFilter`
:ocv:func:`dilate`,
:ocv:func:`morphologyEx`,
:ocv:func:`createMorphologyFilter`
..index:: filter2D
filter2D
------------
..cpp:function:: void filter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
..ocv:function:: void filter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
Convolves an image with the kernel.
@ -856,13 +856,13 @@ filter2D
:param ddepth:Desired depth of the destination image. If it is negative, it will be the same as ``src.depth()`` .
:param kernel:Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using :cpp:func:`split` and process them individually.
:param kernel:Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using :ocv:func:`split` and process them individually.
:param anchor:Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center.
:param delta:Optional value added to the filtered pixels before storing them in ``dst`` .
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.
@ -873,21 +873,21 @@ The function does actually compute correlation, not the convolution:
That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using
:cpp:func:`flip` and set the new anchor to ``(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`` .
:ocv:func:`flip` and set the new anchor to ``(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`` .
The function uses the DFT-based algorithm in case of sufficiently large kernels (~``11 x 11`` or larger) and the direct algorithm (that uses the engine retrieved by :cpp:func:`createLinearFilter` ) for small kernels.
The function uses the DFT-based algorithm in case of sufficiently large kernels (~``11 x 11`` or larger) and the direct algorithm (that uses the engine retrieved by :ocv:func:`createLinearFilter` ) for small kernels.
:param ksize:Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. Or, they can be zero's and then they are computed from ``sigma*`` .
:param sigmaX, sigmaY:Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height`` , respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ``ksize`` , ``sigmaX`` , and ``sigmaY`` .
:param sigmaX, sigmaY:Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height`` , respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ``ksize`` , ``sigmaX`` , and ``sigmaY`` .
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
The function convolves the source image with the specified Gaussian kernel. In-place filtering is supported.
See Also:
:cpp:func:`sepFilter2D`,
:cpp:func:`filter2D`,
:cpp:func:`blur`,
:cpp:func:`boxFilter`,
:cpp:func:`bilateralFilter`,
:cpp:func:`medianBlur`
:ocv:func:`sepFilter2D`,
:ocv:func:`filter2D`,
:ocv:func:`blur`,
:ocv:func:`boxFilter`,
:ocv:func:`bilateralFilter`,
:ocv:func:`medianBlur`
..index:: getDerivKernels
getDerivKernels
-------------------
..cpp:function:: void getDerivKernels( OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F )
..ocv:function:: void getDerivKernels( OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F )
Returns filter coefficients for computing spatial image derivatives.
@ -934,16 +934,16 @@ getDerivKernels
The function computes and returns the filter coefficients for spatial image derivatives. When ``ksize=CV_SCHARR`` , the Scharr
:math:`3 \times 3` kernels are generated (see
:cpp:func:`Scharr` ). Otherwise, Sobel kernels are generated (see
:cpp:func:`Sobel` ). The filters are normally passed to
:cpp:func:`sepFilter2D` or to
:cpp:func:`createSeparableLinearFilter` .
:ocv:func:`Scharr` ). Otherwise, Sobel kernels are generated (see
:ocv:func:`Sobel` ). The filters are normally passed to
:ocv:func:`sepFilter2D` or to
:ocv:func:`createSeparableLinearFilter` .
..index:: getGaussianKernel
getGaussianKernel
---------------------
..cpp:function:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F )
..ocv:function:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F )
Returns Gaussian filter coefficients.
@ -965,22 +965,22 @@ where
:math:`\sum_i G_i=1`.
Two of such generated kernels can be passed to
:cpp:func:`sepFilter2D` or to
:cpp:func:`createSeparableLinearFilter`. Those functions automatically recognize smoothing kernels (i.e. symmetrical kernel with sum of weights = 1) and handle them accordingly. You may also use the higher-level
:cpp:func:`GaussianBlur`.
:ocv:func:`sepFilter2D` or to
:ocv:func:`createSeparableLinearFilter`. Those functions automatically recognize smoothing kernels (i.e. symmetrical kernel with sum of weights = 1) and handle them accordingly. You may also use the higher-level
:ocv:func:`GaussianBlur`.
See Also:
:cpp:func:`sepFilter2D`,
:cpp:func:`createSeparableLinearFilter`,
:cpp:func:`getDerivKernels`,
:cpp:func:`getStructuringElement`,
:cpp:func:`GaussianBlur`
:ocv:func:`sepFilter2D`,
:ocv:func:`createSeparableLinearFilter`,
:ocv:func:`getDerivKernels`,
:ocv:func:`getStructuringElement`,
:ocv:func:`GaussianBlur`
..index:: getKernelType
getKernelType
-----------------
..cpp:function:: int getKernelType(InputArray kernel, Point anchor)
..ocv:function:: int getKernelType(InputArray kernel, Point anchor)
Returns the kernel type.
@ -1003,7 +1003,7 @@ The function analyzes the kernel coefficients and returns the corresponding kern
getStructuringElement
-------------------------
..cpp:function:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1))
..ocv:function:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1))
Returns a structuring element of the specified size and shape for morphological operations.
@ -1028,16 +1028,16 @@ getStructuringElement
:param anchor:Anchor position within the element. The default value :math:`(-1, -1)` means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted.
The function constructs and returns the structuring element that can be then passed to
:cpp:func:`createMorphologyFilter`,
:cpp:func:`erode`,
:cpp:func:`dilate` or
:cpp:func:`morphologyEx` . But you can also construct an arbitrary binary mask yourself and use it as the structuring element.
:ocv:func:`createMorphologyFilter`,
:ocv:func:`erode`,
:ocv:func:`dilate` or
:ocv:func:`morphologyEx` . But you can also construct an arbitrary binary mask yourself and use it as the structuring element.
..index:: medianBlur
medianBlur
--------------
..cpp:function:: void medianBlur( InputArray src, OutputArray dst, int ksize )
..ocv:function:: void medianBlur( InputArray src, OutputArray dst, int ksize )
Smoothes an image using the median filter.
@ -1051,16 +1051,16 @@ The function smoothes an image using the median filter with the
:math:`\texttt{ksize} \times \texttt{ksize}` aperture. Each channel of a multi-channel image is processed independently. In-place operation is supported.
See Also:
:cpp:func:`bilateralFilter`,
:cpp:func:`blur`,
:cpp:func:`boxFilter`,
:cpp:func:`GaussianBlur`
:ocv:func:`bilateralFilter`,
:ocv:func:`blur`,
:ocv:func:`boxFilter`,
:ocv:func:`GaussianBlur`
..index:: morphologyEx
morphologyEx
----------------
..cpp:function:: void morphologyEx( InputArray src, OutputArray dst, int op, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
..ocv:function:: void morphologyEx( InputArray src, OutputArray dst, int op, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )
Performs advanced morphological transformations.
@ -1084,9 +1084,9 @@ morphologyEx
:param iterations:Number of times erosion and dilation are applied.
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphoogyFilter` for details.
:param borderValue:Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphoogyFilter` for details.
The function can perform advanced morphological transformations using an erosion and dilation as basic operations.
@ -1123,15 +1123,15 @@ Morphological gradient:
Any of the operations can be done in-place.
See Also:
:cpp:func:`dilate`,
:cpp:func:`erode`,
:cpp:func:`createMorphologyFilter`
:ocv:func:`dilate`,
:ocv:func:`erode`,
:ocv:func:`createMorphologyFilter`
..index:: Laplacian
Laplacian
-------------
..cpp:function:: void Laplacian( InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
..ocv:function:: void Laplacian( InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
Calculates the Laplacian of an image.
@ -1141,13 +1141,13 @@ Laplacian
:param ddepth:Desired depth of the destination image.
:param ksize:Aperture size used to compute the second-derivative filters. See :cpp:func:`getDerivKernels` for details. The size must be positive and odd.
:param ksize:Aperture size used to compute the second-derivative filters. See :ocv:func:`getDerivKernels` for details. The size must be positive and odd.
:param scale:Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param scale:Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param delta:Optional delta value that is added to the results prior to storing them in ``dst`` .
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
The function calculates the Laplacian of the source image by adding up the second x and y derivatives calculated using the Sobel operator:
@ -1163,14 +1163,14 @@ This is done when ``ksize > 1`` . When ``ksize == 1`` , the Laplacian is compute
The function performs the upsampling step of the Gaussian pyramid construction though it can actually be used to construct the Laplacian pyramid. First, it upsamples the source image by injecting even zero rows and columns and then convolves the result with the same kernel as in
:cpp:func:`pyrDown` multiplied by 4.
:ocv:func:`pyrDown` multiplied by 4.
..index:: sepFilter2D
sepFilter2D
---------------
..cpp:function:: void sepFilter2D( InputArray src, OutputArray dst, int ddepth, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
..ocv:function:: void sepFilter2D( InputArray src, OutputArray dst, int ddepth, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
Applies a separable linear filter to an image.
@ -1237,23 +1237,23 @@ sepFilter2D
:param delta:Value added to the filtered results before storing them.
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
The function applies a separable linear filter to the image. That is, first, every row of ``src`` is filtered with the 1D kernel ``rowKernel`` . Then, every column of the result is filtered with the 1D kernel ``columnKernel`` . The final result shifted by ``delta`` is stored in ``dst`` .
See Also:
:cpp:func:`createSeparableLinearFilter`,
:cpp:func:`filter2D`,
:cpp:func:`Sobel`,
:cpp:func:`GaussianBlur`,
:cpp:func:`boxFilter`,
:cpp:func:`blur`
:ocv:func:`createSeparableLinearFilter`,
:ocv:func:`filter2D`,
:ocv:func:`Sobel`,
:ocv:func:`GaussianBlur`,
:ocv:func:`boxFilter`,
:ocv:func:`blur`
..index:: Sobel
Sobel
---------
..cpp:function:: void Sobel( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
..ocv:function:: void Sobel( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
@ -1269,11 +1269,11 @@ Sobel
:param ksize:Size of the extended Sobel kernel. It must be 1, 3, 5, or 7.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param delta:Optional delta value that is added to the results prior to storing them in ``dst`` .
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
In all cases except one, the
:math:`\texttt{ksize} \times
@ -1316,17 +1316,17 @@ The second case corresponds to a kernel of:
\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}
See Also:
:cpp:func:`Scharr`,
:cpp:func:`Lapacian`,
:cpp:func:`sepFilter2D`,
:cpp:func:`filter2D`,
:cpp:func:`GaussianBlur`
:ocv:func:`Scharr`,
:ocv:func:`Lapacian`,
:ocv:func:`sepFilter2D`,
:ocv:func:`filter2D`,
:ocv:func:`GaussianBlur`
..index:: Scharr
Scharr
----------
..cpp:function:: void Scharr( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
..ocv:function:: void Scharr( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
Calculates the first x- or y- image derivative using Scharr operator.
@ -1340,11 +1340,11 @@ Scharr
:param yorder:Order of the derivative y.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param delta:Optional delta value that is added to the results prior to storing them in ``dst`` .
:param borderType:Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
:param borderType:Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.
The function computes the first x- or y- spatial image derivative using the Scharr operator. The call
Converts image transformation maps from one representation to another.
@ -56,11 +56,11 @@ convertMaps
:param nninterpolation:Flag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.
The function converts a pair of maps for
:cpp:func:`remap` from one representation to another. The following options ( ``(map1.type(), map2.type())``:math:`\rightarrow```(dstmap1.type(), dstmap2.type())`` ) are supported:
:ocv:func:`remap` from one representation to another. The following options ( ``(map1.type(), map2.type())``:math:`\rightarrow```(dstmap1.type(), dstmap2.type())`` ) are supported:
*
:math:`\texttt{(CV\_32FC1, CV\_32FC1)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}` . This is the most frequently used conversion operation, in which the original floating-point maps (see
:cpp:func:`remap` ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when ``nninterpolation=false`` ) contains indices in the interpolation tables.
:ocv:func:`remap` ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when ``nninterpolation=false`` ) contains indices in the interpolation tables.
*
:math:`\texttt{(CV\_32FC2)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}` . The same as above but the original maps are stored in one 2-channel matrix.
@ -69,15 +69,15 @@ The function converts a pair of maps for
Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals.
See Also:
:cpp:func:`remap`,
:cpp:func:`undisort`,
:cpp:func:`initUndistortRectifyMap`
:ocv:func:`remap`,
:ocv:func:`undisort`,
:ocv:func:`initUndistortRectifyMap`
..index:: getAffineTransform
getAffineTransform
----------------------
..cpp:function:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] )
..ocv:function:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] )
Calculates an affine transform from three pairs of the corresponding points.
@ -100,8 +100,8 @@ where
i=0,1,2
See Also:
:cpp:func:`warpAffine`,
:cpp:func:`transform`
:ocv:func:`warpAffine`,
:ocv:func:`transform`
..index:: getPerspectiveTransform
@ -110,7 +110,7 @@ See Also:
getPerspectiveTransform
---------------------------
..cpp:function:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] )
..ocv:function:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] )
Calculates a perspective transform from four pairs of the corresponding points.
@ -133,9 +133,9 @@ where
i=0,1,2
See Also:
:cpp:func:`findHomography`,
:cpp:func:`warpPerspective`,
:cpp:func:`perspectiveTransform`
:ocv:func:`findHomography`,
:ocv:func:`warpPerspective`,
:ocv:func:`perspectiveTransform`
..index:: getRectSubPix
@ -143,7 +143,7 @@ See Also:
getRectSubPix
-----------------
..cpp:function:: void getRectSubPix( InputArray image, Size patchSize, Point2f center, OutputArray dst, int patchType=-1 )
..ocv:function:: void getRectSubPix( InputArray image, Size patchSize, Point2f center, OutputArray dst, int patchType=-1 )
Retrieves a pixel rectangle from an image with sub-pixel accuracy.
@ -168,12 +168,12 @@ using bilinear interpolation. Every channel of multi-channel
images is processed independently. While the center of the rectangle
must be inside the image, parts of the rectangle may be
outside. In this case, the replication border mode (see
:cpp:func:`borderInterpolate` ) is used to extrapolate
:ocv:func:`borderInterpolate` ) is used to extrapolate
the pixel values outside of the image.
See Also:
:cpp:func:`warpAffine`,
:cpp:func:`warpPerspective`
:ocv:func:`warpAffine`,
:ocv:func:`warpPerspective`
..index:: getRotationMatrix2D
@ -181,7 +181,7 @@ See Also:
getRotationMatrix2D
-----------------------
..cpp:function:: Mat getRotationMatrix2D( Point2f center, double angle, double scale )
..ocv:function:: Mat getRotationMatrix2D( Point2f center, double angle, double scale )
Calculates an affine matrix of 2D rotation.
@ -206,9 +206,9 @@ where
The transformation maps the rotation center to itself. If this is not the target, adjust the shift.
See Also:
:cpp:func:`getAffineTransform`,
:cpp:func:`warpAffine`,
:cpp:func:`transform`
:ocv:func:`getAffineTransform`,
:ocv:func:`warpAffine`,
:ocv:func:`transform`
..index:: invertAffineTransform
@ -216,7 +216,7 @@ See Also:
invertAffineTransform
-------------------------
..cpp:function:: void invertAffineTransform(InputArray M, OutputArray iM)
..ocv:function:: void invertAffineTransform(InputArray M, OutputArray iM)
Inverts an affine transformation.
@ -241,20 +241,20 @@ The result is also a
remap
-----
..cpp:function:: void remap( InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
..ocv:function:: void remap( InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
Applies a generic geometrical transformation to an image.
:param src:Source image.
:param dst:Destination image. It has the same size as ``map1`` and the same type as ``src`` .
:param map1:The first map of either ``(x,y)`` points or just ``x`` values having the type ``CV_16SC2`` , ``CV_32FC1`` , or ``CV_32FC2`` . See :cpp:func:`convertMaps` for details on converting a floating point representation to fixed-point for speed.
:param map1:The first map of either ``(x,y)`` points or just ``x`` values having the type ``CV_16SC2`` , ``CV_32FC1`` , or ``CV_32FC2`` . See :ocv:func:`convertMaps` for details on converting a floating point representation to fixed-point for speed.
:param map2:The second map of ``y`` values having the type ``CV_16UC1`` , ``CV_32FC1`` , or none (empty map if ``map1`` is ``(x,y)`` points), respectively.
:param interpolation:Interpolation method (see :cpp:func:`resize` ). The method ``INTER_AREA`` is not supported by this function.
:param interpolation:Interpolation method (see :ocv:func:`resize` ). The method ``INTER_AREA`` is not supported by this function.
:param borderMode:Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
:param borderMode:Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
:param borderValue:Value used in case of a constant border. By default, it is 0.
@ -272,7 +272,7 @@ where values of pixels with non-integer coordinates are computed using one of av
:math:`(x,y)` in
:math:`map_1` , or
fixed-point maps created by using
:cpp:func:`convertMaps` . The reason you might want to convert from floating to fixed-point
:ocv:func:`convertMaps` . The reason you might want to convert from floating to fixed-point
representations of a map is that they can yield much faster (~2x) remapping operations. In the converted case,
:math:`map_1` contains pairs ``(cvFloor(x), cvFloor(y))`` and
:math:`map_2` contains indices in a table of interpolation coefficients.
@ -286,7 +286,7 @@ This function cannot operate in-place.
@ -341,9 +341,9 @@ If you want to decimate the image by factor of 2 in each direction, you can call
See Also:
:cpp:func:`warpAffine`,
:cpp:func:`warpPerspective`,
:cpp:func:`remap`
:ocv:func:`warpAffine`,
:ocv:func:`warpPerspective`,
:ocv:func:`remap`
..index:: warpAffine
@ -351,7 +351,7 @@ See Also:
warpAffine
--------------
..cpp:function:: void warpAffine( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
..ocv:function:: void warpAffine( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
Applies an affine transformation to an image.
@ -363,9 +363,9 @@ warpAffine
:param dsize:Size of the destination image.
:param flags:Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).
:param flags:Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).
:param borderMode:Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function.
:param borderMode:Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function.
:param borderValue:Value used in case of a constant border. By default, it is 0.
@ -376,21 +376,21 @@ The function ``warpAffine`` transforms the source image using the specified matr
\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})
when the flag ``WARP_INVERSE_MAP`` is set. Otherwise, the transformation is first inverted with
:cpp:func:`invertAffineTransform` and then put in the formula above instead of ``M`` .
:ocv:func:`invertAffineTransform` and then put in the formula above instead of ``M`` .
The function cannot operate in-place.
See Also:
:cpp:func:`warpPerspective`,
:cpp:func:`resize`,
:cpp:func:`remap`,
:cpp:func:`getRectSubPix`,
:cpp:func:`transform`
:ocv:func:`warpPerspective`,
:ocv:func:`resize`,
:ocv:func:`remap`,
:ocv:func:`getRectSubPix`,
:ocv:func:`transform`
..index:: warpPerspective
warpPerspective
-------------------
..cpp:function:: void warpPerspective( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
..ocv:function:: void warpPerspective( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
Applies a perspective transformation to an image.
@ -402,9 +402,9 @@ warpPerspective
:param dsize:Size of the destination image.
:param flags:Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).
:param flags:Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).
:param borderMode:Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
:param borderMode:Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
:param borderValue:Value used in case of a constant border. By default, it is 0.
@ -416,15 +416,15 @@ The function ``warpPerspective`` transforms the source image using the specified
\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )
when the flag ``WARP_INVERSE_MAP`` is set. Otherwise, the transformation is first inverted with
:cpp:func:`invert` and then put in the formula above instead of ``M`` .
:ocv:func:`invert` and then put in the formula above instead of ``M`` .
While the function works well with 1-, 2-, 3-dimensional dense histograms, it may not be suitable for high-dimensional sparse histograms. In such histograms, because of aliasing and sampling problems, the coordinates of non-zero histogram bins can slightly shift. To compare such histograms or more general sparse configurations of weighted points, consider using the
..cpp:function:: void adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C )
..ocv:function:: void adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C )
Applies an adaptive threshold to an array.
@ -54,14 +54,14 @@ where
:math:`T(x, y)` is a weighted sum (cross-correlation with a Gaussian window) of the
:math:`\texttt{blockSize} \times \texttt{blockSize}` neighborhood of
:math:`(x, y)` minus ``C`` . The default sigma (standard deviation) is used for the specified ``blockSize`` . See
:cpp:func:`getGaussianKernel` .
:ocv:func:`getGaussianKernel` .
The function can process the image in-place.
See Also:
:cpp:func:`threshold`,
:cpp:func:`blur`,
:cpp:func:`GaussianBlur`
:ocv:func:`threshold`,
:ocv:func:`blur`,
:ocv:func:`GaussianBlur`
..index:: cvtColor
@ -70,7 +70,7 @@ See Also:
cvtColor
------------
..cpp:function:: void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 )
..ocv:function:: void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 )
Converts an image from one color space to another.
@ -127,7 +127,7 @@ The function can do the following transformations:
..
More advanced channel reordering can also be done with
:cpp:func:`mixChannels` .
:ocv:func:`mixChannels` .
*
RGB
@ -402,9 +402,9 @@ The function can do the following transformations:
distanceTransform
---------------------
..cpp:function:: void distanceTransform( InputArray src, OutputArray dst, int distanceType, int maskSize )
..ocv:function:: void distanceTransform( InputArray src, OutputArray dst, int distanceType, int maskSize )
..cpp:function:: void distanceTransform( InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize )
..ocv:function:: void distanceTransform( InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize )
Calculates the distance to the closest zero pixel for each pixel of the source image.
@ -470,9 +470,9 @@ Currently, the second variant can use only the approximate distance transform al
floodFill
-------------
..cpp:function:: int floodFill( InputOutputArray image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )
..ocv:function:: int floodFill( InputOutputArray image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )
..cpp:function:: int floodFill( InputOutputArray image, InputOutputArray mask, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )
..ocv:function:: int floodFill( InputOutputArray image, InputOutputArray mask, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )
Fills a connected component with the given color.
@ -564,7 +564,7 @@ where
Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on. Various modes of the function are demonstrated in the ``floodfill.cpp`` sample.
@ -28,15 +28,15 @@ The function supports multi-channel images. Each channel is processed independen
The functions ``accumulate*`` can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.
After the function finishes the comparison, the best matches can be found as global minimums (when ``CV_TM_SQDIFF`` was used) or maximums (when ``CV_TM_CCORR`` or ``CV_TM_CCOEFF`` was used) using the
:cpp:func:`minMaxLoc` function. In case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels and separate mean values are used for each channel. That is, the function can take a color template and a color image. The result will still be a single-channel image, which is easier to analyze.
:ocv:func:`minMaxLoc` function. In case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels and separate mean values are used for each channel. That is, the function can take a color template and a color image. The result will still be a single-channel image, which is easier to analyze.
). So, due to a limited raster resolution, the moments computed for a contour are slightly different from the moments computed for the same rasterized contour.
:param moments:Input moments computed with :cpp:func:`moments` .
:param moments:Input moments computed with :ocv:func:`moments` .
:param h:Output Hu invariants.
The function calculates the seven Hu invariants (see
@ -101,19 +101,19 @@ where
These values are proved to be invariants to the image scale, rotation, and reflection except the seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of infinite image resolution. In case of raster images, the computed Hu invariants for the original and transformed images are a bit different.
See Also:
:cpp:func:`matchShapes`
:ocv:func:`matchShapes`
..index:: findContours
findContours
----------------
..cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
..ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
..cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
..ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
Finds contours in a binary image.
:param image:Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as ``binary`` . You can use :cpp:func:`compare` , :cpp:func:`inRange` , :cpp:func:`threshold` , :cpp:func:`adaptiveThreshold` , :cpp:func:`Canny` , and others to create a binary image out of a grayscale or color one. The function modifies the ``image`` while extracting the contours.
:param image:Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as ``binary`` . You can use :ocv:func:`compare` , :ocv:func:`inRange` , :ocv:func:`threshold` , :ocv:func:`adaptiveThreshold` , :ocv:func:`Canny` , and others to create a binary image out of a grayscale or color one. The function modifies the ``image`` while extracting the contours.
:param contours:Detected contours. Each contour is stored as a vector of points.
@ -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=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
..ocv: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.
@ -165,7 +165,7 @@ drawContours
:param thickness:Thickness of lines the contours are drawn with. If it is negative (for example, ``thickness=CV_FILLED`` ), the contour interiors are
drawn.
:param lineType:Line connectivity. See :cpp:func:`line` for details.
:param lineType:Line connectivity. See :ocv:func:`line` for details.
:param hierarchy:Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see ``maxLevel`` ).
@ -221,7 +221,7 @@ The function draws contour outlines in the image if
:param orientation:Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking sign of the area. By default the parameter is ``false``, which means that the absolute value is returned.
The function computes a contour area. Similarly to
:cpp:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using
:cpp:func:`drawContours` or
:cpp:func:`fillPoly` , can be different.
:ocv:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using
Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
@ -43,7 +43,7 @@ Bouguet00
calcOpticalFlowFarneback
----------------------------
..cpp:function:: void calcOpticalFlowFarneback( InputArray prevImg, InputArray nextImg, InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags )
..ocv:function:: void calcOpticalFlowFarneback( InputArray prevImg, InputArray nextImg, InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags )
Computes a dense optical flow using the Gunnar Farneback's algorithm.
@ -82,7 +82,7 @@ The function finds an optical flow for each ``prevImg`` pixel using the alorithm
estimateRigidTransform
--------------------------
..cpp:function:: Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine )
..ocv:function:: Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine )
Computes an optimal affine transformation between two 2D point sets.
@ -116,16 +116,16 @@ In the case of point sets, the problem is formulated in the following way. We ne
Updates the motion history image by a moving silhouette.
@ -146,8 +146,8 @@ The function updates the motion history image as follows:
That is, MHI pixels where the motion occurs are set to the current ``timestamp`` , while the pixels where the motion happened last time a long time ago are cleared.
The function, together with
:cpp:func:`calcMotionGradient` and
:cpp:func:`calcGlobalOrientation` , implements a motion templates technique described in
:ocv:func:`calcMotionGradient` and
:ocv:func:`calcGlobalOrientation` , implements a motion templates technique described in
Davis97
and
Bradski00
@ -158,7 +158,7 @@ See also the OpenCV sample ``motempl.c`` that demonstrates the use of all the mo
:cpp:func:`phase` are used so that the computed angle is measured in degrees and covers the full range 0..360. Also, the ``mask`` is filled to indicate pixels where the computed angle is valid.
:ocv:func:`fastArctan` and
:ocv:func:`phase` are used so that the computed angle is measured in degrees and covers the full range 0..360. Also, the ``mask`` is filled to indicate pixels where the computed angle is valid.
Calculates a global motion orientation in a selected region.
:param orientation:Motion gradient orientation image calculated by the function :cpp:func:`calcMotionGradient` .
:param orientation:Motion gradient orientation image calculated by the function :ocv:func:`calcMotionGradient` .
:param mask:Mask image. It may be a conjunction of a valid gradient mask, also calculated by :cpp:func:`calcMotionGradient` , and the mask of a region whose direction needs to be calculated.
:param mask:Mask image. It may be a conjunction of a valid gradient mask, also calculated by :ocv:func:`calcMotionGradient` , and the mask of a region whose direction needs to be calculated.
:param mhi:Motion history image calculated by :cpp:func:`updateMotionHistory` .
:param mhi:Motion history image calculated by :ocv:func:`updateMotionHistory` .
:param timestamp:Timestamp passed to :cpp:func:`updateMotionHistory` .
:param timestamp:Timestamp passed to :ocv:func:`updateMotionHistory` .
:param duration:Maximum duration of a motion track in milliseconds, passed to :cpp:func:`updateMotionHistory` .
:param duration:Maximum duration of a motion track in milliseconds, passed to :ocv:func:`updateMotionHistory` .
The function calculates an average
motion direction in the selected region and returns the angle between
@ -217,7 +217,7 @@ weight and the motion occurred in the past has a smaller weight, as recorded in
Splits a motion history image into a few parts corresponding to separate independent motions (e.g. left hand, right hand).
@ -232,28 +232,28 @@ segmentMotion
:param segThresh:Segmentation threshold; recommended to be equal to the interval between motion history "steps" or greater.
The function finds all of the motion segments and marks them in ``segmask`` with individual values (1,2,...). It also computes a vector with ROIs of motion connected components. After that the motion direction for every component can be calculated with :cpp:func:`calcGlobalOrientation` using the extracted mask of the particular component.
The function finds all of the motion segments and marks them in ``segmask`` with individual values (1,2,...). It also computes a vector with ROIs of motion connected components. After that the motion direction for every component can be calculated with :ocv:func:`calcGlobalOrientation` using the extracted mask of the particular component.
:param probImage:Back projection of the object histogram. See :cpp:func:`calcBackProject` .
:param probImage:Back projection of the object histogram. See :ocv:func:`calcBackProject` .
:param window:Initial search window.
:param criteria:Stop criteria for the underlying :cpp:func:`meanShift` .
:param criteria:Stop criteria for the underlying :ocv:func:`meanShift` .
The function implements the CAMSHIFT object tracking algrorithm
Bradski98
.
First, it finds an object center using
:cpp:func:`meanShift` and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with ``RotatedRect::boundingRect()`` .
:ocv:func:`meanShift` and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with ``RotatedRect::boundingRect()`` .
See the OpenCV sample ``camshiftdemo.c`` that tracks colored objects.
@ -261,23 +261,23 @@ See the OpenCV sample ``camshiftdemo.c`` that tracks colored objects.
meanShift
-------------
..cpp:function:: int meanShift( InputArray probImage, Rect& window, TermCriteria criteria )
..ocv:function:: int meanShift( InputArray probImage, Rect& window, TermCriteria criteria )
Finds an object on a back projection image.
:param probImage:Back projection of the object histogram. See :cpp:func:`calcBackProject` for details.
:param probImage:Back projection of the object histogram. See :ocv:func:`calcBackProject` for details.
:param window:Initial search window.
:param criteria:Stop criteria for the iterative search algorithm.
The function implements the iterative object search algorithm. It takes the input back projection of an object and the initial position. The mass center in ``window`` of the back projection image is computed and the search window center shifts to the mass center. The procedure is repeated until the specified number of iterations ``criteria.maxCount`` is done or until the window center shifts by less than ``criteria.epsilon`` . The algorithm is used inside
:cpp:func:`CamShift` and, unlike
:cpp:func:`CamShift` , the search window size or orientation do not change during the search. You can simply pass the output of
:cpp:func:`calcBackProject` to this function. But better results can be obtained if you pre-filter the back projection and remove the noise (for example, by retrieving connected components with
:cpp:func:`findContours` , throwing away contours with small area (
:cpp:func:`contourArea` ), and rendering the remaining contours with
:cpp:func:`drawContours` ).
:ocv:func:`CamShift` and, unlike
:ocv:func:`CamShift` , the search window size or orientation do not change during the search. You can simply pass the output of
:ocv:func:`calcBackProject` to this function. But better results can be obtained if you pre-filter the back projection and remove the noise (for example, by retrieving connected components with
:ocv:func:`findContours` , throwing away contours with small area (
:ocv:func:`contourArea` ), and rendering the remaining contours with
Vadim Pisarevsky
14 years ago