:param colRange: The range of the ``m`` 's columns to take. Use ``Range::all()`` to take all the columns.
- :param ranges: The array of selected ranges of ``m`` along each dimensionality
-
- .
+ :param ranges: The array of selected ranges of ``m`` along each dimensionality.
:param expr: Matrix expression. See :ref:`MatrixExpressions`.
-These are various constructors that form a matrix. As noticed in the ??
-, 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, in which case the old content is de-referenced, or be allocated with
+These are various constructors that form a matrix. As noticed 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, in which case the old content is de-referenced, or be allocated with
:ref:`Mat::create` .
.. index:: Mat::Mat
Locates the matrix header within a parent matrix.
- :param wholeSize: An output parameter that contains the size of the whole matrix, which ``*this`` is a part of.??
+ :param wholeSize: An output parameter that contains the size of the whole matrix, which contains ``*this`` is a part.
:param ofs: An output parameter that contains an offset of ``*this`` inside the whole matrix.
Clustering
==========
+.. highlight:: cpp
+
.. index:: kmeans
.. _kmeans:
kmeans
------
-.. c:function:: double kmeans( const Mat\& samples, int clusterCount, Mat\& labels, TermCriteria termcrit, int attempts, int flags, Mat* centers )
+.. c:function:: double kmeans( const Mat& samples, int clusterCount, Mat& labels, TermCriteria termcrit, int attempts, int flags, Mat* centers )
Finds centers of clusters and groups input samples around the clusters.
:param labels: Input/output integer array that stores the cluster indices for every sample.
- :param termcrit: Flag to specify the maximum number of iterations and/or accuracy (distance the centers can move by between subsequent iterations??).
+ :param termcrit: Flag to specify the maximum number of iterations and/or the desired accuracy. The accuracy is specified as ``termcrit.epsilon``. As soon as each of the cluster centers moves by less than ``termcrit.epsilon`` on some iteration, the algorithm stops.
:param attempts: Flag to specify how many times the algorithm is executed using different initial labelings. The algorithm returns the labels that yield the best compactness (see the last function parameter).
-------------
.. c:function:: template<typename _Tp, class _EqPredicate> int
-.. c:function:: partition( const vector<_Tp>\& vec, vector<int>\& labels, _EqPredicate predicate=_EqPredicate())
+.. c:function:: partition( const vector<_Tp>& vec, vector<int>& labels, _EqPredicate predicate=_EqPredicate())
Splits an element set into equivalency classes.
All the functions include the parameter ``color`` that uses an RGB value (that may be constructed
with ``CV_RGB`` or the :ref:`Scalar` constructor
) for color
-images and brightness for grayscale images. For color images, the order?? channel
-is normally
-*Blue, Green, Red*.
-This is what
-:func:`imshow`,
-:func:`imread`, and
-:func:`imwrite` expect.
+images and brightness for grayscale images. For color images, the channel ordering
+is normally *Blue, Green, Red*.
+This is what :func:`imshow`, :func:`imread`, and :func:`imwrite` expect.
So, if you form a color using the
:ref:`Scalar` constructor, it should look like:
:param lineType: Type of the circle boundary. See :func:`line` description.
- :param shift: Number of fractional bits in the center?? coordinates, and radius value.
+ :param shift: Number of fractional bits in the center's coordinates and in the radius value.
The function ``circle`` draws a simple or filled circle with a given center and radius.
:param lineType: Type of the ellipse boundary. See :func:`line` description.
- :param shift: Number of fractional bits in the center?? coordinates and axes' values.
+ :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
Introduction
************
+.. highlight:: cpp
+
OpenCV (Open Source Computer Vision Library: http://opencv.willowgarage.com/wiki/) is an open-source BSD-licensed library that includes several hundreds computer vision algorithms. The document describes the so-called OpenCV 2.x API, which is essentially a C++ API, as opposite to the C-based OpenCV 1.x API. The latter is described in opencv1x.pdf.
OpenCV has a modular structure, which means that the package includes several shared or static libraries. The modules are:
================
*``cv``* Namespace
-----------------
+------------------
All the OpenCV classes and functions are placed into the *``cv``* namespace. Therefore, to access this functionality from your code, use the ``cv::`` specifier or ``using namespace cv;`` directive:
// matrix will be deallocated, since it is not referenced by anyone
C = C.clone();
-Therefore, the use of ``Mat`` and other basic structures is simple. But what about high-level classes or even user data types created without automatic memory management in mind? For them OpenCV offers the ``Ptr<>`` template class that is similar to ``std::shared_ptr`` from C++ TR1. So, instead of using plain pointers::
+Therefore, the use of ``Mat`` and other basic structures is simple. But what about high-level classes or even user data types created without taking automatic memory management into account? For them OpenCV offers the ``Ptr<>`` template class that is similar to ``std::shared_ptr`` from C++ TR1. So, instead of using plain pointers::
T* ptr = new T(...);
That is, ``Ptr<T> ptr`` incapsulates a pointer to a ``T`` instance and a reference counter associated with the pointer. See ``Ptr`` description for details.
-.. todo::
-
- Should we replace Ptr<> with the semi-standard shared_ptr<>?
+.. _AutomaticAllocation:
Automatic Allocation of the Output Data
---------------------------------------
return 0;
}
-The array ``frame`` is automatically allocated by the ``>>`` operator, since the video frame resolution and bit-depth is known to the video capturing module. The array ``edges`` is automatically allocated by the ``cvtColor`` function. It has the same size and the bit-depth as the input array. The number of channels is 1 because the color conversion code ``CV_BGR2GRAY`` is passed (that means color to grayscale conversion??). Note that ``frame`` and ``edges`` are allocated only once during the first execution of the loop body, since all the next video frames have the same resolution. If you somehow change the video resolution, the arrays are automatically reallocated.
+The array ``frame`` is automatically allocated by the ``>>`` operator, since the video frame resolution and bit-depth is known to the video capturing module. The array ``edges`` is automatically allocated by the ``cvtColor`` function. It has the same size and the bit-depth as the input array. The number of channels is 1 because the color conversion code ``CV_BGR2GRAY`` is passed, which means color to grayscale conversion. Note that ``frame`` and ``edges`` are allocated only once during the first execution of the loop body, since all the next video frames have the same resolution. If you somehow change the video resolution, the arrays are automatically reallocated.
The key component of this technology is the ``Mat::create`` method. It takes the desired array size and type. If the array already has the specified size and type, the method does nothing. Otherwise, it releases the previously allocated data, if any (this part involves decrementing the reference counter and comparing it with zero), and then allocates a new buffer of the required size. Most functions call this the ``Mat::create`` method for each output array and so the automatic output data allocation is implemented.
* 64-bit floating-point number (double)
* a tuple of several elements, where all elements have the same type (one of the above). An array, whose elements are such tuples, are called multi-channel arrays, as opposite to the single-channel arrays, whose elements are scalar values. The maximum possible number of channels is defined by the ``CV_CN_MAX`` constant (which is not smaller than 32).
-.. todo::
- Need we extend the above list? Shouldn't we throw away 8-bit signed (schar)?
-
For these basic types, the following enumeration is applied::
enum { CV_8U=0, CV_8S=1, CV_16U=2, CV_16S=3, CV_32S=4, CV_32F=5, CV_64F=6 };
The subset of supported types for each functions has been defined from practical needs. All this information about supported types can be put together into a special table. In different implementations of the standard, the tables may look differently. For example, on embedded platforms the double-precision floating-point type (``CV_64F``) may be unavailable.
-.. todo::
- Should we include such a table into the standard?
- Should we specify minimum "must-have" set of supported formats for each functions?
Error Handling
--------------
}
Multi-threading and Re-enterability
-----------------------------------
+-----------------------------------
-The current OpenCV implementation is fully re-enterable as should be any alternative implementation targeted for multi-threaded environments. That is, the same function, the same *constant* method of a class instance, or the same *non-constant* method of different class instances can be called from different threads. Also, the same ``cv::Mat`` can be used in different threads because the reference-counting operations use the architecture-specific atomic instructions.
+The current OpenCV implementation is fully re-enterable. That is, the same function, the same *constant* method of a class instance, or the same *non-constant* method of different class instances can be called from different threads. Also, the same ``cv::Mat`` can be used in different threads because the reference-counting operations use the architecture-specific atomic instructions.
In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently.
-See Also: ??
-
.. index:: bitwise_not
.. _bitwise_not_:
* **DFT_SCALE** Scale the result: divide it by the number of array elements. Normally, it is combined with ``DFT_INVERSE`` . .
* **DFT_ROWS** Perform a forward or inverse transform of every individual row of the input matrix. This flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transforms and so forth.
- * **DFT_COMPLEX_OUTPUT** Perform a forward transformation of 1D or 2D real array. The result, though being a complex array, has complex-conjugate symmetry ( *CCS* ).?? See the description below for details. Such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default. However, you may wish to get a full complex array (for simpler spectrum analysis, and so on). Pass the flag to enable the function to produce a full-size complex output array.
+ * **DFT_COMPLEX_OUTPUT** Perform a forward transformation of 1D or 2D real array. The result, though being a complex array, has complex-conjugate symmetry (*CCS*, see the function description below for details). Such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default. However, you may wish to get a full complex array (for simpler spectrum analysis, and so on). Pass the flag to enable the function to produce a full-size complex output array.
* **DFT_REAL_OUTPUT** Perform an inverse transformation of 1D or 2D complex array. The result is normally a complex array of the same size. However, if the source array has conjugate-complex symmetry (for example, it is a result of forward transformation with ``DFT_COMPLEX_OUTPUT`` flag), the output is a real array. While the function itself does not check whether the input is symmetrical or not, you can pass the flag and then the function will assume the symmetry and produce the real output array. Note that when the input is packed into a real array and inverse transformation is executed, the function treats the input as a packed complex-conjugate symmetrical array. So, the output will also be a real array.
:param dst: Destination array. It has the same size and type as ``src1`` .
- :param flags: The same flags as passed to :func:`dft` . Only the flag ``DFT_ROWS`` is checked for.??
+ :param flags: The operation flags. Currently, the only supported flag is ``DFT_ROWS``, which indicates that each row of ``src1`` and ``src2`` is independent 1D Fourier spectrum.
:param conj: Optional flag that conjugates the second source array before the multiplication (true) or not (false).
:param stddev: Standard deviation of the generated random numbers.
-The function ``randn`` fills the matrix ``mtx`` with normally distributed random numbers with the specified mean and standard deviation.
-?? is applied to the generated numbers (that is, the values are clipped)
+The function ``randn`` fills the matrix ``mtx`` with normally distributed random numbers with the specified mean and standard deviation. The generated random numbers are clipped to fit the value range of the destination array data type.
See Also:
:func:`RNG`,
(when ``mtx.cols=src.channels()+1`` )
-Every element of the ``N`` -channel array ``src`` is
-considered as an ``N`` -element vector that is transformed using
+Every element of the ``N`` -channel array ``src`` is interpreted as ``N`` -element vector that is transformed using
the
:math:`\texttt{M} \times \texttt{N}` or
-:math:`\texttt{M} \times \texttt{N+1}` matrix ``mtx`` into??
-an element of the ``M`` -channel array ``dst`` .
+:math:`\texttt{M} \times \texttt{N+1}` matrix ``mtx``
+to ``M``-element vector - the corresponding element of the destination array ``dst`` .
The function may be used for geometrical transformation of
:math:`N` -dimensional
Common Interfaces of Feature Detectors
======================================
+.. highlight:: cpp
+
Feature detectors in OpenCV have wrappers with common interface that enables to switch easily
between different algorithms solving the same problem. All objects that implement keypoint detectors
inherit
--------
.. c:type:: KeyPoint
- Data structure for salient point detectors. ::
+Data structure for salient point detectors. ::
class KeyPoint
{
// reads vector of keypoints from the specified file storage node
void read(const FileNode& node, CV_OUT vector<KeyPoint>& keypoints);
+..
+
.. index:: FeatureDetector
features2d. 2D Features Framework
*********************************
+.. highlight:: cpp
+
.. toctree::
:maxdepth: 2
Data Structures
===============
+.. highlight:: cpp
+
.. index:: gpu::DevMem2D\_
gpu::DevMem2D\_
----------------------------------
.. cpp:function:: void gpu::Stream::waitForCompletion()
- Blocks ?? until all operations in the stream are complete.
+ Blocks the current CPU thread until all operations in the stream are complete.
.. index:: gpu::StreamAccessor
:param type: Desired matrix type.
- :param m: Destination matrix.
-
- The following wrapper is also available: ??
-
-
+ :param m: Destination matrix.
gpu::meanShiftFiltering
---------------------------
-.. cpp:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst,
- int sp, int sr,
- TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
- + TermCriteria::EPS, 5, 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))
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.
:param sr: Color window radius.
- :param criteria: Termination criteria. See :c:class:`TermCriteria`.
+ :param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
.. index:: gpu::meanShiftProc
gpu::meanShiftProc
----------------------
-.. cpp:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp,
- int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
- + TermCriteria::EPS, 5, 1))
+.. cpp:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
:param sr: Color window radius.
- :param criteria: Termination criteria. See :c:class:`TermCriteria`.
+ :param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
See Also:
:c:func:`gpu::meanShiftFiltering`
:param minsize: Minimum segment size. Smaller segements are merged.
- :param criteria: Termination criteria. See :c:class:`TermCriteria`.
+ :param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
.. index:: gpu::integral
gpu::cornerHarris
---------------------
-.. cpp:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst,
- int blockSize, int ksize, double k,
- int borderType=BORDER_REFLECT101)
+.. cpp:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
Computes the Harris cornerness criteria at each image pixel.
:param src: Source image. Only ``CV_8UC1`` and ``CV_32FC1`` images are supported for now.
- :param dst: Destination image containing cornerness values. The size is the same??. The type is ``CV_32FC1`` .
+ :param dst: Destination image containing cornerness values. It has the same size as ``src`` and ``CV_32FC1`` type.
:param blockSize: Neighborhood size.
gpu::cornerMinEigenVal
--------------------------
-.. cpp:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst,
- int blockSize, int ksize,
- int borderType=BORDER_REFLECT101)
+.. cpp:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
Computes the minimum eigen value of 2x2 derivative covariation matrix at each pixel (the cornerness criteria).
gpu::mulSpectrums
---------------------
-.. cpp:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b,
- GpuMat& c, int flags, bool conjB=false)
+.. cpp:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false)
Performs a per-element multiplication of two Fourier spectrums.
gpu::mulAndScaleSpectrums
-----------------------------
-.. cpp:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b,
- GpuMat& c, int flags, float scale, bool conjB=false)
+.. cpp:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false)
Performs a per-element multiplication of two Fourier spectrums and scales the result.
gpu::convolve
-----------------
-.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
- bool ccorr=false)
+.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false)
-.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
- bool ccorr, ConvolveBuf& buf)
+.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf)
Computes a convolution (or cross-correlation) of two images.
gpu::matchTemplate
----------------------
-.. cpp:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ,
- GpuMat& result, int method)
+.. cpp:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method)
Computes a proximity map for a raster template and an image where the template is searched for.
Feature Detection
=================
+.. highlight:: cpp
+
.. index:: Canny
.. _Canny:
.. _ImageFiltering:
+.. highlight:: cpp
+
Image Filtering
===============
That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using
:func:`flip` and set the new anchor to ``(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`` .
-The function uses the
-??-based algorithm in case of sufficiently large kernels (~
-:math:`11\times11` ) and the direct algorithm (that uses the engine retrieved by
-: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 :func:`createLinearFilter` ) for small kernels.
See Also:
:func:`sepFilter2D`,
where
:math:`i=0..\texttt{ksize}-1` and
:math:`\alpha` is the scale factor chosen so that
-:math:`\sum_i G_i=1` . Two of such generated kernels can be passed to
+:math:`\sum_i G_i=1`.
+
+Two of such generated kernels can be passed to
:func:`sepFilter2D` or to
-:func:`createSeparableLinearFilter` . These functions?? automatically recognize smoothing kernels and handle them accordingly. You may also use the higher-level
-:func:`GaussianBlur` .
+: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
+:func:`GaussianBlur`.
See Also:
:func:`sepFilter2D`,
Geometric Image Transformations
===============================
+.. highlight:: cpp
+
The functions in this section perform various geometrical transformations of 2D images. They do not change the image content but deform the pixel grid, and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel
:math:`(x, y)` of the destination image, the functions compute coordinates of the corresponding "donor" pixel in the source image and copy the pixel value:
* **INTER_LINEAR** - a bilinear interpolation (used by default)
- * **INTER_AREA** - resampling using pixel area relation. It may be a preferred method for image decimation, as it gives freer?? results. But when the image is zoomed, it is similar to the ``INTER_NEAREST`` method.
+ * **INTER_AREA** - resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire-free results. But when the image is zoomed, it is similar to the ``INTER_NEAREST`` method.
* **INTER_CUBIC** - a bicubic interpolation over 4x4 pixel neighborhood
Histograms
==========
+.. highlight:: cpp
+
.. index:: calcHist
.. _calcHist:
Miscellaneous Image Transformations
===================================
+.. highlight:: cpp
+
.. index:: adaptiveThreshold
.. _adaptiveThreshold:
Motion Analysis and Object Tracking
===================================
+.. highlight:: cpp
+
.. index:: accumulate
accumulate
Object Detection
================
+.. highlight:: cpp
+
.. index:: matchTemplate
matchTemplate
-----------------
-.. c:function:: void matchTemplate( const Mat\& image, const Mat\& templ, Mat\& result, int method )
+.. c:function:: void matchTemplate( const Mat& image, const Mat& temp, Mat& result, int method )
Compares a template against overlapped image regions.
Structural Analysis and Shape Descriptors
=========================================
+.. highlight:: cpp
+
.. index:: moments
moments
projects / platform / upstream / opencv.git / commitdiff