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

the first round of cleaning up the RST docs

Browse Source
This commit is contained in:
Vadim Pisarevsky 2011-02-28 21:26:43 +00:00
parent eb8c0b8b4b
commit 4bb893aa9f
48 changed files with 1664 additions and 1649 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -77,25 +77,19 @@ be used for images of
The functions below use the above model to The functions below use the above model to
* * Project 3D points to the image plane given intrinsic and extrinsic parameters
Project 3D points to the image plane given intrinsic and extrinsic parameters
* * Compute extrinsic parameters given intrinsic parameters, a few 3D points and their projections.
Compute extrinsic parameters given intrinsic parameters, a few 3D points and their projections.
* * Estimate intrinsic and extrinsic camera parameters from several views of a known calibration pattern (i.e. every view is described by several 3D-2D point correspondences).
Estimate intrinsic and extrinsic camera parameters from several views of a known calibration pattern (i.e. every view is described by several 3D-2D point correspondences).
* * Estimate the relative position and orientation of the stereo camera "heads" and compute the *rectification* transformation that makes the camera optical axes parallel.
Estimate the relative position and orientation of the stereo camera "heads" and compute the
*rectification*
transformation that makes the camera optical axes parallel.
.. index:: calibrateCamera .. index:: calibrateCamera
cv::calibrateCamera cv::calibrateCamera
------------------- -------------------
.. cfunction:: double calibrateCamera( const vector<vector<Point3f> >\& objectPoints, const vector<vector<Point2f> >\& imagePoints, Size imageSize, Mat\& cameraMatrix, Mat\& distCoeffs, vector<Mat>\& rvecs, vector<Mat>\& tvecs, int flags=0 ) .. c:function:: double calibrateCamera( const vector<vector<Point3f> >& objectPoints, const vector<vector<Point2f> >& imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector<Mat>& rvecs, vector<Mat>& tvecs, int flags=0 )
Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern. Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
@ -168,7 +162,7 @@ See also:
cv::calibrationMatrixValues cv::calibrationMatrixValues
--------------------------- ---------------------------
.. cfunction:: void calibrationMatrixValues( const Mat\& cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double\& fovx, double\& fovy, double\& focalLength, Point2d\& principalPoint, double\& aspectRatio ) .. c:function:: void calibrationMatrixValues( const Mat& cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio )
Computes some useful camera characteristics from the camera matrix Computes some useful camera characteristics from the camera matrix
@ -188,15 +182,16 @@ cv::calibrationMatrixValues
:param principalPoint: The principal point in pixels :param principalPoint: The principal point in pixels
:param aspectRatio: :math:`f_y/f_x` :param aspectRatio: :math:`f_y/f_x`
The function computes various useful camera characteristics from the previously estimated camera matrix. The function computes various useful camera characteristics from the previously estimated camera matrix.
.. index:: composeRT .. index:: composeRT
cv::composeRT cv::composeRT
------------- -------------
.. cfunction:: void composeRT( const Mat\& rvec1, const Mat\& tvec1, const Mat\& rvec2, const Mat\& tvec2, Mat\& rvec3, Mat\& tvec3 ) .. c:function:: void composeRT( const Mat& rvec1, const Mat& tvec1, const Mat& rvec2, const Mat& tvec2, Mat& rvec3, Mat& tvec3 )
.. cfunction:: void composeRT( const Mat\& rvec1, const Mat\& tvec1, const Mat\& rvec2, const Mat\& tvec2, Mat\& rvec3, Mat\& tvec3, Mat\& dr3dr1, Mat\& dr3dt1, Mat\& dr3dr2, Mat\& dr3dt2, Mat\& dt3dr1, Mat\& dt3dt1, Mat\& dt3dr2, Mat\& dt3dt2 ) .. c:function:: void composeRT( const Mat& rvec1, const Mat& tvec1, const Mat& rvec2, const Mat& tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1, Mat& dr3dt1, Mat& dr3dr2, Mat& dr3dt2, Mat& dt3dr1, Mat& dt3dt1, Mat& dt3dr2, Mat& dt3dt2 )
Combines two rotation-and-shift transformations Combines two rotation-and-shift transformations
@ -213,35 +208,35 @@ cv::composeRT
:param tvec3: The output translation vector of the superposition :param tvec3: The output translation vector of the superposition
:param d??d??: The optional output derivatives of ``rvec3`` or ``tvec3`` w.r.t. ``rvec?`` or ``tvec?`` :param d??d??: The optional output derivatives of ``rvec3`` or ``tvec3`` w.r.t. ``rvec?`` or ``tvec?``
The functions compute: The functions compute:
.. math:: .. math::
\begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} , \begin{array}{l} \texttt{rvec3} = \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right ) \\ \texttt{tvec3} = \mathrm{rodrigues} ( \texttt{rvec2} ) \cdot \texttt{tvec1} + \texttt{tvec2} \end{array} ,
where where :math:`\mathrm{rodrigues}` denotes a rotation vector to rotation matrix transformation, and
:math:`\mathrm{rodrigues}` denotes a rotation vector to rotation matrix transformation, and :math:`\mathrm{rodrigues}^{-1}` denotes the inverse transformation, see :func:`Rodrigues`.
:math:`\mathrm{rodrigues}^{-1}` denotes the inverse transformation, see
:func:`Rodrigues` .
Also, the functions can compute the derivatives of the output vectors w.r.t the input vectors (see Also, the functions can compute the derivatives of the output vectors w.r.t the input vectors (see :func:`matMulDeriv` ).
:func:`matMulDeriv` ). The functions are used inside :func:`stereoCalibrate` but can also be used in your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a function that contains matrix multiplication.
The functions are used inside
:func:`stereoCalibrate` but can also be used in your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a function that contains matrix multiplication.
.. index:: computeCorrespondEpilines .. index:: computeCorrespondEpilines
cv::computeCorrespondEpilines cv::computeCorrespondEpilines
----------------------------- -----------------------------
.. cfunction:: void computeCorrespondEpilines( const Mat\& points, int whichImage, const Mat\& F, vector<Vec3f>\& lines ) .. c:function:: void computeCorrespondEpilines( const Mat& points, int whichImage, const Mat& F, vector<Vec3f>& lines )
For points in one image of a stereo pair, computes the corresponding epilines in the other image. For points in one image of a stereo pair, computes the corresponding epilines in the other image.
:param points: The input points. :math:`N \times 1` or :math:`1 \times N` matrix of type ``CV_32FC2`` or ``vector<Point2f>`` :param points: The input points. :math:`N \times 1` or :math:`1 \times N` matrix of type ``CV_32FC2`` or ``vector<Point2f>``
:param whichImage: Index of the image (1 or 2) that contains the ``points`` :param whichImage: Index of the image (1 or 2) that contains the ``points``
:param F: The fundamental matrix that can be estimated using :ref:`FindFundamentalMat` or :ref:`StereoRectify` . :param F: The fundamental matrix that can be estimated using :ref:`FindFundamentalMat` or :ref:`StereoRectify` .
:param lines: The output vector of the corresponding to the points epipolar lines in the other image. Each line :math:`ax + by + c=0` is encoded by 3 numbers :math:`(a, b, c)` :param lines: The output vector of the corresponding to the points epipolar lines in the other image. Each line :math:`ax + by + c=0` is encoded by 3 numbers :math:`(a, b, c)`
For every point in one of the two images of a stereo-pair the function finds the equation of the For every point in one of the two images of a stereo-pair the function finds the equation of the
corresponding epipolar line in the other image. corresponding epipolar line in the other image.
@ -269,9 +264,9 @@ Line coefficients are defined up to a scale. They are normalized, such that
cv::convertPointsHomogeneous cv::convertPointsHomogeneous
---------------------------- ----------------------------
.. cfunction:: void convertPointsHomogeneous( const Mat\& src, vector<Point3f>\& dst ) .. c:function:: void convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst )
.. cfunction:: void convertPointsHomogeneous( const Mat\& src, vector<Point2f>\& dst ) .. c:function:: void convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst )
Convert points to/from homogeneous coordinates. Convert points to/from homogeneous coordinates.
@ -279,10 +274,7 @@ cv::convertPointsHomogeneous
:param dst: The output vector of 2D or 2D points :param dst: The output vector of 2D or 2D points
The The functions convert 2D or 3D points from/to homogeneous coordinates, or simply copy or transpose
functions convert
2D or 3D points from/to homogeneous coordinates, or simply
copy or transpose
the array. If the input array dimensionality is larger than the output, each coordinate is divided by the last coordinate: the array. If the input array dimensionality is larger than the output, each coordinate is divided by the last coordinate:
.. math:: .. math::
@ -295,9 +287,9 @@ If the output array dimensionality is larger, an extra 1 is appended to each poi
cv::decomposeProjectionMatrix cv::decomposeProjectionMatrix
----------------------------- -----------------------------
.. cfunction:: void decomposeProjectionMatrix( const Mat\& projMatrix, Mat\& cameraMatrix, Mat\& rotMatrix, Mat\& transVect ) .. c:function:: void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect )
.. cfunction:: void decomposeProjectionMatrix( const Mat\& projMatrix, Mat\& cameraMatrix, Mat\& rotMatrix, Mat\& transVect, Mat\& rotMatrixX, Mat\& rotMatrixY, Mat\& rotMatrixZ, Vec3d\& eulerAngles ) .. c:function:: void decomposeProjectionMatrix( const Mat& projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX, Mat& rotMatrixY, Mat& rotMatrixZ, Vec3d& eulerAngles )
Decomposes the projection matrix into a rotation matrix and a camera matrix. Decomposes the projection matrix into a rotation matrix and a camera matrix.
@ -328,7 +320,7 @@ The function is based on
cv::drawChessboardCorners cv::drawChessboardCorners
------------------------- -------------------------
.. cfunction:: void drawChessboardCorners( Mat\& image, Size patternSize, const Mat\& corners, bool patternWasFound ) .. c:function:: void drawChessboardCorners( Mat& image, Size patternSize, const Mat& corners, bool patternWasFound )
Renders the detected chessboard corners. Renders the detected chessboard corners.
@ -346,7 +338,7 @@ The function draws the individual chessboard corners detected as red circles if
cv::findChessboardCorners cv::findChessboardCorners
------------------------- -------------------------
.. cfunction:: bool findChessboardCorners( const Mat\& image, Size patternSize, vector<Point2f>\& corners, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+ CV_CALIB_CB_NORMALIZE_IMAGE ) .. c:function:: bool findChessboardCorners( const Mat& image, Size patternSize, vector<Point2f>& corners, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+ CV_CALIB_CB_NORMALIZE_IMAGE )
Finds the positions of the internal corners of the chessboard. Finds the positions of the internal corners of the chessboard.
@ -398,7 +390,6 @@ Sample usage of detecting and drawing chessboard corners: ::
TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1)); TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
drawChessboardCorners(img, patternsize, Mat(corners), patternfound); drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
..
**Note:** **Note:**
the function requires some white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environment (otherwise if there is no border and the background is dark, the outer black squares could not be segmented properly and so the square grouping and ordering algorithm will fail). the function requires some white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environment (otherwise if there is no border and the background is dark, the outer black squares could not be segmented properly and so the square grouping and ordering algorithm will fail).
@ -407,7 +398,7 @@ the function requires some white space (like a square-thick border, the wider th
cv::findCirclesGrid cv::findCirclesGrid
------------------- -------------------
.. cfunction:: bool findCirclesGrid( const Mat\& image, Size patternSize, vector<Point2f>\& centers, int flags=CALIB_CB_SYMMETRIC_GRID ) .. c:function:: bool findCirclesGrid( const Mat& image, Size patternSize, vector<Point2f>& centers, int flags=CALIB_CB_SYMMETRIC_GRID )
Finds the centers of the cirlces' grid. Finds the centers of the cirlces' grid.
@ -443,7 +434,6 @@ Sample usage of detecting and drawing circles' centers: ::
bool patternfound = findCirclesGrid(gray, patternsize, centers); bool patternfound = findCirclesGrid(gray, patternsize, centers);
drawChessboardCorners(img, patternsize, Mat(centers), patternfound); drawChessboardCorners(img, patternsize, Mat(centers), patternfound);
..
**Note:** **Note:**
the function requires some white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environment. the function requires some white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environment.
@ -452,7 +442,7 @@ the function requires some white space (like a square-thick border, the wider th
cv::solvePnP cv::solvePnP
------------ ------------
.. cfunction:: void solvePnP( const Mat\& objectPoints, const Mat\& imagePoints, const Mat\& cameraMatrix, const Mat\& distCoeffs, Mat\& rvec, Mat\& tvec, bool useExtrinsicGuess=false ) .. c:function:: void solvePnP( const Mat& objectPoints, const Mat& imagePoints, const Mat& cameraMatrix, const Mat& distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess=false )
Finds the object pose from the 3D-2D point correspondences Finds the object pose from the 3D-2D point correspondences
@ -476,9 +466,9 @@ The function estimates the object pose given a set of object points, their corre
cv::findFundamentalMat cv::findFundamentalMat
---------------------- ----------------------
.. cfunction:: Mat findFundamentalMat( const Mat\& points1, const Mat\& points2, vector<uchar>\& status, int method=FM_RANSAC, double param1=3., double param2=0.99 ) .. c:function:: Mat findFundamentalMat( const Mat& points1, const Mat& points2, vector<uchar>& status, int method=FM_RANSAC, double param1=3., double param2=0.99 )
.. cfunction:: Mat findFundamentalMat( const Mat\& points1, const Mat\& points2, int method=FM_RANSAC, double param1=3., double param2=0.99 ) .. c:function:: Mat findFundamentalMat( const Mat& points1, const Mat& points2, int method=FM_RANSAC, double param1=3., double param2=0.99 )
Calculates the fundamental matrix from the corresponding points in two images. Calculates the fundamental matrix from the corresponding points in two images.
@ -532,17 +522,16 @@ corresponding to the specified points. It can also be passed to
Mat fundamental_matrix = Mat fundamental_matrix =
findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99); findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
..
.. index:: findHomography .. index:: findHomography
cv::findHomography cv::findHomography
------------------ ------------------
.. cfunction:: Mat findHomography( const Mat\& srcPoints, const Mat\& dstPoints, Mat\& status, int method=0, double ransacReprojThreshold=3 ) .. c:function:: Mat findHomography( const Mat& srcPoints, const Mat& dstPoints, Mat& status, int method=0, double ransacReprojThreshold=3 )
.. cfunction:: Mat findHomography( const Mat\& srcPoints, const Mat\& dstPoints, vector<uchar>\& status, int method=0, double ransacReprojThreshold=3 ) .. c:function:: Mat findHomography( const Mat& srcPoints, const Mat& dstPoints, vector<uchar>& status, int method=0, double ransacReprojThreshold=3 )
.. cfunction:: Mat findHomography( const Mat\& srcPoints, const Mat\& dstPoints, int method=0, double ransacReprojThreshold=3 ) .. c:function:: Mat findHomography( const Mat& srcPoints, const Mat& dstPoints, int method=0, double ransacReprojThreshold=3 )
Finds the perspective transformation between two planes. Finds the perspective transformation between two planes.
@ -568,10 +557,7 @@ cv::findHomography
:param status: The optional output mask set by a robust method ( ``CV_RANSAC`` or ``CV_LMEDS`` ). *Note that the input mask values are ignored.* :param status: The optional output mask set by a robust method ( ``CV_RANSAC`` or ``CV_LMEDS`` ). *Note that the input mask values are ignored.*
The The functions find and return the perspective transformation :math:`H` between the source and the destination planes:
functions find and return
the perspective transformation
:math:`H` between the source and the destination planes:
.. math:: .. math::
@ -622,7 +608,7 @@ See also:
cv::getDefaultNewCameraMatrix cv::getDefaultNewCameraMatrix
----------------------------- -----------------------------
.. cfunction:: Mat getDefaultNewCameraMatrix( const Mat\& cameraMatrix, Size imgSize=Size(), bool centerPrincipalPoint=false ) .. c:function:: Mat getDefaultNewCameraMatrix( const Mat& cameraMatrix, Size imgSize=Size(), bool centerPrincipalPoint=false )
Returns the default new camera matrix Returns the default new camera matrix
@ -652,7 +638,7 @@ By default, the undistortion functions in OpenCV (see ``initUndistortRectifyMap`
cv::getOptimalNewCameraMatrix cv::getOptimalNewCameraMatrix
----------------------------- -----------------------------
.. cfunction:: Mat getOptimalNewCameraMatrix( const Mat\& cameraMatrix, const Mat\& distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0) .. c:function:: Mat getOptimalNewCameraMatrix( const Mat& cameraMatrix, const Mat& distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0)
Returns the new camera matrix based on the free scaling parameter Returns the new camera matrix based on the free scaling parameter
@ -668,8 +654,8 @@ cv::getOptimalNewCameraMatrix
:param newImageSize: The image size after rectification. By default it will be set to ``imageSize`` . :param newImageSize: The image size after rectification. By default it will be set to ``imageSize`` .
:param validPixROI: The optional output rectangle that will outline all-good-pixels region in the undistorted image. See ``roi1, roi2`` description in :ref:`StereoRectify` :param validPixROI: The optional output rectangle that will outline all-good-pixels region in the undistorted image. See ``roi1, roi2`` description in :ref:`StereoRectify`
The function computes
and returns The function computes and returns
the optimal new camera matrix based on the free scaling parameter. By varying this parameter the user may retrieve only sensible pixels ``alpha=0`` , keep all the original image pixels if there is valuable information in the corners ``alpha=1`` , or get something in between. When ``alpha>0`` , the undistortion result will likely have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera matrix, distortion coefficients, the computed new camera matrix and the ``newImageSize`` should be passed to the optimal new camera matrix based on the free scaling parameter. By varying this parameter the user may retrieve only sensible pixels ``alpha=0`` , keep all the original image pixels if there is valuable information in the corners ``alpha=1`` , or get something in between. When ``alpha>0`` , the undistortion result will likely have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera matrix, distortion coefficients, the computed new camera matrix and the ``newImageSize`` should be passed to
:ref:`InitUndistortRectifyMap` to produce the maps for :ref:`InitUndistortRectifyMap` to produce the maps for
:ref:`Remap` . :ref:`Remap` .
@ -678,15 +664,18 @@ the optimal new camera matrix based on the free scaling parameter. By varying t
cv::initCameraMatrix2D cv::initCameraMatrix2D
---------------------- ----------------------
.. cfunction:: Mat initCameraMatrix2D( const vector<vector<Point3f> >\& objectPoints, const vector<vector<Point2f> >\& imagePoints, Size imageSize, double aspectRatio=1.) .. c:function:: Mat initCameraMatrix2D( const vector<vector<Point3f> >& objectPoints, const vector<vector<Point2f> >& imagePoints, Size imageSize, double aspectRatio=1.)
Finds the initial camera matrix from the 3D-2D point correspondences Finds the initial camera matrix from the 3D-2D point correspondences
:param objectPoints: The vector of vectors of the object points. See :func:`calibrateCamera` :param objectPoints: The vector of vectors of the object points. See :func:`calibrateCamera`
:param imagePoints: The vector of vectors of the corresponding image points. See :func:`calibrateCamera` :param imagePoints: The vector of vectors of the corresponding image points. See :func:`calibrateCamera`
:param imageSize: The image size in pixels; used to initialize the principal point :param imageSize: The image size in pixels; used to initialize the principal point
:param aspectRatio: If it is zero or negative, both :math:`f_x` and :math:`f_y` are estimated independently. Otherwise :math:`f_x = f_y * \texttt{aspectRatio}` :param aspectRatio: If it is zero or negative, both :math:`f_x` and :math:`f_y` are estimated independently. Otherwise :math:`f_x = f_y * \texttt{aspectRatio}`
The function estimates and returns the initial camera matrix for camera calibration process. The function estimates and returns the initial camera matrix for camera calibration process.
Currently, the function only supports planar calibration patterns, i.e. patterns where each object point has z-coordinate =0. Currently, the function only supports planar calibration patterns, i.e. patterns where each object point has z-coordinate =0.
@ -694,19 +683,23 @@ Currently, the function only supports planar calibration patterns, i.e. patterns
cv::initUndistortRectifyMap cv::initUndistortRectifyMap
--------------------------- ---------------------------
.. cfunction:: void initUndistortRectifyMap( const Mat\& cameraMatrix, const Mat\& distCoeffs, const Mat\& R, const Mat\& newCameraMatrix, Size size, int m1type, Mat\& map1, Mat\& map2 )
.. c:function:: void initUndistortRectifyMap( const Mat& cameraMatrix, const Mat& distCoeffs, const Mat& R, const Mat& newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2 )
Computes the undistortion and rectification transformation map. Computes the undistortion and rectification transformation map.
:param cameraMatrix: The input camera matrix :math:`A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}` :param cameraMatrix: The input camera matrix :math:`A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
:param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed. :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param R: The optional rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :ref:`StereoRectify` can be passed here. If the matrix is empty , the identity transformation is assumed :param R: The optional rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :ref:`StereoRectify` can be passed here. If the matrix is empty , the identity transformation is assumed
:param newCameraMatrix: The new camera matrix :math:`A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}` :param newCameraMatrix: The new camera matrix :math:`A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}`
:param size: The undistorted image size :param size: The undistorted image size
:param m1type: The type of the first output map, can be ``CV_32FC1`` or ``CV_16SC2`` . See :func:`convertMaps` :param m1type: The type of the first output map, can be ``CV_32FC1`` or ``CV_16SC2`` . See :func:`convertMaps`
:param map1: The first output map :param map1: The first output map
:param map2: The second output map :param map2: The second output map
@ -744,7 +737,8 @@ where the ``cameraMatrix`` can be chosen arbitrarily.
cv::matMulDeriv cv::matMulDeriv
--------------- ---------------
.. cfunction:: void matMulDeriv( const Mat\& A, const Mat\& B, Mat\& dABdA, Mat\& dABdB )
.. c:function:: void matMulDeriv( const Mat& A, const Mat& B, Mat& dABdA, Mat& dABdB )
Computes partial derivatives of the matrix product w.r.t each multiplied matrix Computes partial derivatives of the matrix product w.r.t each multiplied matrix
@ -753,7 +747,9 @@ cv::matMulDeriv
:param B: The second multiplied matrix :param B: The second multiplied matrix
:param dABdA: The first output derivative matrix ``d(A*B)/dA`` of size :math:`\texttt{A.rows*B.cols} \times {A.rows*A.cols}` :param dABdA: The first output derivative matrix ``d(A*B)/dA`` of size :math:`\texttt{A.rows*B.cols} \times {A.rows*A.cols}`
:param dABdA: The second output derivative matrix ``d(A*B)/dB`` of size :math:`\texttt{A.rows*B.cols} \times {B.rows*B.cols}` :param dABdA: The second output derivative matrix ``d(A*B)/dB`` of size :math:`\texttt{A.rows*B.cols} \times {B.rows*B.cols}`
The function computes the partial derivatives of the elements of the matrix product The function computes the partial derivatives of the elements of the matrix product
:math:`A*B` w.r.t. the elements of each of the two input matrices. The function is used to compute Jacobian matrices in :math:`A*B` w.r.t. the elements of each of the two input matrices. The function is used to compute Jacobian matrices in
:func:`stereoCalibrate` , but can also be used in any other similar optimization function. :func:`stereoCalibrate` , but can also be used in any other similar optimization function.
@ -762,18 +758,21 @@ The function computes the partial derivatives of the elements of the matrix prod
cv::projectPoints cv::projectPoints
----------------- -----------------
.. cfunction:: void projectPoints( const Mat\& objectPoints, const Mat\& rvec, const Mat\& tvec, const Mat\& cameraMatrix, const Mat\& distCoeffs, vector<Point2f>\& imagePoints )
.. cfunction:: void projectPoints( const Mat\& objectPoints, const Mat\& rvec, const Mat\& tvec, const Mat\& cameraMatrix, const Mat\& distCoeffs, vector<Point2f>\& imagePoints, Mat\& dpdrot, Mat\& dpdt, Mat\& dpdf, Mat\& dpdc, Mat\& dpddist, double aspectRatio=0 ) .. c:function:: void projectPoints( const Mat& objectPoints, const Mat& rvec, const Mat& tvec, const Mat& cameraMatrix, const Mat& distCoeffs, vector<Point2f>& imagePoints )
.. c:function:: void projectPoints( const Mat& objectPoints, const Mat& rvec, const Mat& tvec, const Mat& cameraMatrix, const Mat& distCoeffs, vector<Point2f>& imagePoints, Mat& dpdrot, Mat& dpdt, Mat& dpdf, Mat& dpdc, Mat& dpddist, double aspectRatio=0 )
Project 3D points on to an image plane. Project 3D points on to an image plane.
:param objectPoints: The array of object points, 3xN or Nx3 1-channel or 1xN or Nx1 3-channel (or ``vector<Point3f>`` ) , where N is the number of points in the view :param objectPoints: The array of object points, 3xN or Nx3 1-channel or 1xN or Nx1 3-channel (or ``vector<Point3f>`` ) , where N is the number of points in the view
:param rvec: The rotation vector, see :ref:`Rodrigues2` :param rvec: The rotation vector, see :ref:`Rodrigues2`
:param tvec: The translation vector :param tvec: The translation vector
:param cameraMatrix: The camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}` :param cameraMatrix: The camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}`
:param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed. :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param imagePoints: The output array of image points, 2xN or Nx2 1-channel or 1xN or Nx1 2-channel (or ``vector<Point2f>`` ) :param imagePoints: The output array of image points, 2xN or Nx2 1-channel or 1xN or Nx1 2-channel (or ``vector<Point2f>`` )
@ -783,7 +782,9 @@ cv::projectPoints
:param dpdt: Optional 2Nx3 matrix of derivatives of image points with respect to components of the translation vector :param dpdt: Optional 2Nx3 matrix of derivatives of image points with respect to components of the translation vector
:param dpdf: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`f_x` and :math:`f_y` :param dpdf: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`f_x` and :math:`f_y`
:param dpdc: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`c_x` and :math:`c_y` :param dpdc: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`c_x` and :math:`c_y`
:param dpddist: Optional 2Nx4 matrix of derivatives of image points with respect to distortion coefficients :param dpddist: Optional 2Nx4 matrix of derivatives of image points with respect to distortion coefficients
The function computes projections of 3D The function computes projections of 3D
@ -804,7 +805,8 @@ Note, that by setting ``rvec=tvec=(0,0,0)`` , or by setting ``cameraMatrix`` to
cv::reprojectImageTo3D cv::reprojectImageTo3D
---------------------- ----------------------
.. cfunction:: void reprojectImageTo3D( const Mat\& disparity, Mat\& _3dImage, const Mat\& Q, bool handleMissingValues=false )
.. c:function:: void reprojectImageTo3D( const Mat& disparity, Mat& _3dImage, const Mat& Q, bool handleMissingValues=false )
Reprojects disparity image to 3D space. Reprojects disparity image to 3D space.
@ -814,6 +816,7 @@ cv::reprojectImageTo3D
Each element of ``_3dImage(x,y)`` will contain the 3D coordinates of the point ``(x,y)`` , computed from the disparity map. Each element of ``_3dImage(x,y)`` will contain the 3D coordinates of the point ``(x,y)`` , computed from the disparity map.
:param Q: The :math:`4 \times 4` perspective transformation matrix that can be obtained with :ref:`StereoRectify` :param Q: The :math:`4 \times 4` perspective transformation matrix that can be obtained with :ref:`StereoRectify`
:param handleMissingValues: If true, when the pixels with the minimal disparity (that corresponds to the outliers; see :ref:`FindStereoCorrespondenceBM` ) will be transformed to 3D points with some very large Z value (currently set to 10000) :param handleMissingValues: If true, when the pixels with the minimal disparity (that corresponds to the outliers; see :ref:`FindStereoCorrespondenceBM` ) will be transformed to 3D points with some very large Z value (currently set to 10000)
The function transforms 1-channel disparity map to 3-channel image representing a 3D surface. That is, for each pixel ``(x,y)`` and the corresponding disparity ``d=disparity(x,y)`` it computes: The function transforms 1-channel disparity map to 3-channel image representing a 3D surface. That is, for each pixel ``(x,y)`` and the corresponding disparity ``d=disparity(x,y)`` it computes:
@ -831,9 +834,9 @@ The matrix ``Q`` can be arbitrary
cv::RQDecomp3x3 cv::RQDecomp3x3
--------------- ---------------
.. cfunction:: void RQDecomp3x3( const Mat\& M, Mat\& R, Mat\& Q ) .. c:function:: void RQDecomp3x3( const Mat& M, Mat& R, Mat& Q )
.. cfunction:: Vec3d RQDecomp3x3( const Mat\& M, Mat\& R, Mat\& Q, Mat\& Qx, Mat\& Qy, Mat\& Qz ) .. c:function:: Vec3d RQDecomp3x3( const Mat& M, Mat& R, Mat& Q, Mat& Qx, Mat& Qy, Mat& Qz )
Computes the 'RQ' decomposition of 3x3 matrices. Computes the 'RQ' decomposition of 3x3 matrices.
@ -860,9 +863,9 @@ that could be used in OpenGL.
cv::Rodrigues cv::Rodrigues
------------- -------------
.. cfunction:: void Rodrigues(const Mat\& src, Mat\& dst) .. c:function:: void Rodrigues(const Mat& src, Mat& dst)
.. cfunction:: void Rodrigues(const Mat\& src, Mat\& dst, Mat\& jacobian) .. c:function:: void Rodrigues(const Mat& src, Mat& dst, Mat& jacobian)
Converts a rotation matrix to a rotation vector or vice versa. Converts a rotation matrix to a rotation vector or vice versa.
@ -894,7 +897,7 @@ used in the global 3D geometry optimization procedures like
StereoBM StereoBM
-------- --------
.. ctype:: StereoBM .. c:type:: StereoBM
The class for computing stereo correspondence using block matching algorithm. :: The class for computing stereo correspondence using block matching algorithm. ::
@ -920,11 +923,9 @@ The class for computing stereo correspondence using block matching algorithm. ::
Ptr<CvStereoBMState> state; Ptr<CvStereoBMState> state;
}; };
..
The class is a C++ wrapper for The class is a C++ wrapper for and the associated functions. In particular, ``StereoBM::operator ()`` is the wrapper for
and the associated functions. In particular, ``StereoBM::operator ()`` is the wrapper for :ref:`FindStereoCorrespondceBM`. See the respective descriptions.
:ref:`FindStereoCorrespondceBM` . See the respective descriptions.
.. index:: StereoSGBM .. index:: StereoSGBM
@ -932,7 +933,7 @@ and the associated functions. In particular, ``StereoBM::operator ()`` is the wr
StereoSGBM StereoSGBM
---------- ----------
.. ctype:: StereoSGBM .. c:type:: StereoSGBM
The class for computing stereo correspondence using semi-global block matching algorithm. :: The class for computing stereo correspondence using semi-global block matching algorithm. ::
@ -961,7 +962,6 @@ The class for computing stereo correspondence using semi-global block matching a
... ...
}; };
..
The class implements modified H. Hirschmuller algorithm The class implements modified H. Hirschmuller algorithm
HH08 HH08
@ -988,9 +988,9 @@ HH08
cv::StereoSGBM::StereoSGBM cv::StereoSGBM::StereoSGBM
-------------------------- --------------------------
.. cfunction:: StereoSGBM::StereoSGBM() .. c:function:: StereoSGBM::StereoSGBM()
.. cfunction:: 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) .. c: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)
StereoSGBM constructors StereoSGBM constructors
@ -998,9 +998,7 @@ cv::StereoSGBM::StereoSGBM
:param numDisparities: This is maximum disparity minus minimum disparity. Always greater than 0. In the current implementation this parameter must be divisible by 16. :param numDisparities: This is maximum disparity minus minimum disparity. Always greater than 0. In the current implementation this parameter must be divisible by 16.
:param SADWindowSize: The matched block size. Must be an odd number ``>=1`` . Normally, it should be somewhere in ``3..11`` range :param SADWindowSize: The matched block size. Must be an odd number ``>=1`` . Normally, it should be somewhere in ``3..11`` range.
.
:param P1, P2: Parameters that control disparity smoothness. The larger the values, the smoother the disparity. ``P1`` is the penalty on the disparity change by plus or minus 1 between neighbor pixels. ``P2`` is the penalty on the disparity change by more than 1 between neighbor pixels. The algorithm requires ``P2 > P1`` . See ``stereo_match.cpp`` sample where some reasonably good ``P1`` and ``P2`` values are shown (like ``8*number_of_image_channels*SADWindowSize*SADWindowSize`` and ``32*number_of_image_channels*SADWindowSize*SADWindowSize`` , respectively). :param P1, P2: Parameters that control disparity smoothness. The larger the values, the smoother the disparity. ``P1`` is the penalty on the disparity change by plus or minus 1 between neighbor pixels. ``P2`` is the penalty on the disparity change by more than 1 between neighbor pixels. The algorithm requires ``P2 > P1`` . See ``stereo_match.cpp`` sample where some reasonably good ``P1`` and ``P2`` values are shown (like ``8*number_of_image_channels*SADWindowSize*SADWindowSize`` and ``32*number_of_image_channels*SADWindowSize*SADWindowSize`` , respectively).
@ -1015,13 +1013,15 @@ cv::StereoSGBM::StereoSGBM
:param speckleRange: Maximum disparity variation within each connected component. If you do speckle filtering, set it to some positive value, multiple of 16. Normally, 16 or 32 is good enough. :param speckleRange: Maximum disparity variation within each connected component. If you do speckle filtering, set it to some positive value, multiple of 16. Normally, 16 or 32 is good enough.
:param fullDP: Set it to ``true`` to run full-scale 2-pass dynamic programming algorithm. It will consume O(W*H*numDisparities) bytes, which is large for 640x480 stereo and huge for HD-size pictures. By default this is ``false`` :param fullDP: Set it to ``true`` to run full-scale 2-pass dynamic programming algorithm. It will consume O(W*H*numDisparities) bytes, which is large for 640x480 stereo and huge for HD-size pictures. By default this is ``false``
The first constructor initializes ``StereoSGBM`` with all the default parameters (so actually one will only have to set ``StereoSGBM::numberOfDisparities`` at minimum). The second constructor allows you to set each parameter to a custom value. The first constructor initializes ``StereoSGBM`` with all the default parameters (so actually one will only have to set ``StereoSGBM::numberOfDisparities`` at minimum). The second constructor allows you to set each parameter to a custom value.
.. index:: StereoSGBM::operator () .. index:: StereoSGBM::operator ()
cv::StereoSGBM::operator () cv::StereoSGBM::operator ()
--------------------------- ---------------------------
.. cfunction:: void SGBM::operator()(const Mat\& left, const Mat\& right, Mat\& disp)
.. c:function:: void SGBM::operator()(const Mat& left, const Mat& right, Mat& disp)
Computes disparity using SGBM algorithm for a rectified stereo pair Computes disparity using SGBM algorithm for a rectified stereo pair
@ -1037,7 +1037,7 @@ The method executes SGBM algorithm on a rectified stereo pair. See ``stereo_matc
cv::stereoCalibrate cv::stereoCalibrate
------------------- -------------------
.. cfunction:: double stereoCalibrate( const vector<vector<Point3f> >\& objectPoints, const vector<vector<Point2f> >\& imagePoints1, const vector<vector<Point2f> >\& imagePoints2, Mat\& cameraMatrix1, Mat\& distCoeffs1, Mat\& cameraMatrix2, Mat\& distCoeffs2, Size imageSize, Mat\& R, Mat\& T, Mat\& E, Mat\& F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+ TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC ) .. c:function:: double stereoCalibrate( const vector<vector<Point3f> >& objectPoints, const vector<vector<Point2f> >& imagePoints1, const vector<vector<Point2f> >& imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+ TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC )
Calibrates stereo camera. Calibrates stereo camera.
@ -1123,9 +1123,9 @@ The function returns the final value of the re-projection error.
cv::stereoRectify cv::stereoRectify
----------------- -----------------
.. cfunction:: void stereoRectify( const Mat\& cameraMatrix1, const Mat\& distCoeffs1, const Mat\& cameraMatrix2, const Mat\& distCoeffs2, Size imageSize, const Mat\& R, const Mat\& T, Mat\& R1, Mat\& R2, Mat\& P1, Mat\& P2, Mat\& Q, int flags=CALIB_ZERO_DISPARITY ) .. c:function:: void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1, const Mat& cameraMatrix2, const Mat& distCoeffs2, Size imageSize, const Mat& R, const Mat& T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags=CALIB_ZERO_DISPARITY )
.. cfunction:: void stereoRectify( const Mat\& cameraMatrix1, const Mat\& distCoeffs1, const Mat\& cameraMatrix2, const Mat\& distCoeffs2, Size imageSize, const Mat\& R, const Mat\& T, Mat\& R1, Mat\& R2, Mat\& P1, Mat\& P2, Mat\& Q, double alpha, Size newImageSize=Size(), Rect* roi1=0, Rect* roi2=0, int flags=CALIB_ZERO_DISPARITY ) .. c:function:: void stereoRectify( const Mat& cameraMatrix1, const Mat& distCoeffs1, const Mat& cameraMatrix2, const Mat& distCoeffs2, Size imageSize, const Mat& R, const Mat& T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, double alpha, Size newImageSize=Size(), Rect* roi1=0, Rect* roi2=0, int flags=CALIB_ZERO_DISPARITY )
Computes rectification transforms for each head of a calibrated stereo camera. Computes rectification transforms for each head of a calibrated stereo camera.
@ -1198,7 +1198,7 @@ Below is the screenshot from ``stereo_calib.cpp`` sample. Some red horizontal li
cv::stereoRectifyUncalibrated cv::stereoRectifyUncalibrated
----------------------------- -----------------------------
.. cfunction:: bool stereoRectifyUncalibrated( const Mat\& points1, const Mat\& points2, const Mat\& F, Size imgSize, Mat\& H1, Mat\& H2, double threshold=5 ) .. c:function:: bool stereoRectifyUncalibrated( const Mat& points1, const Mat& points2, const Mat& F, Size imgSize, Mat& H1, Mat& H2, double threshold=5 )
Computes rectification transform for uncalibrated stereo camera. Computes rectification transform for uncalibrated stereo camera.
@ -1227,14 +1227,16 @@ Note that while the algorithm does not need to know the intrinsic parameters of
cv::undistort cv::undistort
------------- -------------
.. cfunction:: void undistort( const Mat\& src, Mat\& dst, const Mat\& cameraMatrix, const Mat\& distCoeffs, const Mat\& newCameraMatrix=Mat() ) .. c:function:: void undistort( const Mat& src, Mat& dst, const Mat& cameraMatrix, const Mat& distCoeffs, const Mat& newCameraMatrix=Mat() )
Transforms an image to compensate for lens distortion. Transforms an image to compensate for lens distortion.
:param src: The input (distorted) image :param src: The input (distorted) image
:param dst: The output (corrected) image; will have the same size and the same type as ``src`` :param dst: The output (corrected) image; will have the same size and the same type as ``src``
:param cameraMatrix: The input camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}` :param cameraMatrix: The input camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
:param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed. :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param newCameraMatrix: Camera matrix of the distorted image. By default it is the same as ``cameraMatrix`` , but you may additionally scale and shift the result by using some different matrix :param newCameraMatrix: Camera matrix of the distorted image. By default it is the same as ``cameraMatrix`` , but you may additionally scale and shift the result by using some different matrix
@ -1259,9 +1261,9 @@ The camera matrix and the distortion parameters can be determined using
cv::undistortPoints cv::undistortPoints
------------------- -------------------
.. cfunction:: void undistortPoints( const Mat\& src, vector<Point2f>\& dst, const Mat\& cameraMatrix, const Mat\& distCoeffs, const Mat\& R=Mat(), const Mat\& P=Mat()) .. c:function:: void undistortPoints( const Mat& src, vector<Point2f>& dst, const Mat& cameraMatrix, const Mat& distCoeffs, const Mat& R=Mat(), const Mat& P=Mat())
.. cfunction:: void undistortPoints( const Mat\& src, Mat\& dst, const Mat\& cameraMatrix, const Mat\& distCoeffs, const Mat\& R=Mat(), const Mat\& P=Mat()) .. c:function:: void undistortPoints( const Mat& src, Mat& dst, const Mat& cameraMatrix, const Mat& distCoeffs, const Mat& R=Mat(), const Mat& P=Mat())
Computes the ideal point coordinates from the observed point coordinates. Computes the ideal point coordinates from the observed point coordinates.
@ -1270,6 +1272,7 @@ cv::undistortPoints
:param dst: The output ideal point coordinates, after undistortion and reverse perspective transformation . :param dst: The output ideal point coordinates, after undistortion and reverse perspective transformation .
:param cameraMatrix: The camera matrix :math:`\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}` :param cameraMatrix: The camera matrix :math:`\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
:param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed. :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param R: The rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :func:`StereoRectify` can be passed here. If the matrix is empty, the identity transformation is used :param R: The rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :func:`StereoRectify` can be passed here. If the matrix is empty, the identity transformation is used
@ -1291,7 +1294,6 @@ The function is similar to
x = X/W, y = Y/W x = X/W, y = Y/W
u' = x*fx' + cx' u' = x*fx' + cx'
v' = y*fy' + cy', v' = y*fy' + cy',
..
where undistort() is approximate iterative algorithm that estimates the normalized original point coordinates out of the normalized distorted point coordinates ("normalized" means that the coordinates do not depend on the camera matrix). where undistort() is approximate iterative algorithm that estimates the normalized original point coordinates out of the normalized distorted point coordinates ("normalized" means that the coordinates do not depend on the camera matrix).

391
modules/core/doc/basic_structures.rst
View File

File diff suppressed because it is too large Load Diff

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

@ -5,9 +5,9 @@ Clustering
.. index:: kmeans .. index:: kmeans
cv::kmeans kmeans
---------- ----------
.. cfunction:: 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 the centers of clusters and groups the input samples around the clusters. Finds the centers of clusters and groups the input samples around the clusters.
@ -53,11 +53,11 @@ attempts to 1, initialize labels each time using some custom algorithm and pass
.. index:: partition .. index:: partition
cv::partition partition
------------- -------------
.. cfunction:: template<typename _Tp, class _EqPredicate> int .. c:function:: template<typename _Tp, class _EqPredicate> int
.. cfunction:: 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. Splits an element set into equivalency classes.

53
modules/core/doc/drawing_functions.rst
View File

@ -31,9 +31,9 @@ Also, note that the functions do not support alpha-transparency - when the targe
.. index:: circle .. index:: circle
cv::circle circle
---------- ----------
.. cfunction:: void circle(Mat\& img, Point center, int radius, const Scalar\& color, int thickness=1, int lineType=8, int shift=0) .. c:function:: void circle(Mat& img, Point center, int radius, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
Draws a circle Draws a circle
@ -56,11 +56,11 @@ given center and radius.
.. index:: clipLine .. index:: clipLine
cv::clipLine clipLine
------------ ------------
.. cfunction:: bool clipLine(Size imgSize, Point\& pt1, Point\& pt2) .. c:function:: bool clipLine(Size imgSize, Point& pt1, Point& pt2)
.. cfunction:: bool clipLine(Rect imgRect, Point\& pt1, Point\& pt2) .. c:function:: bool clipLine(Rect imgRect, Point& pt1, Point& pt2)
Clips the line against the image rectangle Clips the line against the image rectangle
@ -76,11 +76,11 @@ They return ``false`` if the line segment is completely outside the rectangle an
.. index:: ellipse .. index:: ellipse
cv::ellipse ellipse
----------- -----------
.. cfunction:: 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) .. c: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)
.. cfunction:: void ellipse(Mat\& img, const RotatedRect\& box, const Scalar\& color, int thickness=1, int lineType=8) .. c: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 an fills ellipse sector. Draws a simple or thick elliptic arc or an fills ellipse sector.
@ -120,9 +120,9 @@ Parameters of Elliptic Arc
.. index:: ellipse2Poly .. index:: ellipse2Poly
cv::ellipse2Poly ellipse2Poly
---------------- ----------------
.. cfunction:: void ellipse2Poly( Point center, Size axes, int angle, int startAngle, int endAngle, int delta, vector<Point>\& pts ) .. c: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 Approximates an elliptic arc with a polyline
@ -141,9 +141,9 @@ The function ``ellipse2Poly`` computes the vertices of a polyline that approxima
.. index:: fillConvexPoly .. index:: fillConvexPoly
cv::fillConvexPoly fillConvexPoly
------------------ ------------------
.. cfunction:: void fillConvexPoly(Mat\& img, const Point* pts, int npts, const Scalar\& color, int lineType=8, int shift=0) .. c:function:: void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0)
Fills a convex polygon. Fills a convex polygon.
@ -166,9 +166,9 @@ line) twice at the most (though, its top-most and/or the bottom edge could be ho
.. index:: fillPoly .. index:: fillPoly
cv::fillPoly fillPoly
------------ ------------
.. cfunction:: void fillPoly(Mat\& img, const Point** pts, const int* npts, int ncontours, const Scalar\& color, int lineType=8, int shift=0, Point offset=Point() ) .. c: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 Fills the area bounded by one or more polygons
@ -192,9 +192,9 @@ areas with holes, contours with self-intersections (some of thier parts), and so
.. index:: getTextSize .. index:: getTextSize
cv::getTextSize getTextSize
--------------- ---------------
.. cfunction:: Size getTextSize(const string\& text, int fontFace, double fontScale, int thickness, int* baseLine) .. c:function:: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine)
Calculates the width and height of a text string. Calculates the width and height of a text string.
@ -234,13 +234,12 @@ That is, the following code will render some text, the tight box surrounding it
// then put the text itself // then put the text itself
putText(img, text, textOrg, fontFace, fontScale, putText(img, text, textOrg, fontFace, fontScale,
Scalar::all(255), thickness, 8); Scalar::all(255), thickness, 8);
..
.. index:: line .. index:: line
cv::line line
-------- --------
.. cfunction:: void line(Mat\& img, Point pt1, Point pt2, const Scalar\& color, int thickness=1, int lineType=8, int shift=0) .. c: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 Draws a line segment connecting two points
@ -277,7 +276,7 @@ the line color, the user may use the macro ``CV_RGB(r, g, b)`` .
LineIterator LineIterator
------------ ------------
.. ctype:: LineIterator .. c:type:: LineIterator
Class for iterating pixels on a raster line :: Class for iterating pixels on a raster line ::
@ -304,7 +303,6 @@ Class for iterating pixels on a raster line ::
int minusDelta, plusDelta; int minusDelta, plusDelta;
int minusStep, plusStep; int minusStep, plusStep;
}; };
..
The class ``LineIterator`` is used to get each pixel of a raster line. It can be treated as versatile implementation of the Bresenham algorithm, where you can stop at each pixel and do some extra processing, for example, grab pixel values along the line, or draw a line with some effect (e.g. with XOR operation). The class ``LineIterator`` is used to get each pixel of a raster line. It can be treated as versatile implementation of the Bresenham algorithm, where you can stop at each pixel and do some extra processing, for example, grab pixel values along the line, or draw a line with some effect (e.g. with XOR operation).
@ -317,13 +315,12 @@ The number of pixels along the line is store in ``LineIterator::count`` . ::
for(int i = 0; i < it.count; i++, ++it) for(int i = 0; i < it.count; i++, ++it)
buf[i] = *(const Vec3b)*it; buf[i] = *(const Vec3b)*it;
..
.. index:: rectangle .. index:: rectangle
cv::rectangle rectangle
------------- -------------
.. cfunction:: void rectangle(Mat\& img, Point pt1, Point pt2, const Scalar\& color, int thickness=1, int lineType=8, int shift=0) .. c:function:: void rectangle(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0)
Draws a simple, thick, or filled up-right rectangle. Draws a simple, thick, or filled up-right rectangle.
@ -345,9 +342,9 @@ The function ``rectangle`` draws a rectangle outline or a filled rectangle, whic
.. index:: polylines .. index:: polylines
cv::polylines polylines
------------- -------------
.. cfunction:: 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 ) .. c: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 Draws several polygonal curves
@ -373,9 +370,9 @@ The function ``polylines`` draws one or more polygonal curves.
.. index:: putText .. index:: putText
cv::putText putText
----------- -----------
.. cfunction:: void putText( Mat\& img, const string\& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false ) .. c: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 Draws a text string

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

File diff suppressed because it is too large Load Diff

60
modules/core/doc/utility_and_system_functions_and_macros.rst
View File

@ -5,9 +5,9 @@ Utility and System Functions and Macros
.. index:: alignPtr .. index:: alignPtr
cv::alignPtr alignPtr
------------ ------------
.. cfunction:: template<typename _Tp> _Tp* alignPtr(_Tp* ptr, int n=sizeof(_Tp)) .. c:function:: template<typename _Tp> _Tp* alignPtr(_Tp* ptr, int n=sizeof(_Tp))
Aligns pointer to the specified number of bytes Aligns pointer to the specified number of bytes
@ -23,9 +23,9 @@ The function returns the aligned pointer of the same type as the input pointer:
.. index:: alignSize .. index:: alignSize
cv::alignSize alignSize
------------- -------------
.. cfunction:: size_t alignSize(size_t sz, int n) .. c:function:: size_t alignSize(size_t sz, int n)
Aligns a buffer size to the specified number of bytes Aligns a buffer size to the specified number of bytes
@ -41,9 +41,9 @@ The function returns the minimum number that is greater or equal to ``sz`` and i
.. index:: allocate .. index:: allocate
cv::allocate allocate
------------ ------------
.. cfunction:: template<typename _Tp> _Tp* allocate(size_t n) .. c:function:: template<typename _Tp> _Tp* allocate(size_t n)
Allocates an array of elements Allocates an array of elements
@ -53,9 +53,9 @@ The generic function ``allocate`` allocates buffer for the specified number of e
.. index:: deallocate .. index:: deallocate
cv::deallocate deallocate
-------------- --------------
.. cfunction:: template<typename _Tp> void deallocate(_Tp* ptr, size_t n) .. c:function:: template<typename _Tp> void deallocate(_Tp* ptr, size_t n)
Allocates an array of elements Allocates an array of elements
@ -73,7 +73,7 @@ The generic function ``deallocate`` deallocates the buffer allocated with
CV_Assert CV_Assert
--------- ---------
.. cfunction:: CV_Assert(expr) .. c:function:: CV_Assert(expr)
Checks a condition at runtime. :: Checks a condition at runtime. ::
@ -88,13 +88,13 @@ The macros ``CV_Assert`` and ``CV_DbgAssert`` evaluate the specified expression
.. index:: error .. index:: error
cv::error error
--------- ---------
.. cfunction:: void error( const Exception\& exc ) .. c:function:: void error( const Exception\& exc )
.. cfunction:: \#define CV_Error( code, msg ) <...> .. c:function:: \#define CV_Error( code, msg ) <...>
.. cfunction:: \#define CV_Error_( code, args ) <...> .. c:function:: \#define CV_Error_( code, args ) <...>
Signals an error and raises the exception Signals an error and raises the exception
@ -120,7 +120,7 @@ The macro ``CV_Error_`` can be used to construct the error message on-fly to inc
Exception Exception
--------- ---------
.. ctype:: Exception .. c:type:: Exception
The exception class passed to error :: The exception class passed to error ::
@ -152,9 +152,9 @@ The class ``Exception`` encapsulates all or almost all the necessary information
.. index:: fastMalloc .. index:: fastMalloc
cv::fastMalloc fastMalloc
-------------- --------------
.. cfunction:: void* fastMalloc(size_t size) .. c:function:: void* fastMalloc(size_t size)
Allocates aligned memory buffer Allocates aligned memory buffer
@ -164,9 +164,9 @@ The function allocates buffer of the specified size and returns it. When the buf
.. index:: fastFree .. index:: fastFree
cv::fastFree fastFree
------------ ------------
.. cfunction:: void fastFree(void* ptr) .. c:function:: void fastFree(void* ptr)
Deallocates memory buffer Deallocates memory buffer
@ -178,9 +178,9 @@ If NULL pointer is passed, the function does nothing.
.. index:: format .. index:: format
cv::format format
---------- ----------
.. cfunction:: string format( const char* fmt, ... ) .. c:function:: string format( const char* fmt, ... )
Returns a text string formatted using printf-like expression Returns a text string formatted using printf-like expression
@ -191,9 +191,9 @@ The function acts like ``sprintf`` , but forms and returns STL string. It can be
.. index:: getNumThreads .. index:: getNumThreads
cv::getNumThreads getNumThreads
----------------- -----------------
.. cfunction:: int getNumThreads() .. c:function:: int getNumThreads()
Returns the number of threads used by OpenCV Returns the number of threads used by OpenCV
@ -204,9 +204,9 @@ See also:
.. index:: getThreadNum .. index:: getThreadNum
cv::getThreadNum getThreadNum
---------------- ----------------
.. cfunction:: int getThreadNum() .. c:function:: int getThreadNum()
Returns index of the currently executed thread Returns index of the currently executed thread
@ -217,9 +217,9 @@ See also:
.. index:: getTickCount .. index:: getTickCount
cv::getTickCount getTickCount
---------------- ----------------
.. cfunction:: int64 getTickCount() .. c:function:: int64 getTickCount()
Returns the number of ticks Returns the number of ticks
@ -229,9 +229,9 @@ It can be used to initialize
.. index:: getTickFrequency .. index:: getTickFrequency
cv::getTickFrequency getTickFrequency
-------------------- --------------------
.. cfunction:: double getTickFrequency() .. c:function:: double getTickFrequency()
Returns the number of ticks per second Returns the number of ticks per second
@ -245,9 +245,9 @@ That is, the following code computes the execution time in seconds. ::
.. index:: setNumThreads .. index:: setNumThreads
cv::setNumThreads setNumThreads
----------------- -----------------
.. cfunction:: void setNumThreads(int nthreads) .. c:function:: void setNumThreads(int nthreads)
Sets the number of threads used by OpenCV Sets the number of threads used by OpenCV

6
modules/core/doc/xml_yaml_persistence.rst
View File

@ -9,7 +9,7 @@ XML/YAML Persistence
FileStorage FileStorage
----------- -----------
.. ctype:: FileStorage .. c:type:: FileStorage
The XML/YAML file storage class :: The XML/YAML file storage class ::
@ -73,7 +73,7 @@ The XML/YAML file storage class ::
FileNode FileNode
-------- --------
.. ctype:: FileNode .. c:type:: FileNode
The XML/YAML file node class :: The XML/YAML file node class ::
@ -124,7 +124,7 @@ The XML/YAML file node class ::
FileNodeIterator FileNodeIterator
---------------- ----------------
.. ctype:: FileNodeIterator .. c:type:: FileNodeIterator
The XML/YAML file node iterator class :: The XML/YAML file node iterator class ::

30
modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst
View File

@ -15,7 +15,7 @@ descriptor extractors inherit
DescriptorExtractor DescriptorExtractor
------------------- -------------------
.. ctype:: DescriptorExtractor .. c:type:: DescriptorExtractor
Abstract base class for computing descriptors for image keypoints. :: Abstract base class for computing descriptors for image keypoints. ::
@ -51,9 +51,9 @@ descriptors as a
.. index:: DescriptorExtractor::compute .. index:: DescriptorExtractor::compute
cv::DescriptorExtractor::compute DescriptorExtractor::compute
-------------------------------- --------------------------------
.. cfunction:: void DescriptorExtractor::compute( const Mat\& image, vector<KeyPoint>\& keypoints, Mat\& descriptors ) const .. c:function:: void DescriptorExtractor::compute( const Mat\& image, vector<KeyPoint>\& keypoints, Mat\& descriptors ) const
Compute the descriptors for a set of keypoints detected in an image (first variant) Compute the descriptors for a set of keypoints detected in an image (first variant)
or image set (second variant). or image set (second variant).
@ -64,7 +64,7 @@ or image set (second variant).
:param descriptors: The descriptors. Row i is the descriptor for keypoint i. :param descriptors: The descriptors. Row i is the descriptor for keypoint i.
.. cfunction:: void DescriptorExtractor::compute( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints, vector<Mat>\& descriptors ) const .. c:function:: void DescriptorExtractor::compute( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints, vector<Mat>\& descriptors ) const
* **images** The image set. * **images** The image set.
@ -77,9 +77,9 @@ or image set (second variant).
.. index:: DescriptorExtractor::read .. index:: DescriptorExtractor::read
cv::DescriptorExtractor::read DescriptorExtractor::read
----------------------------- -----------------------------
.. cfunction:: void DescriptorExtractor::read( const FileNode\& fn ) .. c:function:: void DescriptorExtractor::read( const FileNode\& fn )
Read descriptor extractor object from file node. Read descriptor extractor object from file node.
@ -87,9 +87,9 @@ cv::DescriptorExtractor::read
.. index:: DescriptorExtractor::write .. index:: DescriptorExtractor::write
cv::DescriptorExtractor::write DescriptorExtractor::write
------------------------------ ------------------------------
.. cfunction:: void DescriptorExtractor::write( FileStorage\& fs ) const .. c:function:: void DescriptorExtractor::write( FileStorage\& fs ) const
Write descriptor extractor object to file storage. Write descriptor extractor object to file storage.
@ -97,10 +97,10 @@ cv::DescriptorExtractor::write
.. index:: DescriptorExtractor::create .. index:: DescriptorExtractor::create
cv::DescriptorExtractor::create DescriptorExtractor::create
------------------------------- -------------------------------
:func:`DescriptorExtractor` :func:`DescriptorExtractor`
.. cfunction:: Ptr<DescriptorExtractor> DescriptorExtractor::create( const string\& descriptorExtractorType ) .. c:function:: Ptr<DescriptorExtractor> DescriptorExtractor::create( const string\& descriptorExtractorType )
Descriptor extractor factory that creates of given type with Descriptor extractor factory that creates of given type with
default parameters (rather using default constructor). default parameters (rather using default constructor).
@ -123,7 +123,7 @@ e.g. ``"OpponentSIFT"`` , etc.
SiftDescriptorExtractor SiftDescriptorExtractor
----------------------- -----------------------
.. ctype:: SiftDescriptorExtractor .. c:type:: SiftDescriptorExtractor
Wrapping class for descriptors computing using Wrapping class for descriptors computing using
:func:`SIFT` class. :: :func:`SIFT` class. ::
@ -155,7 +155,7 @@ Wrapping class for descriptors computing using
SurfDescriptorExtractor SurfDescriptorExtractor
----------------------- -----------------------
.. ctype:: SurfDescriptorExtractor .. c:type:: SurfDescriptorExtractor
Wrapping class for descriptors computing using Wrapping class for descriptors computing using
:func:`SURF` class. :: :func:`SURF` class. ::
@ -181,7 +181,7 @@ Wrapping class for descriptors computing using
CalonderDescriptorExtractor CalonderDescriptorExtractor
--------------------------- ---------------------------
.. ctype:: CalonderDescriptorExtractor .. c:type:: CalonderDescriptorExtractor
Wrapping class for descriptors computing using Wrapping class for descriptors computing using
:func:`RTreeClassifier` class. :: :func:`RTreeClassifier` class. ::
@ -207,7 +207,7 @@ Wrapping class for descriptors computing using
OpponentColorDescriptorExtractor OpponentColorDescriptorExtractor
-------------------------------- --------------------------------
.. ctype:: OpponentColorDescriptorExtractor .. c:type:: OpponentColorDescriptorExtractor
Adapts a descriptor extractor to compute descripors in Opponent Color Space Adapts a descriptor extractor to compute descripors in Opponent Color Space
(refer to van de Sande et al., CGIV 2008 "Color Descriptors for Object Category Recognition"). (refer to van de Sande et al., CGIV 2008 "Color Descriptors for Object Category Recognition").
@ -235,7 +235,7 @@ them into a single color descriptor. ::
BriefDescriptorExtractor BriefDescriptorExtractor
------------------------ ------------------------
.. ctype:: BriefDescriptorExtractor .. c:type:: BriefDescriptorExtractor
Class for computing BRIEF descriptors described in paper of Calonder M., Lepetit V., Class for computing BRIEF descriptors described in paper of Calonder M., Lepetit V.,
Strecha C., Fua P.: ''BRIEF: Binary Robust Independent Elementary Features.'' Strecha C., Fua P.: ''BRIEF: Binary Robust Independent Elementary Features.''

58
modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst
View File

@ -15,7 +15,7 @@ descriptor matchers inherit
DMatch DMatch
------ ------
.. ctype:: DMatch .. c:type:: DMatch
Match between two keypoint descriptors: query descriptor index, Match between two keypoint descriptors: query descriptor index,
train descriptor index, train image index and distance between descriptors. :: train descriptor index, train image index and distance between descriptors. ::
@ -48,7 +48,7 @@ train descriptor index, train image index and distance between descriptors. ::
DescriptorMatcher DescriptorMatcher
----------------- -----------------
.. ctype:: DescriptorMatcher .. c:type:: DescriptorMatcher
Abstract base class for matching keypoint descriptors. It has two groups Abstract base class for matching keypoint descriptors. It has two groups
of match methods: for matching descriptors of one image with other image or of match methods: for matching descriptors of one image with other image or
@ -106,9 +106,9 @@ with image set. ::
.. index:: DescriptorMatcher::add .. index:: DescriptorMatcher::add
cv::DescriptorMatcher::add DescriptorMatcher::add
-------------------------- ```` -------------------------- ````
.. cfunction:: void add( const vector<Mat>\& descriptors ) .. c:function:: void add( const vector<Mat>\& descriptors )
Add descriptors to train descriptor collection. If collection trainDescCollectionis not empty Add descriptors to train descriptor collection. If collection trainDescCollectionis not empty
the new descriptors are added to existing train descriptors. the new descriptors are added to existing train descriptors.
@ -118,41 +118,41 @@ the new descriptors are added to existing train descriptors.
.. index:: DescriptorMatcher::getTrainDescriptors .. index:: DescriptorMatcher::getTrainDescriptors
cv::DescriptorMatcher::getTrainDescriptors DescriptorMatcher::getTrainDescriptors
------------------------------------------ ```` ------------------------------------------ ````
.. cfunction:: const vector<Mat>\& getTrainDescriptors() const .. c:function:: const vector<Mat>\& getTrainDescriptors() const
Returns constant link to the train descriptor collection (i.e. trainDescCollection). Returns constant link to the train descriptor collection (i.e. trainDescCollection).
.. index:: DescriptorMatcher::clear .. index:: DescriptorMatcher::clear
cv::DescriptorMatcher::clear DescriptorMatcher::clear
---------------------------- ----------------------------
.. cfunction:: void DescriptorMatcher::clear() .. c:function:: void DescriptorMatcher::clear()
Clear train descriptor collection. Clear train descriptor collection.
.. index:: DescriptorMatcher::empty .. index:: DescriptorMatcher::empty
cv::DescriptorMatcher::empty DescriptorMatcher::empty
---------------------------- ----------------------------
.. cfunction:: bool DescriptorMatcher::empty() const .. c:function:: bool DescriptorMatcher::empty() const
Return true if there are not train descriptors in collection. Return true if there are not train descriptors in collection.
.. index:: DescriptorMatcher::isMaskSupported .. index:: DescriptorMatcher::isMaskSupported
cv::DescriptorMatcher::isMaskSupported DescriptorMatcher::isMaskSupported
-------------------------------------- --------------------------------------
.. cfunction:: bool DescriptorMatcher::isMaskSupported() .. c:function:: bool DescriptorMatcher::isMaskSupported()
Returns true if descriptor matcher supports masking permissible matches. Returns true if descriptor matcher supports masking permissible matches.
.. index:: DescriptorMatcher::train .. index:: DescriptorMatcher::train
cv::DescriptorMatcher::train DescriptorMatcher::train
---------------------------- ----------------------------
.. cfunction:: void DescriptorMatcher::train() .. c:function:: void DescriptorMatcher::train()
Train descriptor matcher (e.g. train flann index). In all methods to match the method train() Train descriptor matcher (e.g. train flann index). In all methods to match the method train()
is run every time before matching. Some descriptor matchers (e.g. BruteForceMatcher) have empty is run every time before matching. Some descriptor matchers (e.g. BruteForceMatcher) have empty
@ -161,9 +161,9 @@ trains flann::Index)
.. index:: DescriptorMatcher::match .. index:: DescriptorMatcher::match
cv::DescriptorMatcher::match DescriptorMatcher::match
---------------------------- ```` ```` ```` ```` ---------------------------- ```` ```` ```` ````
.. cfunction:: void DescriptorMatcher::match( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<DMatch>\& matches, const Mat\& mask=Mat() ) const .. c:function:: void DescriptorMatcher::match( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<DMatch>\& matches, const Mat\& mask=Mat() ) const
Find the best match for each descriptor from a query set with train descriptors. Find the best match for each descriptor from a query set with train descriptors.
Supposed that the query descriptors are of keypoints detected on the same query image. Supposed that the query descriptors are of keypoints detected on the same query image.
@ -172,7 +172,7 @@ supposed that they are of keypoints detected on the same train image. In second
of the method train descriptors collection that was set using addmethod is used. of the method train descriptors collection that was set using addmethod is used.
Optional mask (or masks) can be set to describe which descriptors can be matched. queryDescriptors[i]can be matched with trainDescriptors[j]only if mask.at<uchar>(i,j)is non-zero. Optional mask (or masks) can be set to describe which descriptors can be matched. queryDescriptors[i]can be matched with trainDescriptors[j]only if mask.at<uchar>(i,j)is non-zero.
.. cfunction:: void DescriptorMatcher::match( const Mat\& queryDescriptors, vector<DMatch>\& matches, const vector<Mat>\& masks=vector<Mat>() ) .. c:function:: void DescriptorMatcher::match( const Mat\& queryDescriptors, vector<DMatch>\& matches, const vector<Mat>\& masks=vector<Mat>() )
:param queryDescriptors: Query set of descriptors. :param queryDescriptors: Query set of descriptors.
@ -189,16 +189,16 @@ Optional mask (or masks) can be set to describe which descriptors can be matched
.. index:: DescriptorMatcher::knnMatch .. index:: DescriptorMatcher::knnMatch
cv::DescriptorMatcher::knnMatch DescriptorMatcher::knnMatch
------------------------------- -------------------------------
:func:`DescriptorMatcher::match` :func:`DescriptorMatcher::match`
.. cfunction:: void DescriptorMatcher::knnMatch( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<vector<DMatch> >\& matches, int k, const Mat\& mask=Mat(), bool compactResult=false ) const .. c:function:: void DescriptorMatcher::knnMatch( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<vector<DMatch> >\& matches, int k, const Mat\& mask=Mat(), bool compactResult=false ) const
Find the k best matches for each descriptor from a query set with train descriptors. Find the k best matches for each descriptor from a query set with train descriptors.
Found k (or less if not possible) matches are returned in distance increasing order. Found k (or less if not possible) matches are returned in distance increasing order.
Details about query and train descriptors see in . Details about query and train descriptors see in .
.. cfunction:: void DescriptorMatcher::knnMatch( const Mat\& queryDescriptors, vector<vector<DMatch> >\& matches, int k, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false ) .. c:function:: void DescriptorMatcher::knnMatch( const Mat\& queryDescriptors, vector<vector<DMatch> >\& matches, int k, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false )
:param queryDescriptors, trainDescriptors, mask, masks: See in :func:`DescriptorMatcher::match` . :param queryDescriptors, trainDescriptors, mask, masks: See in :func:`DescriptorMatcher::match` .
@ -210,16 +210,16 @@ Details about query and train descriptors see in .
.. index:: DescriptorMatcher::radiusMatch .. index:: DescriptorMatcher::radiusMatch
cv::DescriptorMatcher::radiusMatch DescriptorMatcher::radiusMatch
---------------------------------- ----------------------------------
:func:`DescriptorMatcher::match` :func:`DescriptorMatcher::match`
.. cfunction:: void DescriptorMatcher::radiusMatch( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<vector<DMatch> >\& matches, float maxDistance, const Mat\& mask=Mat(), bool compactResult=false ) const .. c:function:: void DescriptorMatcher::radiusMatch( const Mat\& queryDescriptors, const Mat\& trainDescriptors, vector<vector<DMatch> >\& matches, float maxDistance, const Mat\& mask=Mat(), bool compactResult=false ) const
Find the best matches for each query descriptor which have distance less than given threshold. Find the best matches for each query descriptor which have distance less than given threshold.
Found matches are returned in distance increasing order. Details about query and train Found matches are returned in distance increasing order. Details about query and train
descriptors see in . descriptors see in .
.. cfunction:: void DescriptorMatcher::radiusMatch( const Mat\& queryDescriptors, vector<vector<DMatch> >\& matches, float maxDistance, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false ) .. c:function:: void DescriptorMatcher::radiusMatch( const Mat\& queryDescriptors, vector<vector<DMatch> >\& matches, float maxDistance, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false )
:param queryDescriptors, trainDescriptors, mask, masks: See in :func:`DescriptorMatcher::match` . :param queryDescriptors, trainDescriptors, mask, masks: See in :func:`DescriptorMatcher::match` .
@ -229,9 +229,9 @@ descriptors see in .
.. index:: DescriptorMatcher::clone .. index:: DescriptorMatcher::clone
cv::DescriptorMatcher::clone DescriptorMatcher::clone
---------------------------- ----------------------------
.. cfunction:: Ptr<DescriptorMatcher> \\DescriptorMatcher::clone( bool emptyTrainData ) const .. c:function:: Ptr<DescriptorMatcher> \\DescriptorMatcher::clone( bool emptyTrainData ) const
Clone the matcher. Clone the matcher.
@ -241,10 +241,10 @@ cv::DescriptorMatcher::clone
.. index:: DescriptorMatcher::create .. index:: DescriptorMatcher::create
cv::DescriptorMatcher::create DescriptorMatcher::create
----------------------------- -----------------------------
:func:`DescriptorMatcher` :func:`DescriptorMatcher`
.. cfunction:: Ptr<DescriptorMatcher> DescriptorMatcher::create( const string\& descriptorMatcherType ) .. c:function:: Ptr<DescriptorMatcher> DescriptorMatcher::create( const string\& descriptorMatcherType )
Descriptor matcher factory that creates of Descriptor matcher factory that creates of
given type with default parameters (rather using default constructor). given type with default parameters (rather using default constructor).
@ -259,7 +259,7 @@ Now the following matcher types are supported: ``"BruteForce"`` (it uses ``L2``
BruteForceMatcher BruteForceMatcher
----------------- -----------------
.. ctype:: BruteForceMatcher .. c:type:: BruteForceMatcher
Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest 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 descriptor in the second set by trying each one. This descriptor matcher supports masking
@ -348,7 +348,7 @@ For float descriptors, a common choice would be ``L2<float>`` . Class of support
FlannBasedMatcher FlannBasedMatcher
----------------- -----------------
.. ctype:: FlannBasedMatcher .. c:type:: FlannBasedMatcher
Flann based descriptor matcher. This matcher trains Flann based descriptor matcher. This matcher trains
:func:`flann::Index` on :func:`flann::Index` on

64
modules/features2d/doc/common_interfaces_of_feature_detectors.rst
View File

@ -14,7 +14,7 @@ inherit
KeyPoint KeyPoint
-------- --------
.. ctype:: KeyPoint .. c:type:: KeyPoint
Data structure for salient point detectors. :: Data structure for salient point detectors. ::
@ -73,7 +73,7 @@ Data structure for salient point detectors. ::
FeatureDetector FeatureDetector
--------------- ---------------
.. ctype:: FeatureDetector .. c:type:: FeatureDetector
Abstract base class for 2D image feature detectors. :: Abstract base class for 2D image feature detectors. ::
@ -101,9 +101,9 @@ Abstract base class for 2D image feature detectors. ::
.. index:: FeatureDetector::detect .. index:: FeatureDetector::detect
cv::FeatureDetector::detect FeatureDetector::detect
--------------------------- ---------------------------
.. cfunction:: void FeatureDetector::detect( const Mat\& image, vector<KeyPoint>\& keypoints, const Mat\& mask=Mat() ) const .. c:function:: void FeatureDetector::detect( const Mat\& image, vector<KeyPoint>\& keypoints, const Mat\& mask=Mat() ) const
Detect keypoints in an image (first variant) or image set (second variant). Detect keypoints in an image (first variant) or image set (second variant).
@ -114,7 +114,7 @@ cv::FeatureDetector::detect
:param mask: Mask specifying where to look for keypoints (optional). Must be a char matrix :param mask: Mask specifying where to look for keypoints (optional). Must be a char matrix
with non-zero values in the region of interest. with non-zero values in the region of interest.
.. cfunction:: void FeatureDetector::detect( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints, const vector<Mat>\& masks=vector<Mat>() ) const .. c:function:: void FeatureDetector::detect( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints, const vector<Mat>\& masks=vector<Mat>() ) const
* **images** Images set. * **images** Images set.
@ -125,9 +125,9 @@ cv::FeatureDetector::detect
.. index:: FeatureDetector::read .. index:: FeatureDetector::read
cv::FeatureDetector::read FeatureDetector::read
------------------------- -------------------------
.. cfunction:: void FeatureDetector::read( const FileNode\& fn ) .. c:function:: void FeatureDetector::read( const FileNode\& fn )
Read feature detector object from file node. Read feature detector object from file node.
@ -135,9 +135,9 @@ cv::FeatureDetector::read
.. index:: FeatureDetector::write .. index:: FeatureDetector::write
cv::FeatureDetector::write FeatureDetector::write
-------------------------- --------------------------
.. cfunction:: void FeatureDetector::write( FileStorage\& fs ) const .. c:function:: void FeatureDetector::write( FileStorage\& fs ) const
Write feature detector object to file storage. Write feature detector object to file storage.
@ -145,10 +145,10 @@ cv::FeatureDetector::write
.. index:: FeatureDetector::create .. index:: FeatureDetector::create
cv::FeatureDetector::create FeatureDetector::create
--------------------------- ---------------------------
:func:`FeatureDetector` :func:`FeatureDetector`
.. cfunction:: Ptr<FeatureDetector> FeatureDetector::create( const string\& detectorType ) .. c:function:: Ptr<FeatureDetector> FeatureDetector::create( const string\& detectorType )
Feature detector factory that creates of given type with Feature detector factory that creates of given type with
default parameters (rather using default constructor). default parameters (rather using default constructor).
@ -176,7 +176,7 @@ e.g. ``"GridFAST"``,``"PyramidSTAR"`` , etc.
FastFeatureDetector FastFeatureDetector
------------------- -------------------
.. ctype:: FastFeatureDetector .. c:type:: FastFeatureDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`FAST` method. :: :func:`FAST` method. ::
@ -198,7 +198,7 @@ Wrapping class for feature detection using
GoodFeaturesToTrackDetector GoodFeaturesToTrackDetector
--------------------------- ---------------------------
.. ctype:: GoodFeaturesToTrackDetector .. c:type:: GoodFeaturesToTrackDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`goodFeaturesToTrack` function. :: :func:`goodFeaturesToTrack` function. ::
@ -241,7 +241,7 @@ Wrapping class for feature detection using
MserFeatureDetector MserFeatureDetector
------------------- -------------------
.. ctype:: MserFeatureDetector .. c:type:: MserFeatureDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`MSER` class. :: :func:`MSER` class. ::
@ -267,7 +267,7 @@ Wrapping class for feature detection using
StarFeatureDetector StarFeatureDetector
------------------- -------------------
.. ctype:: StarFeatureDetector .. c:type:: StarFeatureDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`StarDetector` class. :: :func:`StarDetector` class. ::
@ -291,7 +291,7 @@ Wrapping class for feature detection using
SiftFeatureDetector SiftFeatureDetector
------------------- -------------------
.. ctype:: SiftFeatureDetector .. c:type:: SiftFeatureDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`SIFT` class. :: :func:`SIFT` class. ::
@ -320,7 +320,7 @@ Wrapping class for feature detection using
SurfFeatureDetector SurfFeatureDetector
------------------- -------------------
.. ctype:: SurfFeatureDetector .. c:type:: SurfFeatureDetector
Wrapping class for feature detection using Wrapping class for feature detection using
:func:`SURF` class. :: :func:`SURF` class. ::
@ -343,7 +343,7 @@ Wrapping class for feature detection using
GridAdaptedFeatureDetector GridAdaptedFeatureDetector
-------------------------- --------------------------
.. ctype:: GridAdaptedFeatureDetector .. c:type:: GridAdaptedFeatureDetector
Adapts a detector to partition the source image into a grid and detect Adapts a detector to partition the source image into a grid and detect
points in each cell. :: points in each cell. ::
@ -374,7 +374,7 @@ points in each cell. ::
PyramidAdaptedFeatureDetector PyramidAdaptedFeatureDetector
----------------------------- -----------------------------
.. ctype:: PyramidAdaptedFeatureDetector .. c:type:: PyramidAdaptedFeatureDetector
Adapts a detector to detect points over multiple levels of a Gaussian Adapts a detector to detect points over multiple levels of a Gaussian
pyramid. Useful for detectors that are not inherently scaled. :: pyramid. Useful for detectors that are not inherently scaled. ::
@ -397,7 +397,7 @@ pyramid. Useful for detectors that are not inherently scaled. ::
DynamicAdaptedFeatureDetector DynamicAdaptedFeatureDetector
----------------------------- -----------------------------
.. ctype:: DynamicAdaptedFeatureDetector .. c:type:: DynamicAdaptedFeatureDetector
An adaptively adjusting detector that iteratively detects until the desired number An adaptively adjusting detector that iteratively detects until the desired number
of features are found. of features are found.
@ -442,9 +442,9 @@ Here is a sample of how to create a DynamicAdaptedFeatureDetector. ::
.. index:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector .. index:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector
cv::DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector
---------------------------------------------------------------- ----------------------------------------------------------------
.. cfunction:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>\& adjaster, int min_features, int max_features, int max_iters ) .. c:function:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr<AdjusterAdapter>\& adjaster, int min_features, int max_features, int max_iters )
DynamicAdaptedFeatureDetector constructor. DynamicAdaptedFeatureDetector constructor.
@ -464,7 +464,7 @@ cv::DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector
AdjusterAdapter AdjusterAdapter
--------------- ---------------
.. ctype:: AdjusterAdapter .. c:type:: AdjusterAdapter
A feature detector parameter adjuster interface, this is used by the A feature detector parameter adjuster interface, this is used by the
:func:`DynamicAdaptedFeatureDetector` and is a wrapper for :func:`DynamicAdaptedFeatureDetector` and is a wrapper for
@ -485,9 +485,9 @@ See
.. index:: AdjusterAdapter::tooFew .. index:: AdjusterAdapter::tooFew
cv::AdjusterAdapter::tooFew AdjusterAdapter::tooFew
--------------------------- ---------------------------
.. cfunction:: virtual void tooFew(int min, int n_detected) = 0 .. c:function:: virtual void tooFew(int min, int n_detected) = 0
Too few features were detected so, adjust the detector parameters accordingly - so that the next Too few features were detected so, adjust the detector parameters accordingly - so that the next
detection detects more features. detection detects more features.
@ -506,9 +506,9 @@ An example implementation of this is ::
.. index:: AdjusterAdapter::tooMany .. index:: AdjusterAdapter::tooMany
cv::AdjusterAdapter::tooMany AdjusterAdapter::tooMany
---------------------------- ----------------------------
.. cfunction:: virtual void tooMany(int max, int n_detected) = 0 .. c:function:: virtual void tooMany(int max, int n_detected) = 0
Too many features were detected so, adjust the detector parameters accordingly - so that the next Too many features were detected so, adjust the detector parameters accordingly - so that the next
detection detects less features. detection detects less features.
@ -527,9 +527,9 @@ An example implementation of this is ::
.. index:: AdjusterAdapter::good .. index:: AdjusterAdapter::good
cv::AdjusterAdapter::good AdjusterAdapter::good
------------------------- -------------------------
.. cfunction:: virtual bool good() const = 0 .. c:function:: virtual bool good() const = 0
Are params maxed out or still valid? Returns false if the parameters can't be adjusted any more. Are params maxed out or still valid? Returns false if the parameters can't be adjusted any more.
@ -547,7 +547,7 @@ An example implementation of this is ::
FastAdjuster FastAdjuster
------------ ------------
.. ctype:: FastAdjuster .. c:type:: FastAdjuster
An An
:func:`AdjusterAdapter` for the :func:`AdjusterAdapter` for the
@ -568,7 +568,7 @@ threshhold by 1 ::
StarAdjuster StarAdjuster
------------ ------------
.. ctype:: StarAdjuster .. c:type:: StarAdjuster
An An
:func:`AdjusterAdapter` for the :func:`AdjusterAdapter` for the
@ -588,7 +588,7 @@ StarFeatureDetector. ::
SurfAdjuster SurfAdjuster
------------ ------------
.. ctype:: SurfAdjuster .. c:type:: SurfAdjuster
An An
:func:`AdjusterAdapter` for the :func:`AdjusterAdapter` for the

68
modules/features2d/doc/common_interfaces_of_generic_descriptor_matchers.rst
View File

@ -18,7 +18,7 @@ There are descriptors such as One way descriptor and Ferns that have ``GenericDe
GenericDescriptorMatcher GenericDescriptorMatcher
------------------------ ------------------------
.. ctype:: GenericDescriptorMatcher .. c:type:: GenericDescriptorMatcher
Abstract interface for a keypoint descriptor extracting and matching. Abstract interface for a keypoint descriptor extracting and matching.
There is There is
@ -92,9 +92,9 @@ with image set. ::
.. index:: GenericDescriptorMatcher::add .. index:: GenericDescriptorMatcher::add
cv::GenericDescriptorMatcher::add GenericDescriptorMatcher::add
--------------------------------- ---------------------------------
.. cfunction:: void GenericDescriptorMatcher::add( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints ) .. c:function:: void GenericDescriptorMatcher::add( const vector<Mat>\& images, vector<vector<KeyPoint> >\& keypoints )
Adds images and keypoints from them to the train collection (descriptors are supposed to be calculated here). Adds images and keypoints from them to the train collection (descriptors are supposed to be calculated here).
If train collection is not empty new image and keypoints from them will be added to If train collection is not empty new image and keypoints from them will be added to
@ -107,56 +107,56 @@ existing data.
.. index:: GenericDescriptorMatcher::getTrainImages .. index:: GenericDescriptorMatcher::getTrainImages
cv::GenericDescriptorMatcher::getTrainImages GenericDescriptorMatcher::getTrainImages
-------------------------------------------- --------------------------------------------
.. cfunction:: const vector<Mat>\& GenericDescriptorMatcher::getTrainImages() const .. c:function:: const vector<Mat>\& GenericDescriptorMatcher::getTrainImages() const
Returns train image collection. Returns train image collection.
.. index:: GenericDescriptorMatcher::getTrainKeypoints .. index:: GenericDescriptorMatcher::getTrainKeypoints
cv::GenericDescriptorMatcher::getTrainKeypoints GenericDescriptorMatcher::getTrainKeypoints
----------------------------------------------- -----------------------------------------------
.. cfunction:: const vector<vector<KeyPoint> >\& GenericDescriptorMatcher::getTrainKeypoints() const .. c:function:: const vector<vector<KeyPoint> >\& GenericDescriptorMatcher::getTrainKeypoints() const
Returns train keypoints collection. Returns train keypoints collection.
.. index:: GenericDescriptorMatcher::clear .. index:: GenericDescriptorMatcher::clear
cv::GenericDescriptorMatcher::clear GenericDescriptorMatcher::clear
----------------------------------- -----------------------------------
.. cfunction:: void GenericDescriptorMatcher::clear() .. c:function:: void GenericDescriptorMatcher::clear()
Clear train collection (iamges and keypoints). Clear train collection (iamges and keypoints).
.. index:: GenericDescriptorMatcher::train .. index:: GenericDescriptorMatcher::train
cv::GenericDescriptorMatcher::train GenericDescriptorMatcher::train
----------------------------------- -----------------------------------
.. cfunction:: void GenericDescriptorMatcher::train() .. c:function:: void GenericDescriptorMatcher::train()
Train the object, e.g. tree-based structure to extract descriptors or Train the object, e.g. tree-based structure to extract descriptors or
to optimize descriptors matching. to optimize descriptors matching.
.. index:: GenericDescriptorMatcher::isMaskSupported .. index:: GenericDescriptorMatcher::isMaskSupported
cv::GenericDescriptorMatcher::isMaskSupported GenericDescriptorMatcher::isMaskSupported
--------------------------------------------- ---------------------------------------------
.. cfunction:: void GenericDescriptorMatcher::isMaskSupported() .. c:function:: void GenericDescriptorMatcher::isMaskSupported()
Returns true if generic descriptor matcher supports masking permissible matches. Returns true if generic descriptor matcher supports masking permissible matches.
.. index:: GenericDescriptorMatcher::classify .. index:: GenericDescriptorMatcher::classify
cv::GenericDescriptorMatcher::classify GenericDescriptorMatcher::classify
-------------------------------------- --------------------------------------
:func:`GenericDescriptorMatcher::add` :func:`GenericDescriptorMatcher::add`
.. cfunction:: void GenericDescriptorMatcher::classify( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints ) const .. c:function:: void GenericDescriptorMatcher::classify( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints ) const
Classifies query keypoints under keypoints of one train image qiven as input argument Classifies query keypoints under keypoints of one train image qiven as input argument
(first version of the method) or train image collection that set using (second version). (first version of the method) or train image collection that set using (second version).
.. cfunction:: void GenericDescriptorMatcher::classify( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints ) .. c:function:: void GenericDescriptorMatcher::classify( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints )
:param queryImage: The query image. :param queryImage: The query image.
@ -168,16 +168,16 @@ cv::GenericDescriptorMatcher::classify
.. index:: GenericDescriptorMatcher::match .. index:: GenericDescriptorMatcher::match
cv::GenericDescriptorMatcher::match GenericDescriptorMatcher::match
----------------------------------- -----------------------------------
:func:`GenericDescriptorMatcher::add` :func:`DescriptorMatcher::match` :func:`GenericDescriptorMatcher::add` :func:`DescriptorMatcher::match`
.. cfunction:: void GenericDescriptorMatcher::match( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<DMatch>\& matches, const Mat\& mask=Mat() ) const .. c:function:: void GenericDescriptorMatcher::match( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<DMatch>\& matches, const Mat\& mask=Mat() ) const
Find best match for query keypoints to the training set. In first version of method Find best match for query keypoints to the training set. In first version of method
one train image and keypoints detected on it - are input arguments. In second version one train image and keypoints detected on it - are input arguments. In second version
query keypoints are matched to training collectin that set using . As in the mask can be set. query keypoints are matched to training collectin that set using . As in the mask can be set.
.. cfunction:: void GenericDescriptorMatcher::match( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<DMatch>\& matches, const vector<Mat>\& masks=vector<Mat>() ) .. c:function:: void GenericDescriptorMatcher::match( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<DMatch>\& matches, const vector<Mat>\& masks=vector<Mat>() )
:param queryImage: Query image. :param queryImage: Query image.
@ -199,50 +199,50 @@ query keypoints are matched to training collectin that set using . As in the mas
.. index:: GenericDescriptorMatcher::knnMatch .. index:: GenericDescriptorMatcher::knnMatch
cv::GenericDescriptorMatcher::knnMatch GenericDescriptorMatcher::knnMatch
-------------------------------------- --------------------------------------
:func:`GenericDescriptorMatcher::match` :func:`DescriptorMatcher::knnMatch` :func:`GenericDescriptorMatcher::match` :func:`DescriptorMatcher::knnMatch`
.. cfunction:: void GenericDescriptorMatcher::knnMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<vector<DMatch> >\& matches, int k, const Mat\& mask=Mat(), bool compactResult=false ) const .. c:function:: void GenericDescriptorMatcher::knnMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<vector<DMatch> >\& matches, int k, const Mat\& mask=Mat(), bool compactResult=false ) const
Find the knn best matches for each keypoint from a query set with train keypoints. Find the knn best matches for each keypoint from a query set with train keypoints.
Found knn (or less if not possible) matches are returned in distance increasing order. Found knn (or less if not possible) matches are returned in distance increasing order.
Details see in and . Details see in and .
.. cfunction:: void GenericDescriptorMatcher::knnMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<vector<DMatch> >\& matches, int k, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false ) .. c:function:: void GenericDescriptorMatcher::knnMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<vector<DMatch> >\& matches, int k, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false )
.. index:: GenericDescriptorMatcher::radiusMatch .. index:: GenericDescriptorMatcher::radiusMatch
cv::GenericDescriptorMatcher::radiusMatch GenericDescriptorMatcher::radiusMatch
----------------------------------------- -----------------------------------------
:func:`GenericDescriptorMatcher::match` :func:`DescriptorMatcher::radiusMatch` :func:`GenericDescriptorMatcher::match` :func:`DescriptorMatcher::radiusMatch`
.. cfunction:: void GenericDescriptorMatcher::radiusMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<vector<DMatch> >\& matches, float maxDistance, const Mat\& mask=Mat(), bool compactResult=false ) const .. c:function:: void GenericDescriptorMatcher::radiusMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, const Mat\& trainImage, vector<KeyPoint>\& trainKeypoints, vector<vector<DMatch> >\& matches, float maxDistance, const Mat\& mask=Mat(), bool compactResult=false ) const
Find the best matches for each query keypoint which have distance less than given threshold. Find the best matches for each query keypoint which have distance less than given threshold.
Found matches are returned in distance increasing order. Details see in and . Found matches are returned in distance increasing order. Details see in and .
.. cfunction:: void GenericDescriptorMatcher::radiusMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<vector<DMatch> >\& matches, float maxDistance, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false ) .. c:function:: void GenericDescriptorMatcher::radiusMatch( const Mat\& queryImage, vector<KeyPoint>\& queryKeypoints, vector<vector<DMatch> >\& matches, float maxDistance, const vector<Mat>\& masks=vector<Mat>(), bool compactResult=false )
.. index:: GenericDescriptorMatcher::read .. index:: GenericDescriptorMatcher::read
cv::GenericDescriptorMatcher::read GenericDescriptorMatcher::read
---------------------------------- ----------------------------------
.. cfunction:: void GenericDescriptorMatcher::read( const FileNode\& fn ) .. c:function:: void GenericDescriptorMatcher::read( const FileNode\& fn )
Reads matcher object from a file node. Reads matcher object from a file node.
.. index:: GenericDescriptorMatcher::write .. index:: GenericDescriptorMatcher::write
cv::GenericDescriptorMatcher::write GenericDescriptorMatcher::write
----------------------------------- -----------------------------------
.. cfunction:: void GenericDescriptorMatcher::write( FileStorage\& fs ) const .. c:function:: void GenericDescriptorMatcher::write( FileStorage\& fs ) const
Writes match object to a file storage Writes match object to a file storage
.. index:: GenericDescriptorMatcher::clone .. index:: GenericDescriptorMatcher::clone
cv::GenericDescriptorMatcher::clone GenericDescriptorMatcher::clone
----------------------------------- -----------------------------------
.. cfunction:: Ptr<GenericDescriptorMatcher>\\GenericDescriptorMatcher::clone( bool emptyTrainData ) const .. c:function:: Ptr<GenericDescriptorMatcher>\\GenericDescriptorMatcher::clone( bool emptyTrainData ) const
Clone the matcher. Clone the matcher.
@ -256,7 +256,7 @@ cv::GenericDescriptorMatcher::clone
OneWayDescriptorMatcher OneWayDescriptorMatcher
----------------------- -----------------------
.. ctype:: OneWayDescriptorMatcher .. c:type:: OneWayDescriptorMatcher
Wrapping class for computing, matching and classification of descriptors using Wrapping class for computing, matching and classification of descriptors using
:func:`OneWayDescriptorBase` class. :: :func:`OneWayDescriptorBase` class. ::
@ -317,7 +317,7 @@ Wrapping class for computing, matching and classification of descriptors using
FernDescriptorMatcher FernDescriptorMatcher
--------------------- ---------------------
.. ctype:: FernDescriptorMatcher .. c:type:: FernDescriptorMatcher
Wrapping class for computing, matching and classification of descriptors using Wrapping class for computing, matching and classification of descriptors using
:func:`FernClassifier` class. :: :func:`FernClassifier` class. ::
@ -376,7 +376,7 @@ Wrapping class for computing, matching and classification of descriptors using
VectorDescriptorMatcher VectorDescriptorMatcher
----------------------- -----------------------
.. ctype:: VectorDescriptorMatcher .. c:type:: VectorDescriptorMatcher
Class used for matching descriptors that can be described as vectors in a finite-dimensional space. :: Class used for matching descriptors that can be described as vectors in a finite-dimensional space. ::

10
modules/features2d/doc/drawing_function_of_keypoints_and_matches.rst
View File

@ -5,14 +5,14 @@ Drawing Function of Keypoints and Matches
.. index:: drawMatches .. index:: drawMatches
cv::drawMatches drawMatches
--------------- ---------------
.. cfunction:: void drawMatches( const Mat\& img1, const vector<KeyPoint>\& keypoints1, const Mat\& img2, const vector<KeyPoint>\& keypoints2, const vector<DMatch>\& matches1to2, Mat\& outImg, const Scalar\& matchColor=Scalar::all(-1), const Scalar\& singlePointColor=Scalar::all(-1), const vector<char>\& matchesMask=vector<char>(), int flags=DrawMatchesFlags::DEFAULT ) .. c:function:: void drawMatches( const Mat\& img1, const vector<KeyPoint>\& keypoints1, const Mat\& img2, const vector<KeyPoint>\& keypoints2, const vector<DMatch>\& matches1to2, Mat\& outImg, const Scalar\& matchColor=Scalar::all(-1), const Scalar\& singlePointColor=Scalar::all(-1), const vector<char>\& matchesMask=vector<char>(), int flags=DrawMatchesFlags::DEFAULT )
This function draws matches of keypints from two images on output image. This function draws matches of keypints from two images on output image.
Match is a line connecting two keypoints (circles). Match is a line connecting two keypoints (circles).
.. cfunction:: void drawMatches( const Mat\& img1, const vector<KeyPoint>\& keypoints1, const Mat\& img2, const vector<KeyPoint>\& keypoints2, const vector<vector<DMatch> >\& matches1to2, Mat\& outImg, const Scalar\& matchColor=Scalar::all(-1), const Scalar\& singlePointColor=Scalar::all(-1), const vector<vector<char>>\& matchesMask= vector<vector<char> >(), int flags=DrawMatchesFlags::DEFAULT ) .. c:function:: void drawMatches( const Mat\& img1, const vector<KeyPoint>\& keypoints1, const Mat\& img2, const vector<KeyPoint>\& keypoints2, const vector<vector<DMatch> >\& matches1to2, Mat\& outImg, const Scalar\& matchColor=Scalar::all(-1), const Scalar\& singlePointColor=Scalar::all(-1), const vector<vector<char>>\& matchesMask= vector<vector<char> >(), int flags=DrawMatchesFlags::DEFAULT )
:param img1: First source image. :param img1: First source image.
@ -60,9 +60,9 @@ Match is a line connecting two keypoints (circles).
.. index:: drawKeypoints .. index:: drawKeypoints
cv::drawKeypoints drawKeypoints
----------------- -----------------
.. cfunction:: void drawKeypoints( const Mat\& image, const vector<KeyPoint>\& keypoints, Mat\& outImg, const Scalar\& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT ) .. c:function:: void drawKeypoints( const Mat\& image, const vector<KeyPoint>\& keypoints, Mat\& outImg, const Scalar\& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT )
Draw keypoints. Draw keypoints.

130
modules/features2d/doc/feature_detection_and_description.rst
View File

@ -5,9 +5,9 @@ Feature detection and description
.. index:: FAST .. index:: FAST
cv::FAST FAST
-------- --------
.. cfunction:: void FAST( const Mat\& image, vector<KeyPoint>\& keypoints, int threshold, bool nonmaxSupression=true ) .. c:function:: void FAST( const Mat& image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true )
Detects corners using FAST algorithm by E. Rosten (''Machine learning for high-speed corner detection'', 2006). Detects corners using FAST algorithm by E. Rosten (''Machine learning for high-speed corner detection'', 2006).
@ -26,7 +26,7 @@ cv::FAST
MSER MSER
---- ----
.. ctype:: MSER .. c:type:: MSER
Maximally-Stable Extremal Region Extractor :: Maximally-Stable Extremal Region Extractor ::
@ -45,11 +45,9 @@ Maximally-Stable Extremal Region Extractor ::
// the optional mask marks the area where MSERs are searched for // the optional mask marks the area where MSERs are searched for
void operator()( const Mat& image, vector<vector<Point> >& msers, const Mat& mask ) const; void operator()( const Mat& image, vector<vector<Point> >& msers, const Mat& mask ) const;
}; };
..
The class encapsulates all the parameters of MSER (see The class encapsulates all the parameters of MSER (see
http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions) extraction algorithm.
) extraction algorithm.
.. index:: StarDetector .. index:: StarDetector
@ -57,7 +55,7 @@ http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions
StarDetector StarDetector
------------ ------------
.. ctype:: StarDetector .. c:type:: StarDetector
Implements Star keypoint detector :: Implements Star keypoint detector ::
@ -86,7 +84,6 @@ Implements Star keypoint detector ::
// finds keypoints in an image // finds keypoints in an image
void operator()(const Mat& image, vector<KeyPoint>& keypoints) const; void operator()(const Mat& image, vector<KeyPoint>& keypoints) const;
}; };
..
The class implements a modified version of CenSurE keypoint detector described in The class implements a modified version of CenSurE keypoint detector described in
Agrawal08 Agrawal08
@ -97,7 +94,7 @@ Agrawal08
SIFT SIFT
---- ----
.. ctype:: SIFT .. c:type:: SIFT
Class for extracting keypoints and computing descriptors using approach named Scale Invariant Feature Transform (SIFT). :: Class for extracting keypoints and computing descriptors using approach named Scale Invariant Feature Transform (SIFT). ::
@ -179,7 +176,7 @@ Class for extracting keypoints and computing descriptors using approach named Sc
protected: protected:
... ...
}; };
..
.. index:: SURF .. index:: SURF
@ -187,14 +184,14 @@ Class for extracting keypoints and computing descriptors using approach named Sc
SURF SURF
---- ----
.. ctype:: SURF .. c:type:: SURF
Class for extracting Speeded Up Robust Features from an image. :: Class for extracting Speeded Up Robust Features from an image. ::
class SURF : public CvSURFParams class SURF : public CvSURFParams
{ {
public: public:
// default constructor // c:function::default constructor
SURF(); SURF();
// constructor that initializes all the algorithm parameters // constructor that initializes all the algorithm parameters
SURF(double _hessianThreshold, int _nOctaves=4, SURF(double _hessianThreshold, int _nOctaves=4,
@ -213,11 +210,8 @@ Class for extracting Speeded Up Robust Features from an image. ::
vector<float>& descriptors, vector<float>& descriptors,
bool useProvidedKeypoints=false) const; bool useProvidedKeypoints=false) const;
}; };
..
The class ``SURF`` implements Speeded Up Robust Features descriptor The class ``SURF`` implements Speeded Up Robust Features descriptor Bay06.
Bay06
.
There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints
(which is the default option), but the descriptors can be also computed for the user-specified keypoints. (which is the default option), but the descriptors can be also computed for the user-specified keypoints.
The function can be used for object tracking and localization, image stitching etc. See the ``find_obj.cpp`` demo in OpenCV samples directory. The function can be used for object tracking and localization, image stitching etc. See the ``find_obj.cpp`` demo in OpenCV samples directory.
@ -228,7 +222,7 @@ The function can be used for object tracking and localization, image stitching e
RandomizedTree RandomizedTree
-------------- --------------
.. ctype:: RandomizedTree .. c:type:: RandomizedTree
The class contains base structure for ``RTreeClassifier`` :: The class contains base structure for ``RTreeClassifier`` ::
@ -241,10 +235,10 @@ The class contains base structure for ``RTreeClassifier`` ::
~RandomizedTree(); ~RandomizedTree();
void train(std::vector<BaseKeypoint> const& base_set, void train(std::vector<BaseKeypoint> const& base_set,
cv::RNG &rng, int depth, int views, RNG &rng, int depth, int views,
size_t reduced_num_dim, int num_quant_bits); size_t reduced_num_dim, int num_quant_bits);
void train(std::vector<BaseKeypoint> const& base_set, void train(std::vector<BaseKeypoint> const& base_set,
cv::RNG &rng, PatchGenerator &make_patch, int depth, RNG &rng, PatchGenerator &make_patch, int depth,
int views, size_t reduced_num_dim, int num_quant_bits); int views, size_t reduced_num_dim, int num_quant_bits);
// following two funcs are EXPERIMENTAL // following two funcs are EXPERIMENTAL
@ -281,11 +275,11 @@ The class contains base structure for ``RTreeClassifier`` ::
uchar **posteriors2_; // 16-bytes aligned posteriors uchar **posteriors2_; // 16-bytes aligned posteriors
std::vector<int> leaf_counts_; std::vector<int> leaf_counts_;
void createNodes(int num_nodes, cv::RNG &rng); void createNodes(int num_nodes, RNG &rng);
void allocPosteriorsAligned(int num_leaves, int num_classes); void allocPosteriorsAligned(int num_leaves, int num_classes);
void freePosteriors(int which); void freePosteriors(int which);
// which: 1=posteriors_, 2=posteriors2_, 3=both // which: 1=posteriors_, 2=posteriors2_, 3=both
void init(int classes, int depth, cv::RNG &rng); void init(int classes, int depth, RNG &rng);
void addExample(int class_id, uchar* patch_data); void addExample(int class_id, uchar* patch_data);
void finalize(size_t reduced_num_dim, int num_quant_bits); void finalize(size_t reduced_num_dim, int num_quant_bits);
int getIndex(uchar* patch_data) const; int getIndex(uchar* patch_data) const;
@ -297,19 +291,18 @@ The class contains base structure for ``RTreeClassifier`` ::
void compressLeaves(size_t reduced_num_dim); void compressLeaves(size_t reduced_num_dim);
void estimateQuantPercForPosteriors(float perc[2]); void estimateQuantPercForPosteriors(float perc[2]);
}; };
..
.. index:: RandomizedTree::train .. index:: RandomizedTree::train
cv::RandomizedTree::train RandomizedTree::train
------------------------- -------------------------
.. cfunction:: void train(std::vector<BaseKeypoint> const\& base_set, cv::RNG \&rng, PatchGenerator \&make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) .. c:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits)
Trains a randomized tree using input set of keypoints Trains a randomized tree using input set of keypoints
.. cfunction:: void train(std::vector<BaseKeypoint> const\& base_set, cv::RNG \&rng, PatchGenerator \&make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) .. c:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits)
{Vector of ``BaseKeypoint`` type. Contains keypoints from the image are used for training} {Vector of ``BaseKeypoint`` type. Contains keypoints from the image are used for training}
{Random numbers generator is used for training} {Random numbers generator is used for training}
{Patch generator is used for training} {Patch generator is used for training}
{Maximum tree depth} {Maximum tree depth}
@ -319,13 +312,13 @@ cv::RandomizedTree::train
.. index:: RandomizedTree::read .. index:: RandomizedTree::read
cv::RandomizedTree::read RandomizedTree::read
------------------------ ------------------------
.. cfunction:: read(const char* file_name, int num_quant_bits) .. c:function:: read(const char* file_name, int num_quant_bits)
Reads pre-saved randomized tree from file or stream Reads pre-saved randomized tree from file or stream
.. cfunction:: read(std::istream \&is, int num_quant_bits) .. c:function:: read(std::istream \&is, int num_quant_bits)
:param file_name: Filename of file contains randomized tree data :param file_name: Filename of file contains randomized tree data
@ -335,13 +328,13 @@ cv::RandomizedTree::read
.. index:: RandomizedTree::write .. index:: RandomizedTree::write
cv::RandomizedTree::write RandomizedTree::write
------------------------- -------------------------
.. cfunction:: void write(const char* file_name) const .. c:function:: void write(const char* file_name) const
Writes current randomized tree to a file or stream Writes current randomized tree to a file or stream
.. cfunction:: void write(std::ostream \&os) const .. c:function:: void write(std::ostream \&os) const
:param file_name: Filename of file where randomized tree data will be stored :param file_name: Filename of file where randomized tree data will be stored
@ -349,9 +342,9 @@ cv::RandomizedTree::write
.. index:: RandomizedTree::applyQuantization .. index:: RandomizedTree::applyQuantization
cv::RandomizedTree::applyQuantization RandomizedTree::applyQuantization
------------------------------------- -------------------------------------
.. cfunction:: void applyQuantization(int num_quant_bits) .. c:function:: void applyQuantization(int num_quant_bits)
Applies quantization to the current randomized tree Applies quantization to the current randomized tree
@ -363,7 +356,7 @@ cv::RandomizedTree::applyQuantization
RTreeNode RTreeNode
--------- ---------
.. ctype:: RTreeNode .. c:type:: RTreeNode
The class contains base structure for ``RandomizedTree`` :: The class contains base structure for ``RandomizedTree`` ::
@ -384,7 +377,6 @@ The class contains base structure for ``RandomizedTree`` ::
return patch_data[offset1] > patch_data[offset2]; return patch_data[offset1] > patch_data[offset2];
} }
}; };
..
.. index:: RTreeClassifier .. index:: RTreeClassifier
@ -392,7 +384,7 @@ The class contains base structure for ``RandomizedTree`` ::
RTreeClassifier RTreeClassifier
--------------- ---------------
.. ctype:: RTreeClassifier .. c:type:: RTreeClassifier
The class contains ``RTreeClassifier`` . It represents calonder descriptor which was originally introduced by Michael Calonder :: The class contains ``RTreeClassifier`` . It represents calonder descriptor which was originally introduced by Michael Calonder ::
@ -405,7 +397,7 @@ The class contains ``RTreeClassifier`` . It represents calonder descriptor which
RTreeClassifier(); RTreeClassifier();
void train(std::vector<BaseKeypoint> const& base_set, void train(std::vector<BaseKeypoint> const& base_set,
cv::RNG &rng, RNG &rng,
int num_trees = RTreeClassifier::DEFAULT_TREES, int num_trees = RTreeClassifier::DEFAULT_TREES,
int depth = DEFAULT_DEPTH, int depth = DEFAULT_DEPTH,
int views = DEFAULT_VIEWS, int views = DEFAULT_VIEWS,
@ -413,7 +405,7 @@ The class contains ``RTreeClassifier`` . It represents calonder descriptor which
int num_quant_bits = DEFAULT_NUM_QUANT_BITS, int num_quant_bits = DEFAULT_NUM_QUANT_BITS,
bool print_status = true); bool print_status = true);
void train(std::vector<BaseKeypoint> const& base_set, void train(std::vector<BaseKeypoint> const& base_set,
cv::RNG &rng, RNG &rng,
PatchGenerator &make_patch, PatchGenerator &make_patch,
int num_trees = RTreeClassifier::DEFAULT_TREES, int num_trees = RTreeClassifier::DEFAULT_TREES,
int depth = DEFAULT_DEPTH, int depth = DEFAULT_DEPTH,
@ -457,17 +449,16 @@ The class contains ``RTreeClassifier`` . It represents calonder descriptor which
int original_num_classes_; int original_num_classes_;
bool keep_floats_; bool keep_floats_;
}; };
..
.. index:: RTreeClassifier::train .. index:: RTreeClassifier::train
cv::RTreeClassifier::train RTreeClassifier::train
-------------------------- --------------------------
.. cfunction:: void train(std::vector<BaseKeypoint> const\& base_set, cv::RNG \&rng, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true) .. c:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true)
Trains a randomized tree classificator using input set of keypoints Trains a randomized tree classificator using input set of keypoints
.. cfunction:: void train(std::vector<BaseKeypoint> const\& base_set, cv::RNG \&rng, PatchGenerator \&make_patch, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true) .. c:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true)
{Vector of ``BaseKeypoint`` type. Contains keypoints from the image are used for training} {Vector of ``BaseKeypoint`` type. Contains keypoints from the image are used for training}
{Random numbers generator is used for training} {Random numbers generator is used for training}
@ -481,34 +472,35 @@ cv::RTreeClassifier::train
.. index:: RTreeClassifier::getSignature .. index:: RTreeClassifier::getSignature
cv::RTreeClassifier::getSignature RTreeClassifier::getSignature
--------------------------------- ---------------------------------
.. cfunction:: void getSignature(IplImage *patch, uchar *sig) .. c:function:: void getSignature(IplImage *patch, uchar *sig)
Returns signature for image patch Returns signature for image patch
.. cfunction:: void getSignature(IplImage *patch, float *sig) .. c:function:: void getSignature(IplImage *patch, float *sig)
{Image patch to calculate signature for} {Image patch to calculate signature for}
{Output signature (array dimension is ``reduced_num_dim)`` } {Output signature (array dimension is ``reduced_num_dim)`` }
.. index:: RTreeClassifier::getSparseSignature .. index:: RTreeClassifier::getSparseSignature
cv::RTreeClassifier::getSparseSignature RTreeClassifier::getSparseSignature
--------------------------------------- ```` ---------------------------------------
.. cfunction:: void getSparseSignature(IplImage *patch, float *sig, float thresh)
.. c:function:: void getSparseSignature(IplImage *patch, float *sig, float thresh)
The function is simular to getSignaturebut uses the threshold for removing all signature elements less than the threshold. So that the signature is compressed The function is simular to getSignaturebut uses the threshold for removing all signature elements less than the threshold. So that the signature is compressed
{Image patch to calculate signature for} {Image patch to calculate signature for}
{Output signature (array dimension is ``reduced_num_dim)`` } {Output signature (array dimension is ``reduced_num_dim)``}
{The threshold that is used for compressing the signature} {The threshold that is used for compressing the signature}
.. index:: RTreeClassifier::countNonZeroElements .. index:: RTreeClassifier::countNonZeroElements
cv::RTreeClassifier::countNonZeroElements RTreeClassifier::countNonZeroElements
----------------------------------------- -----------------------------------------
.. cfunction:: static int countNonZeroElements(float *vec, int n, double tol=1e-10) .. c:function:: static int countNonZeroElements(float *vec, int n, double tol=1e-10)
The function returns the number of non-zero elements in the input array. The function returns the number of non-zero elements in the input array.
@ -520,13 +512,13 @@ cv::RTreeClassifier::countNonZeroElements
.. index:: RTreeClassifier::read .. index:: RTreeClassifier::read
cv::RTreeClassifier::read RTreeClassifier::read
------------------------- -------------------------
.. cfunction:: read(const char* file_name) .. c:function:: read(const char* file_name)
Reads pre-saved RTreeClassifier from file or stream Reads pre-saved RTreeClassifier from file or stream
.. cfunction:: read(std::istream \&is) .. c:function:: read(std::istream& is)
:param file_name: Filename of file contains randomized tree data :param file_name: Filename of file contains randomized tree data
@ -534,13 +526,13 @@ cv::RTreeClassifier::read
.. index:: RTreeClassifier::write .. index:: RTreeClassifier::write
cv::RTreeClassifier::write RTreeClassifier::write
-------------------------- --------------------------
.. cfunction:: void write(const char* file_name) const .. c:function:: void write(const char* file_name) const
Writes current RTreeClassifier to a file or stream Writes current RTreeClassifier to a file or stream
.. cfunction:: void write(std::ostream \&os) const .. c:function:: void write(std::ostream \&os) const
:param file_name: Filename of file where randomized tree data will be stored :param file_name: Filename of file where randomized tree data will be stored
@ -548,9 +540,9 @@ cv::RTreeClassifier::write
.. index:: RTreeClassifier::setQuantization .. index:: RTreeClassifier::setQuantization
cv::RTreeClassifier::setQuantization RTreeClassifier::setQuantization
------------------------------------ ------------------------------------
.. cfunction:: void setQuantization(int num_quant_bits) .. c:function:: void setQuantization(int num_quant_bits)
Applies quantization to the current randomized tree Applies quantization to the current randomized tree
@ -569,26 +561,26 @@ Below there is an example of ``RTreeClassifier`` usage for feature matching. The
cvExtractSURF( train_image, 0, &objectKeypoints, &objectDescriptors, cvExtractSURF( train_image, 0, &objectKeypoints, &objectDescriptors,
storage, params ); storage, params );
cv::RTreeClassifier detector; RTreeClassifier detector;
int patch_width = cv::PATCH_SIZE; int patch_width = PATCH_SIZE;
iint patch_height = cv::PATCH_SIZE; iint patch_height = PATCH_SIZE;
vector<cv::BaseKeypoint> base_set; vector<BaseKeypoint> base_set;
int i=0; int i=0;
CvSURFPoint* point; CvSURFPoint* point;
for (i=0;i<(n_points > 0 ? n_points : objectKeypoints->total);i++) for (i=0;i<(n_points > 0 ? n_points : objectKeypoints->total);i++)
{ {
point=(CvSURFPoint*)cvGetSeqElem(objectKeypoints,i); point=(CvSURFPoint*)cvGetSeqElem(objectKeypoints,i);
base_set.push_back( base_set.push_back(
cv::BaseKeypoint(point->pt.x,point->pt.y,train_image)); BaseKeypoint(point->pt.x,point->pt.y,train_image));
} }
//Detector training //Detector training
cv::RNG rng( cvGetTickCount() ); RNG rng( cvGetTickCount() );
cv::PatchGenerator gen(0,255,2,false,0.7,1.3,-CV_PI/3,CV_PI/3, PatchGenerator gen(0,255,2,false,0.7,1.3,-CV_PI/3,CV_PI/3,
-CV_PI/3,CV_PI/3); -CV_PI/3,CV_PI/3);
printf("RTree Classifier training...n"); printf("RTree Classifier training...n");
detector.train(base_set,rng,gen,24,cv::DEFAULT_DEPTH,2000, detector.train(base_set,rng,gen,24,DEFAULT_DEPTH,2000,
(int)base_set.size(), detector.DEFAULT_NUM_QUANT_BITS); (int)base_set.size(), detector.DEFAULT_NUM_QUANT_BITS);
printf("Donen"); printf("Donen");
@ -643,5 +635,5 @@ Below there is an example of ``RTreeClassifier`` usage for feature matching. The
} }
cvResetImageROI(test_image); cvResetImageROI(test_image);
} }
..
..

48
modules/features2d/doc/object_categorization.rst
View File

@ -12,7 +12,7 @@ are described in this section.
BOWTrainer BOWTrainer
---------- ----------
.. ctype:: BOWTrainer .. c:type:: BOWTrainer
Abstract base class for training ''bag of visual words'' vocabulary from a set of descriptors. Abstract base class for training ''bag of visual words'' vocabulary from a set of descriptors.
See e.g. ''Visual Categorization with Bags of Keypoints'' of Gabriella Csurka, Christopher R. Dance, See e.g. ''Visual Categorization with Bags of Keypoints'' of Gabriella Csurka, Christopher R. Dance,
@ -40,9 +40,9 @@ Lixin Fan, Jutta Willamowski, Cedric Bray, 2004. ::
.. index:: BOWTrainer::add .. index:: BOWTrainer::add
cv::BOWTrainer::add BOWTrainer::add
------------------- ```` ------------------- ````
.. cfunction:: void BOWTrainer::add( const Mat\& descriptors ) .. c:function:: void BOWTrainer::add( const Mat\& descriptors )
Add descriptors to training set. The training set will be clustered using clustermethod to construct vocabulary. Add descriptors to training set. The training set will be clustered using clustermethod to construct vocabulary.
@ -50,31 +50,31 @@ cv::BOWTrainer::add
.. index:: BOWTrainer::getDescriptors .. index:: BOWTrainer::getDescriptors
cv::BOWTrainer::getDescriptors BOWTrainer::getDescriptors
------------------------------ ------------------------------
.. cfunction:: const vector<Mat>\& BOWTrainer::getDescriptors() const .. c:function:: const vector<Mat>\& BOWTrainer::getDescriptors() const
Returns training set of descriptors. Returns training set of descriptors.
.. index:: BOWTrainer::descripotorsCount .. index:: BOWTrainer::descripotorsCount
cv::BOWTrainer::descripotorsCount BOWTrainer::descripotorsCount
--------------------------------- ---------------------------------
.. cfunction:: const vector<Mat>\& BOWTrainer::descripotorsCount() const .. c:function:: const vector<Mat>\& BOWTrainer::descripotorsCount() const
Returns count of all descriptors stored in the training set. Returns count of all descriptors stored in the training set.
.. index:: BOWTrainer::cluster .. index:: BOWTrainer::cluster
cv::BOWTrainer::cluster BOWTrainer::cluster
----------------------- -----------------------
.. cfunction:: Mat BOWTrainer::cluster() const .. c:function:: Mat BOWTrainer::cluster() const
Cluster train descriptors. Vocabulary consists from cluster centers. So this method Cluster train descriptors. Vocabulary consists from cluster centers. So this method
returns vocabulary. In first method variant the stored in object train descriptors will be returns vocabulary. In first method variant the stored in object train descriptors will be
clustered, in second variant -- input descriptors will be clustered. clustered, in second variant -- input descriptors will be clustered.
.. cfunction:: Mat BOWTrainer::cluster( const Mat\& descriptors ) const .. c:function:: Mat BOWTrainer::cluster( const Mat\& descriptors ) const
:param descriptors: Descriptors to cluster. Each row of ``descriptors`` matrix is a one descriptor. Descriptors will not be added :param descriptors: Descriptors to cluster. Each row of ``descriptors`` matrix is a one descriptor. Descriptors will not be added
to the inner train descriptor set. to the inner train descriptor set.
@ -85,7 +85,7 @@ clustered, in second variant -- input descriptors will be clustered.
BOWKMeansTrainer BOWKMeansTrainer
---------------- ----------------
.. ctype:: BOWKMeansTrainer .. c:type:: BOWKMeansTrainer
:func:`kmeans` based class to train visual vocabulary using the ''bag of visual words'' approach. :: :func:`kmeans` based class to train visual vocabulary using the ''bag of visual words'' approach. ::
@ -115,7 +115,7 @@ arguments.
BOWImgDescriptorExtractor BOWImgDescriptorExtractor
------------------------- -------------------------
.. ctype:: BOWImgDescriptorExtractor .. c:type:: BOWImgDescriptorExtractor
Class to compute image descriptor using ''bad of visual words''. In few, Class to compute image descriptor using ''bad of visual words''. In few,
such computing consists from the following steps: such computing consists from the following steps:
@ -149,9 +149,9 @@ Class to compute image descriptor using ''bad of visual words''. In few,
.. index:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor .. index:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor
cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor BOWImgDescriptorExtractor::BOWImgDescriptorExtractor
-------------------------------------------------------- --------------------------------------------------------
.. cfunction:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor( const Ptr<DescriptorExtractor>\& dextractor, const Ptr<DescriptorMatcher>\& dmatcher ) .. c:function:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor( const Ptr<DescriptorExtractor>\& dextractor, const Ptr<DescriptorMatcher>\& dmatcher )
Constructor. Constructor.
@ -163,9 +163,9 @@ cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor
.. index:: BOWImgDescriptorExtractor::setVocabulary .. index:: BOWImgDescriptorExtractor::setVocabulary
cv::BOWImgDescriptorExtractor::setVocabulary BOWImgDescriptorExtractor::setVocabulary
-------------------------------------------- --------------------------------------------
.. cfunction:: void BOWImgDescriptorExtractor::setVocabulary( const Mat\& vocabulary ) .. c:function:: void BOWImgDescriptorExtractor::setVocabulary( const Mat\& vocabulary )
Method to set visual vocabulary. Method to set visual vocabulary.
@ -174,17 +174,17 @@ cv::BOWImgDescriptorExtractor::setVocabulary
.. index:: BOWImgDescriptorExtractor::getVocabulary .. index:: BOWImgDescriptorExtractor::getVocabulary
cv::BOWImgDescriptorExtractor::getVocabulary BOWImgDescriptorExtractor::getVocabulary
-------------------------------------------- --------------------------------------------
.. cfunction:: const Mat\& BOWImgDescriptorExtractor::getVocabulary() const .. c:function:: const Mat\& BOWImgDescriptorExtractor::getVocabulary() const
Returns set vocabulary. Returns set vocabulary.
.. index:: BOWImgDescriptorExtractor::compute .. index:: BOWImgDescriptorExtractor::compute
cv::BOWImgDescriptorExtractor::compute BOWImgDescriptorExtractor::compute
-------------------------------------- --------------------------------------
.. cfunction:: void BOWImgDescriptorExtractor::compute( const Mat\& image, vector<KeyPoint>\& keypoints, Mat\& imgDescriptor, vector<vector<int> >* pointIdxsOfClusters=0, Mat* descriptors=0 ) .. c:function:: void BOWImgDescriptorExtractor::compute( const Mat\& image, vector<KeyPoint>\& keypoints, Mat\& imgDescriptor, vector<vector<int> >* pointIdxsOfClusters=0, Mat* descriptors=0 )
Compute image descriptor using set visual vocabulary. Compute image descriptor using set visual vocabulary.
@ -201,17 +201,17 @@ cv::BOWImgDescriptorExtractor::compute
.. index:: BOWImgDescriptorExtractor::descriptorSize .. index:: BOWImgDescriptorExtractor::descriptorSize
cv::BOWImgDescriptorExtractor::descriptorSize BOWImgDescriptorExtractor::descriptorSize
--------------------------------------------- ---------------------------------------------
.. cfunction:: int BOWImgDescriptorExtractor::descriptorSize() const .. c:function:: int BOWImgDescriptorExtractor::descriptorSize() const
Returns image discriptor size, if vocabulary was set, and 0 otherwise. Returns image discriptor size, if vocabulary was set, and 0 otherwise.
.. index:: BOWImgDescriptorExtractor::descriptorType .. index:: BOWImgDescriptorExtractor::descriptorType
cv::BOWImgDescriptorExtractor::descriptorType BOWImgDescriptorExtractor::descriptorType
--------------------------------------------- ---------------------------------------------
.. cfunction:: int BOWImgDescriptorExtractor::descriptorType() const .. c:function:: int BOWImgDescriptorExtractor::descriptorType() const
Returns image descriptor type. Returns image descriptor type.

66
modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
View File

@ -9,7 +9,7 @@ Camera Calibration and 3d Reconstruction
gpu::StereoBM_GPU gpu::StereoBM_GPU
----------------- -----------------
.. ctype:: gpu::StereoBM_GPU .. c:type:: gpu::StereoBM_GPU
The class for computing stereo correspondence using block matching algorithm. :: The class for computing stereo correspondence using block matching algorithm. ::
@ -39,7 +39,7 @@ The class for computing stereo correspondence using block matching algorithm. ::
... ...
}; };
..
This class computes the disparity map using block matching algorithm. The class also performs pre- and post- filtering steps: sobel prefiltering (if PREFILTER_XSOBEL flag is set) and low textureness filtering (if averageTexThreshols This class computes the disparity map using block matching algorithm. The class also performs pre- and post- filtering steps: sobel prefiltering (if PREFILTER_XSOBEL flag is set) and low textureness filtering (if averageTexThreshols
:math:`>` 0). If ``avergeTexThreshold = 0`` low textureness filtering is disabled, otherwise disparity is set to 0 in each point ``(x, y)`` where for left image :math:`>` 0). If ``avergeTexThreshold = 0`` low textureness filtering is disabled, otherwise disparity is set to 0 in each point ``(x, y)`` where for left image
@ -51,9 +51,9 @@ This class computes the disparity map using block matching algorithm. The class
cv::gpu::StereoBM_GPU::StereoBM_GPU cv::gpu::StereoBM_GPU::StereoBM_GPU
-----------------------------------_ -----------------------------------_
.. cfunction:: StereoBM_GPU::StereoBM_GPU() .. c:function:: StereoBM_GPU::StereoBM_GPU()
.. cfunction:: StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ) .. c:function:: StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ)
StereoBMGPU constructors. StereoBMGPU constructors.
@ -73,9 +73,9 @@ cv::gpu::StereoBM_GPU::StereoBM_GPU
cv::gpu::StereoBM_GPU::operator () cv::gpu::StereoBM_GPU::operator ()
---------------------------------- ----------------------------------
.. cfunction:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity) .. c:function:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, const Stream\& stream) .. c:function:: void StereoBM_GPU::operator() (const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, const Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair. The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
@ -93,7 +93,7 @@ cv::gpu::StereoBM_GPU::operator ()
cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable
----------------------------------------------- -----------------------------------------------
.. cfunction:: bool StereoBM_GPU::checkIfGpuCallReasonable() .. c:function:: bool StereoBM_GPU::checkIfGpuCallReasonable()
Some heuristics that tries to estmate if the current GPU will be faster then CPU in this algorithm. It queries current active device. Some heuristics that tries to estmate if the current GPU will be faster then CPU in this algorithm. It queries current active device.
@ -103,7 +103,7 @@ cv::gpu::StereoBM_GPU::checkIfGpuCallReasonable
gpu::StereoBeliefPropagation gpu::StereoBeliefPropagation
---------------------------- ----------------------------
.. ctype:: gpu::StereoBeliefPropagation .. c:type:: gpu::StereoBeliefPropagation
The class for computing stereo correspondence using belief propagation algorithm. :: The class for computing stereo correspondence using belief propagation algorithm. ::
@ -147,7 +147,7 @@ The class for computing stereo correspondence using belief propagation algorithm
... ...
}; };
..
The class implements Pedro F. Felzenszwalb algorithm The class implements Pedro F. Felzenszwalb algorithm
felzenszwalb_bp felzenszwalb_bp
@ -171,9 +171,9 @@ for data cost storage. ``width_step`` is the number of bytes in a line including
cv::gpu::StereoBeliefPropagation::StereoBeliefPropagation cv::gpu::StereoBeliefPropagation::StereoBeliefPropagation
--------------------------------------------------------- ---------------------------------------------------------
.. cfunction:: StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F) .. c:function:: StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
.. cfunction:: 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) .. c:function:: 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)
StereoBeliefPropagation constructors. StereoBeliefPropagation constructors.
@ -216,7 +216,7 @@ By default ``StereoBeliefPropagation`` uses floating-point arithmetics and ``CV_
cv::gpu::StereoBeliefPropagation::estimateRecommendedParams cv::gpu::StereoBeliefPropagation::estimateRecommendedParams
----------------------------------------------------------- ```` ```` ```` ```` ```` ----------------------------------------------------------- ```` ```` ```` ```` ````
.. cfunction:: void StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels) .. c:function:: void StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels)
Some heuristics that tries to compute recommended parameters (ndisp, itersand levels) for specified image size (widthand height). Some heuristics that tries to compute recommended parameters (ndisp, itersand levels) for specified image size (widthand height).
@ -224,9 +224,9 @@ cv::gpu::StereoBeliefPropagation::estimateRecommendedParams
cv::gpu::StereoBeliefPropagation::operator () cv::gpu::StereoBeliefPropagation::operator ()
--------------------------------------------- ---------------------------------------------
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity) .. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream) .. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair or data cost. The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair or data cost.
@ -238,9 +238,9 @@ cv::gpu::StereoBeliefPropagation::operator ()
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity) .. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity)
.. cfunction:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity, Stream\& stream) .. c:function:: void StereoBeliefPropagation::operator()( const GpuMat\& data, GpuMat\& disparity, Stream\& stream)
* **data** The user specified data cost. It must have ``msg_type`` type and :math:`\texttt{imgRows} \cdot \texttt{ndisp} \times \texttt{imgCols}` size. * **data** The user specified data cost. It must have ``msg_type`` type and :math:`\texttt{imgRows} \cdot \texttt{ndisp} \times \texttt{imgCols}` size.
@ -254,7 +254,7 @@ cv::gpu::StereoBeliefPropagation::operator ()
gpu::StereoConstantSpaceBP gpu::StereoConstantSpaceBP
-------------------------- --------------------------
.. ctype:: gpu::StereoConstantSpaceBP .. c:type:: gpu::StereoConstantSpaceBP
The class for computing stereo correspondence using constant space belief propagation algorithm. :: The class for computing stereo correspondence using constant space belief propagation algorithm. ::
@ -305,7 +305,7 @@ The class for computing stereo correspondence using constant space belief propag
... ...
}; };
..
The class implements Q. Yang algorithm The class implements Q. Yang algorithm
qx_csbp qx_csbp
@ -315,9 +315,9 @@ qx_csbp
cv::gpu::StereoConstantSpaceBP::StereoConstantSpaceBP cv::gpu::StereoConstantSpaceBP::StereoConstantSpaceBP
----------------------------------------------------- -----------------------------------------------------
.. cfunction:: 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) .. c:function:: 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)
.. cfunction:: 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) .. c: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)
StereoConstantSpaceBP constructors. StereoConstantSpaceBP constructors.
@ -364,7 +364,7 @@ By default ``StereoConstantSpaceBP`` uses floating-point arithmetics and ``CV_32
cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams
--------------------------------------------------------- ```` ```` ```` ``_`` ```` ```` --------------------------------------------------------- ```` ```` ```` ``_`` ```` ````
.. cfunction:: void StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels, int\& nr_plane) .. c:function:: void StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int\& ndisp, int\& iters, int\& levels, int\& nr_plane)
Some heuristics that tries to compute parameters (ndisp, iters, levelsand nrplane) for specified image size (widthand height). Some heuristics that tries to compute parameters (ndisp, iters, levelsand nrplane) for specified image size (widthand height).
@ -372,9 +372,9 @@ cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams
cv::gpu::StereoConstantSpaceBP::operator () cv::gpu::StereoConstantSpaceBP::operator ()
------------------------------------------- -------------------------------------------
.. cfunction:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity) .. c:function:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity)
.. cfunction:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream) .. c:function:: void StereoConstantSpaceBP::operator()( const GpuMat\& left, const GpuMat\& right, GpuMat\& disparity, Stream\& stream)
The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair. The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
@ -392,7 +392,7 @@ cv::gpu::StereoConstantSpaceBP::operator ()
gpu::DisparityBilateralFilter gpu::DisparityBilateralFilter
----------------------------- -----------------------------
.. ctype:: gpu::DisparityBilateralFilter .. c:type:: gpu::DisparityBilateralFilter
The class for disparity map refinement using joint bilateral filtering. :: The class for disparity map refinement using joint bilateral filtering. ::
@ -417,7 +417,7 @@ The class for disparity map refinement using joint bilateral filtering. ::
... ...
}; };
..
The class implements Q. Yang algorithm The class implements Q. Yang algorithm
qx_csbp qx_csbp
@ -427,9 +427,9 @@ qx_csbp
cv::gpu::DisparityBilateralFilter::DisparityBilateralFilter cv::gpu::DisparityBilateralFilter::DisparityBilateralFilter
----------------------------------------------------------- -----------------------------------------------------------
.. cfunction:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS) .. c:function:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
.. cfunction:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range) .. c:function:: DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range)
DisparityBilateralFilter constructors. DisparityBilateralFilter constructors.
@ -449,9 +449,9 @@ cv::gpu::DisparityBilateralFilter::DisparityBilateralFilter
cv::gpu::DisparityBilateralFilter::operator () cv::gpu::DisparityBilateralFilter::operator ()
---------------------------------------------- ----------------------------------------------
.. cfunction:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst) .. c:function:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst)
.. cfunction:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst, Stream\& stream) .. c:function:: void DisparityBilateralFilter::operator()( const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst, Stream\& stream)
Refines disparity map using joint bilateral filtering. Refines disparity map using joint bilateral filtering.
@ -467,9 +467,9 @@ cv::gpu::DisparityBilateralFilter::operator ()
cv::gpu::drawColorDisp cv::gpu::drawColorDisp
---------------------- ----------------------
.. cfunction:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp) .. c:function:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp)
.. cfunction:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp, const Stream\& stream) .. c:function:: void drawColorDisp(const GpuMat\& src_disp, GpuMat\& dst_disp, int ndisp, const Stream\& stream)
Does coloring of disparity image. Does coloring of disparity image.
@ -489,9 +489,9 @@ This function converts
cv::gpu::reprojectImageTo3D cv::gpu::reprojectImageTo3D
--------------------------- ---------------------------
.. cfunction:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q) .. c:function:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q)
.. cfunction:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q, const Stream\& stream) .. c:function:: void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, const Mat\& Q, const Stream\& stream)
Reprojects disparity image to 3D space. Reprojects disparity image to 3D space.

54
modules/gpu/doc/data_structures.rst
View File

@ -9,7 +9,7 @@ Data Structures
gpu::DevMem2D_ gpu::DevMem2D_
-------------- --------------
.. ctype:: gpu::DevMem2D_ .. c:type:: gpu::DevMem2D_
This is a simple lightweight class that encapsulate pitched memory on GPU. It is intended to pass to nvcc-compiled code, i.e. CUDA kernels. So it is used internally by OpenCV and by users writes own device code. Its members can be called both from host and from device code. :: This is a simple lightweight class that encapsulate pitched memory on GPU. It is intended to pass to nvcc-compiled code, i.e. CUDA kernels. So it is used internally by OpenCV and by users writes own device code. Its members can be called both from host and from device code. ::
@ -35,7 +35,7 @@ This is a simple lightweight class that encapsulate pitched memory on GPU. It is
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0); __CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const; __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
}; };
..
.. index:: gpu::PtrStep_ .. index:: gpu::PtrStep_
@ -43,7 +43,7 @@ This is a simple lightweight class that encapsulate pitched memory on GPU. It is
gpu::PtrStep_ gpu::PtrStep_
------------- -------------
.. ctype:: gpu::PtrStep_ .. c:type:: gpu::PtrStep_
This is structure is similar to DevMem2D_but contains only pointer and row step. Width and height fields are excluded due to performance reasons. The structure is for internal use or for users who write own device code. :: This is structure is similar to DevMem2D_but contains only pointer and row step. Width and height fields are excluded due to performance reasons. The structure is for internal use or for users who write own device code. ::
@ -62,7 +62,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step.
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0); __CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const; __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
}; };
..
.. index:: gpu::PtrElemStrp_ .. index:: gpu::PtrElemStrp_
@ -70,7 +70,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step.
gpu::PtrElemStrp_ gpu::PtrElemStrp_
----------------- -----------------
.. ctype:: gpu::PtrElemStrp_ .. c:type:: gpu::PtrElemStrp_
This is structure is similar to DevMem2D_but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class is can only be constructed if sizeof(T) is a multiple of 256. The structure is for internal use or for users who write own device code. :: This is structure is similar to DevMem2D_but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class is can only be constructed if sizeof(T) is a multiple of 256. The structure is for internal use or for users who write own device code. ::
@ -80,7 +80,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0); __CV_GPU_HOST_DEVICE__ T* ptr(int y = 0);
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const; __CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const;
}; };
..
.. index:: gpu::GpuMat .. index:: gpu::GpuMat
@ -88,7 +88,7 @@ This is structure is similar to DevMem2D_but contains only pointer and row step
gpu::GpuMat gpu::GpuMat
----------- -----------
.. ctype:: gpu::GpuMat .. c:type:: gpu::GpuMat
The base storage class for GPU memory with reference counting. Its interface is almost The base storage class for GPU memory with reference counting. Its interface is almost
:func:`Mat` interface with some limitations, so using it won't be a problem. The limitations are no arbitrary dimensions support (only 2D), no functions that returns references to its data (because references on GPU are not valid for CPU), no expression templates technique support. Because of last limitation please take care with overloaded matrix operators - they cause memory allocations. The GpuMat class is convertible to :func:`Mat` interface with some limitations, so using it won't be a problem. The limitations are no arbitrary dimensions support (only 2D), no functions that returns references to its data (because references on GPU are not valid for CPU), no expression templates technique support. Because of last limitation please take care with overloaded matrix operators - they cause memory allocations. The GpuMat class is convertible to
@ -129,7 +129,7 @@ In contrast with
//! download async //! download async
void download(CudaMem& m, Stream& stream) const; void download(CudaMem& m, Stream& stream) const;
}; };
..
**Please note:** **Please note:**
Is it a bad practice to leave static or global GpuMat variables allocated, i.e. to rely on its destructor. That is because destruction order of such variables and CUDA context is undefined and GPU memory release function returns error if CUDA context has been destroyed before. Is it a bad practice to leave static or global GpuMat variables allocated, i.e. to rely on its destructor. That is because destruction order of such variables and CUDA context is undefined and GPU memory release function returns error if CUDA context has been destroyed before.
@ -142,7 +142,7 @@ See also:
gpu::CudaMem gpu::CudaMem
------------ ------------
.. ctype:: gpu::CudaMem .. c:type:: gpu::CudaMem
This is a class with reference counting that wraps special memory type allocation functions from CUDA. Its interface is also This is a class with reference counting that wraps special memory type allocation functions from CUDA. Its interface is also
:func:`Mat` -like but with additional memory type parameter: :func:`Mat` -like but with additional memory type parameter:
@ -183,16 +183,16 @@ Please note that allocation size of such memory types is usually limited. For mo
int alloc_type; int alloc_type;
}; };
..
.. index:: gpu::CudaMem::createMatHeader .. index:: gpu::CudaMem::createMatHeader
cv::gpu::CudaMem::createMatHeader cv::gpu::CudaMem::createMatHeader
--------------------------------- ---------------------------------
:func:`Mat` :func:`Mat`
.. cfunction:: Mat CudaMem::createMatHeader() const .. c:function:: Mat CudaMem::createMatHeader() const
.. cfunction:: CudaMem::operator Mat() const .. c:function:: CudaMem::operator Mat() const
Creates header without reference counting to CudaMem data. Creates header without reference counting to CudaMem data.
@ -201,9 +201,9 @@ cv::gpu::CudaMem::createMatHeader
cv::gpu::CudaMem::createGpuMatHeader cv::gpu::CudaMem::createGpuMatHeader
------------------------------------ ------------------------------------
:func:`gpu::GpuMat` ``_`` :func:`gpu::GpuMat` ``_``
.. cfunction:: GpuMat CudaMem::createGpuMatHeader() const .. c:function:: GpuMat CudaMem::createGpuMatHeader() const
.. cfunction:: CudaMem::operator GpuMat() const .. c:function:: CudaMem::operator GpuMat() const
Maps CPU memory to GPU address space and creates header without reference counting for it. This can be done only if memory was allocated with ALLOCZEROCOPYflag and if it is supported by hardware (laptops often share video and CPU memory, so address spaces can be mapped, and that eliminates extra copy). Maps CPU memory to GPU address space and creates header without reference counting for it. This can be done only if memory was allocated with ALLOCZEROCOPYflag and if it is supported by hardware (laptops often share video and CPU memory, so address spaces can be mapped, and that eliminates extra copy).
@ -211,7 +211,7 @@ cv::gpu::CudaMem::createGpuMatHeader
cv::gpu::CudaMem::canMapHostMemory cv::gpu::CudaMem::canMapHostMemory
---------------------------------- ``_`` ---------------------------------- ``_``
.. cfunction:: static bool CudaMem::canMapHostMemory() .. c:function:: static bool CudaMem::canMapHostMemory()
Returns true if the current hardware supports address space mapping and ALLOCZEROCOPYmemory allocation Returns true if the current hardware supports address space mapping and ALLOCZEROCOPYmemory allocation
@ -221,7 +221,7 @@ cv::gpu::CudaMem::canMapHostMemory
gpu::Stream gpu::Stream
----------- -----------
.. ctype:: gpu::Stream .. c:type:: gpu::Stream
This class encapsulated queue of the asynchronous calls. Some functions have overloads with additional This class encapsulated queue of the asynchronous calls. Some functions have overloads with additional
:func:`gpu::Stream` parameter. The overloads do initialization work (allocate output buffers, upload constants, etc.), start GPU kernel and return before results are ready. A check if all operation are complete can be performed via :func:`gpu::Stream` parameter. The overloads do initialization work (allocate output buffers, upload constants, etc.), start GPU kernel and return before results are ready. A check if all operation are complete can be performed via
@ -266,13 +266,13 @@ This class encapsulated queue of the asynchronous calls. Some functions have ove
void enqueueConvert(const GpuMat& src, GpuMat& dst, int type, void enqueueConvert(const GpuMat& src, GpuMat& dst, int type,
double a = 1, double b = 0); double a = 1, double b = 0);
}; };
..
.. index:: gpu::Stream::queryIfComplete .. index:: gpu::Stream::queryIfComplete
cv::gpu::Stream::queryIfComplete cv::gpu::Stream::queryIfComplete
-------------------------------- --------------------------------
.. cfunction:: bool Stream::queryIfComplete() .. c:function:: bool Stream::queryIfComplete()
Returns true if the current stream queue is finished, otherwise false. Returns true if the current stream queue is finished, otherwise false.
@ -280,7 +280,7 @@ cv::gpu::Stream::queryIfComplete
cv::gpu::Stream::waitForCompletion cv::gpu::Stream::waitForCompletion
---------------------------------- ----------------------------------
.. cfunction:: void Stream::waitForCompletion() .. c:function:: void Stream::waitForCompletion()
Blocks until all operations in the stream are complete. Blocks until all operations in the stream are complete.
@ -290,7 +290,7 @@ cv::gpu::Stream::waitForCompletion
gpu::StreamAccessor gpu::StreamAccessor
------------------- -------------------
.. ctype:: gpu::StreamAccessor .. c:type:: gpu::StreamAccessor
This class provides possibility to get ``cudaStream_t`` from This class provides possibility to get ``cudaStream_t`` from
:func:`gpu::Stream` . This class is declared in ``stream_accessor.hpp`` because that is only public header that depend on Cuda Runtime API. Including it will bring the dependency to your code. :: :func:`gpu::Stream` . This class is declared in ``stream_accessor.hpp`` because that is only public header that depend on Cuda Runtime API. Including it will bring the dependency to your code. ::
@ -299,13 +299,13 @@ This class provides possibility to get ``cudaStream_t`` from
{ {
CV_EXPORTS static cudaStream_t getStream(const Stream& stream); CV_EXPORTS static cudaStream_t getStream(const Stream& stream);
}; };
..
.. index:: gpu::createContinuous .. index:: gpu::createContinuous
cv::gpu::createContinuous cv::gpu::createContinuous
------------------------- -------------------------
.. cfunction:: void createContinuous(int rows, int cols, int type, GpuMat\& m) .. c:function:: void createContinuous(int rows, int cols, int type, GpuMat\& m)
Creates continuous matrix in GPU memory. Creates continuous matrix in GPU memory.
@ -319,11 +319,11 @@ cv::gpu::createContinuous
Also the following wrappers are available: Also the following wrappers are available:
.. cfunction:: GpuMat createContinuous(int rows, int cols, int type) .. c:function:: GpuMat createContinuous(int rows, int cols, int type)
.. cfunction:: void createContinuous(Size size, int type, GpuMat\& m) .. c:function:: void createContinuous(Size size, int type, GpuMat\& m)
.. cfunction:: GpuMat createContinuous(Size size, int type) .. c:function:: GpuMat createContinuous(Size size, int type)
Matrix is called continuous if its elements are stored continuously, i.e. wuthout gaps in the end of each row. Matrix is called continuous if its elements are stored continuously, i.e. wuthout gaps in the end of each row.
@ -331,7 +331,7 @@ Matrix is called continuous if its elements are stored continuously, i.e. wuthou
cv::gpu::ensureSizeIsEnough cv::gpu::ensureSizeIsEnough
--------------------------- ---------------------------
.. cfunction:: void ensureSizeIsEnough(int rows, int cols, int type, GpuMat\& m) .. c:function:: void ensureSizeIsEnough(int rows, int cols, int type, GpuMat\& m)
Ensures that size of matrix is big enough and matrix has proper type. The function doesn't reallocate memory if the matrix has proper attributes already. Ensures that size of matrix is big enough and matrix has proper type. The function doesn't reallocate memory if the matrix has proper attributes already.
@ -345,5 +345,5 @@ cv::gpu::ensureSizeIsEnough
Also the following wrapper is available: Also the following wrapper is available:
.. cfunction:: void ensureSizeIsEnough(Size size, int type, GpuMat\& m) .. c:function:: void ensureSizeIsEnough(Size size, int type, GpuMat\& m)

38
modules/gpu/doc/feature_detection_and_description.rst
View File

@ -9,7 +9,7 @@ Feature Detection and Description
gpu::SURF_GPU gpu::SURF_GPU
------------- -------------
.. ctype:: gpu::SURF_GPU .. c:type:: gpu::SURF_GPU
Class for extracting Speeded Up Robust Features from an image. :: Class for extracting Speeded Up Robust Features from an image. ::
@ -62,7 +62,7 @@ Class for extracting Speeded Up Robust Features from an image. ::
GpuMat maxPosBuffer; GpuMat maxPosBuffer;
GpuMat featuresBuffer; GpuMat featuresBuffer;
}; };
..
The class ``SURF_GPU`` implements Speeded Up Robust Features descriptor. There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints (which is the default option), but the descriptors can be also computed for the user-specified keypoints. Supports only 8 bit grayscale images. The class ``SURF_GPU`` implements Speeded Up Robust Features descriptor. There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints (which is the default option), but the descriptors can be also computed for the user-specified keypoints. Supports only 8 bit grayscale images.
@ -81,7 +81,7 @@ See also:
gpu::BruteForceMatcher_GPU gpu::BruteForceMatcher_GPU
-------------------------- --------------------------
.. ctype:: gpu::BruteForceMatcher_GPU .. c:type:: gpu::BruteForceMatcher_GPU
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. :: 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. ::
@ -166,7 +166,7 @@ Brute-force descriptor matcher. For each descriptor in the first set, this match
private: private:
std::vector<GpuMat> trainDescCollection; std::vector<GpuMat> trainDescCollection;
}; };
..
The class ``BruteForceMatcher_GPU`` has the similar interface to class The class ``BruteForceMatcher_GPU`` has the similar interface to class
. It has two groups of match methods: for matching descriptors of one image with other image or with image set. Also all functions have alternative: save results to GPU memory or to CPU memory. . It has two groups of match methods: for matching descriptors of one image with other image or with image set. Also all functions have alternative: save results to GPU memory or to CPU memory.
@ -180,9 +180,9 @@ See also:,.
cv::gpu::BruteForceMatcher_GPU::match cv::gpu::BruteForceMatcher_GPU::match
------------------------------------- -------------------------------------
.. cfunction:: void match(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector<DMatch>\& matches, const GpuMat\& mask = GpuMat()) .. c:function:: void match(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector<DMatch>\& matches, const GpuMat\& mask = GpuMat())
.. cfunction:: void match(const GpuMat\& queryDescs, std::vector<DMatch>\& matches, const std::vector<GpuMat>\& masks = std::vector<GpuMat>()) .. c:function:: void match(const GpuMat\& queryDescs, std::vector<DMatch>\& matches, const std::vector<GpuMat>\& masks = std::vector<GpuMat>())
Finds the best match for each descriptor from a query set with train descriptors. Finds the best match for each descriptor from a query set with train descriptors.
@ -195,7 +195,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::matchSingle cv::gpu::BruteForceMatcher_GPU::matchSingle
------------------------------------------- -------------------------------------------
.. cfunction:: void matchSingle(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, const GpuMat\& mask = GpuMat()) .. c:function:: void matchSingle(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, const GpuMat\& mask = GpuMat())
Finds the best match for each query descriptor. Results will be stored to GPU memory. Finds the best match for each query descriptor. Results will be stored to GPU memory.
@ -212,7 +212,7 @@ cv::gpu::BruteForceMatcher_GPU::matchSingle
cv::gpu::BruteForceMatcher_GPU::matchCollection cv::gpu::BruteForceMatcher_GPU::matchCollection
----------------------------------------------- -----------------------------------------------
.. cfunction:: void matchCollection(const GpuMat\& queryDescs, const GpuMat\& trainCollection, GpuMat\& trainIdx, GpuMat\& imgIdx, GpuMat\& distance, const GpuMat\& maskCollection) .. c:function:: void matchCollection(const GpuMat\& queryDescs, const GpuMat\& trainCollection, GpuMat\& trainIdx, GpuMat\& imgIdx, GpuMat\& distance, const GpuMat\& maskCollection)
Find the best match for each query descriptor from train collection. Results will be stored to GPU memory. Find the best match for each query descriptor from train collection. Results will be stored to GPU memory.
@ -231,7 +231,7 @@ cv::gpu::BruteForceMatcher_GPU::matchCollection
cv::gpu::BruteForceMatcher_GPU::makeGpuCollection cv::gpu::BruteForceMatcher_GPU::makeGpuCollection
------------------------------------------------- -------------------------------------------------
.. cfunction:: void makeGpuCollection(GpuMat\& trainCollection, GpuMat\& maskCollection, const vector<GpuMat>\& masks = std::vector<GpuMat>()) .. c:function:: void makeGpuCollection(GpuMat\& trainCollection, GpuMat\& maskCollection, const vector<GpuMat>\& masks = std::vector<GpuMat>())
Makes gpu collection of train descriptors and masks in suitable format for function. Makes gpu collection of train descriptors and masks in suitable format for function.
@ -241,9 +241,9 @@ cv::gpu::BruteForceMatcher_GPU::makeGpuCollection
cv::gpu::BruteForceMatcher_GPU::matchDownload cv::gpu::BruteForceMatcher_GPU::matchDownload
--------------------------------------------- ```` ```` ```` --------------------------------------------- ```` ```` ````
.. cfunction:: void matchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector<DMatch>\& matches) .. c:function:: void matchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
.. cfunction:: void matchDownload(const GpuMat\& trainIdx, GpuMat\& imgIdx, const GpuMat\& distance, std::vector<DMatch>\& matches) .. c:function:: void matchDownload(const GpuMat\& trainIdx, GpuMat\& imgIdx, const GpuMat\& distance, std::vector<DMatch>\& matches)
Downloads trainIdx, imgIdxand distancematrices obtained via or to CPU vector with . Downloads trainIdx, imgIdxand distancematrices obtained via or to CPU vector with .
@ -253,11 +253,11 @@ cv::gpu::BruteForceMatcher_GPU::matchDownload
cv::gpu::BruteForceMatcher_GPU::knnMatch cv::gpu::BruteForceMatcher_GPU::knnMatch
---------------------------------------- ----------------------------------------
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, int k, const GpuMat\& mask = GpuMat(), bool compactResult = false) .. c:function:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, int k, const GpuMat\& mask = GpuMat(), bool compactResult = false)
Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order.
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, int k, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false ) .. c:function:: void knnMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, int k, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false )
See also: See also:
:func:`DescriptorMatcher::knnMatch` . :func:`DescriptorMatcher::knnMatch` .
@ -268,7 +268,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::knnMatch cv::gpu::BruteForceMatcher_GPU::knnMatch
---------------------------------------- ----------------------------------------
.. cfunction:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, GpuMat\& allDist, int k, const GpuMat\& mask = GpuMat()) .. c:function:: void knnMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& distance, GpuMat\& allDist, int k, const GpuMat\& mask = GpuMat())
Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. Results will be stored to GPU memory. Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. Results will be stored to GPU memory.
@ -291,7 +291,7 @@ cv::gpu::BruteForceMatcher_GPU::knnMatch
cv::gpu::BruteForceMatcher_GPU::knnMatchDownload cv::gpu::BruteForceMatcher_GPU::knnMatchDownload
------------------------------------------------ ```` ```` ```` ```` ------------------------------------------------ ```` ```` ```` ````
.. cfunction:: void knnMatchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false) .. c:function:: void knnMatchDownload(const GpuMat\& trainIdx, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
Downloads trainIdxand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors. Downloads trainIdxand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors.
@ -301,11 +301,11 @@ cv::gpu::BruteForceMatcher_GPU::knnMatchDownload
cv::gpu::BruteForceMatcher_GPU::radiusMatch cv::gpu::BruteForceMatcher_GPU::radiusMatch
------------------------------------------- -------------------------------------------
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const GpuMat\& mask = GpuMat(), bool compactResult = false) .. c:function:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const GpuMat\& mask = GpuMat(), bool compactResult = false)
Finds the best matches for each query descriptor which have distance less than given threshold. Found matches are returned in distance increasing order. Finds the best matches for each query descriptor which have distance less than given threshold. Found matches are returned in distance increasing order.
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false) .. c:function:: void radiusMatch(const GpuMat\& queryDescs, std::vector< std::vector<DMatch> >\& matches, float maxDistance, const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), bool compactResult = false)
This function works only on devices with Compute Capability This function works only on devices with Compute Capability
:math:`>=` 1.1. :math:`>=` 1.1.
@ -319,7 +319,7 @@ See also:
cv::gpu::BruteForceMatcher_GPU::radiusMatch cv::gpu::BruteForceMatcher_GPU::radiusMatch
------------------------------------------- -------------------------------------------
.. cfunction:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& nMatches, GpuMat\& distance, float maxDistance, const GpuMat\& mask = GpuMat()) .. c:function:: void radiusMatch(const GpuMat\& queryDescs, const GpuMat\& trainDescs, GpuMat\& trainIdx, GpuMat\& nMatches, GpuMat\& distance, float maxDistance, const GpuMat\& mask = GpuMat())
Finds the best matches for each query descriptor which have distance less than given threshold. Results will be stored to GPU memory. Finds the best matches for each query descriptor which have distance less than given threshold. Results will be stored to GPU memory.
@ -347,7 +347,7 @@ This function works only on devices with Compute Capability
cv::gpu::BruteForceMatcher_GPU::radiusMatchDownload cv::gpu::BruteForceMatcher_GPU::radiusMatchDownload
--------------------------------------------------- ```` ```` ```` ```` ```` --------------------------------------------------- ```` ```` ```` ```` ````
.. cfunction:: void radiusMatchDownload(const GpuMat\& trainIdx, const GpuMat\& nMatches, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false) .. c:function:: void radiusMatchDownload(const GpuMat\& trainIdx, const GpuMat\& nMatches, const GpuMat\& distance, std::vector< std::vector<DMatch> >\& matches, bool compactResult = false)
Downloads trainIdx, nMatchesand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors. Downloads trainIdx, nMatchesand distancematrices obtained via to CPU vector with . If compactResultis true matchesvector will not contain matches for fully masked out query descriptors.

88
modules/gpu/doc/image_filtering.rst
View File

@ -13,7 +13,7 @@ See also:
gpu::BaseRowFilter_GPU gpu::BaseRowFilter_GPU
---------------------- ----------------------
.. ctype:: gpu::BaseRowFilter_GPU .. c:type:: gpu::BaseRowFilter_GPU
The 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. :: The 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. ::
@ -25,7 +25,7 @@ The base class for linear or non-linear filters that processes rows of 2D arrays
virtual void operator()(const GpuMat& src, GpuMat& dst) = 0; virtual void operator()(const GpuMat& src, GpuMat& dst) = 0;
int ksize, anchor; int ksize, anchor;
}; };
..
**Please note:** **Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside This class doesn't allocate memory for destination image. Usually this class is used inside
@ -37,7 +37,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::BaseColumnFilter_GPU gpu::BaseColumnFilter_GPU
------------------------- -------------------------
.. ctype:: gpu::BaseColumnFilter_GPU .. c:type:: gpu::BaseColumnFilter_GPU
The 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. :: The 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,7 +49,7 @@ The base class for linear or non-linear filters that processes columns of 2D arr
virtual void operator()(const GpuMat& src, GpuMat& dst) = 0; virtual void operator()(const GpuMat& src, GpuMat& dst) = 0;
int ksize, anchor; int ksize, anchor;
}; };
..
**Please note:** **Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside This class doesn't allocate memory for destination image. Usually this class is used inside
@ -61,7 +61,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::BaseFilter_GPU gpu::BaseFilter_GPU
------------------- -------------------
.. ctype:: gpu::BaseFilter_GPU .. c:type:: gpu::BaseFilter_GPU
The base class for non-separable 2D filters. :: The base class for non-separable 2D filters. ::
@ -74,7 +74,7 @@ The base class for non-separable 2D filters. ::
Size ksize; Size ksize;
Point anchor; Point anchor;
}; };
..
**Please note:** **Please note:**
This class doesn't allocate memory for destination image. Usually this class is used inside This class doesn't allocate memory for destination image. Usually this class is used inside
@ -86,7 +86,7 @@ This class doesn't allocate memory for destination image. Usually this class is
gpu::FilterEngine_GPU gpu::FilterEngine_GPU
--------------------- ---------------------
.. ctype:: gpu::FilterEngine_GPU .. c:type:: gpu::FilterEngine_GPU
The base class for Filter Engine. :: The base class for Filter Engine. ::
@ -98,7 +98,7 @@ The base class for Filter Engine. ::
virtual void apply(const GpuMat& src, GpuMat& dst, virtual void apply(const GpuMat& src, GpuMat& dst,
Rect roi = Rect(0,0,-1,-1)) = 0; Rect roi = Rect(0,0,-1,-1)) = 0;
}; };
..
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 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
:func:`gpu::filter2D`,:func:`gpu::erode`,:func:`gpu::Sobel` etc. :func:`gpu::filter2D`,:func:`gpu::erode`,:func:`gpu::Sobel` etc.
@ -124,7 +124,7 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem
} }
// Release buffers only once // Release buffers only once
filter.release(); filter.release();
..
``FilterEngine_GPU`` can process a rectangular sub-region of an image. By default, if ``roi == Rect(0,0,-1,-1)``,``FilterEngine_GPU`` processes inner region of image ( ``Rect(anchor.x, anchor.y, src_size.width - ksize.width, src_size.height - ksize.height)`` ), because some filters doesn't check if indices are outside the image for better perfomace. See below which filters supports processing the whole image and which not and image type limitations. ``FilterEngine_GPU`` can process a rectangular sub-region of an image. By default, if ``roi == Rect(0,0,-1,-1)``,``FilterEngine_GPU`` processes inner region of image ( ``Rect(anchor.x, anchor.y, src_size.width - ksize.width, src_size.height - ksize.height)`` ), because some filters doesn't check if indices are outside the image for better perfomace. See below which filters supports processing the whole image and which not and image type limitations.
**Please note:** **Please note:**
@ -138,7 +138,7 @@ See also:,,,,,,,,,,
cv::gpu::createFilter2D_GPU cv::gpu::createFilter2D_GPU
--------------------------- ---------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createFilter2D_GPU( const Ptr<BaseFilter_GPU>\& filter2D, int srcType, int dstType) .. c:function:: Ptr<FilterEngine_GPU> createFilter2D_GPU( const Ptr<BaseFilter_GPU>\& filter2D, int srcType, int dstType)
Creates non-separable filter engine with the specified filter. Creates non-separable filter engine with the specified filter.
@ -156,7 +156,7 @@ Usually this function is used inside high-level functions, like,.
cv::gpu::createSeparableFilter_GPU cv::gpu::createSeparableFilter_GPU
---------------------------------- ----------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>\& rowFilter, const Ptr<BaseColumnFilter_GPU>\& columnFilter, int srcType, int bufType, int dstType) .. c:function:: Ptr<FilterEngine_GPU> createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>\& rowFilter, const Ptr<BaseColumnFilter_GPU>\& columnFilter, int srcType, int bufType, int dstType)
Creates separable filter engine with the specified filters. Creates separable filter engine with the specified filters.
@ -178,7 +178,7 @@ Usually this function is used inside high-level functions, like
cv::gpu::getRowSumFilter_GPU cv::gpu::getRowSumFilter_GPU
---------------------------- ----------------------------
.. cfunction:: Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1) .. c:function:: Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
Creates horizontal 1D box filter. Creates horizontal 1D box filter.
@ -199,7 +199,7 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::getColumnSumFilter_GPU cv::gpu::getColumnSumFilter_GPU
------------------------------- -------------------------------
.. cfunction:: Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1) .. c:function:: Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
Creates vertical 1D box filter. Creates vertical 1D box filter.
@ -220,11 +220,11 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::createBoxFilter_GPU cv::gpu::createBoxFilter_GPU
---------------------------- ----------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, const Point\& anchor = Point(-1,-1)) .. c:function:: Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, const Point\& anchor = Point(-1,-1))
Creates normalized 2D box filter. Creates normalized 2D box filter.
.. cfunction:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1, -1)) .. c:function:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4`` . :param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4`` .
@ -244,7 +244,7 @@ See also:
cv::gpu::boxFilter cv::gpu::boxFilter
------------------ ------------------
.. cfunction:: void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1)) .. c:function:: void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1))
Smooths the image using the normalized box filter. Smooths the image using the normalized box filter.
@ -268,7 +268,7 @@ See also:
cv::gpu::blur cv::gpu::blur
------------- -------------
.. cfunction:: void blur(const GpuMat\& src, GpuMat\& dst, Size ksize, Point anchor = Point(-1,-1)) .. c:function:: void blur(const GpuMat\& src, GpuMat\& dst, Size ksize, Point anchor = Point(-1,-1))
A synonym for normalized box filter. A synonym for normalized box filter.
@ -292,11 +292,11 @@ See also:
cv::gpu::createMorphologyFilter_GPU cv::gpu::createMorphologyFilter_GPU
----------------------------------- -----------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Point\& anchor = Point(-1,-1), int iterations = 1) .. c:function:: Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Point\& anchor = Point(-1,-1), int iterations = 1)
Creates 2D morphological filter. Creates 2D morphological filter.
.. cfunction:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Size\& ksize, Point anchor=Point(-1,-1)) .. c:function:: Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat\& kernel, const Size\& ksize, Point anchor=Point(-1,-1))
{Morphology operation id. Only ``MORPH_ERODE`` and ``MORPH_DILATE`` are supported.} {Morphology operation id. Only ``MORPH_ERODE`` and ``MORPH_DILATE`` are supported.}
@ -318,7 +318,7 @@ See also:
cv::gpu::erode cv::gpu::erode
-------------- --------------
.. cfunction:: void erode(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1) .. c:function:: void erode(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Erodes an image by using a specific structuring element. Erodes an image by using a specific structuring element.
@ -342,7 +342,7 @@ See also:
cv::gpu::dilate cv::gpu::dilate
--------------- ---------------
.. cfunction:: void dilate(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1) .. c:function:: void dilate(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Dilates an image by using a specific structuring element. Dilates an image by using a specific structuring element.
@ -366,25 +366,25 @@ See also:
cv::gpu::morphologyEx cv::gpu::morphologyEx
--------------------- ---------------------
.. cfunction:: void morphologyEx(const GpuMat\& src, GpuMat\& dst, int op, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1) .. c:function:: void morphologyEx(const GpuMat\& src, GpuMat\& dst, int op, const Mat\& kernel, Point anchor = Point(-1, -1), int iterations = 1)
Applies an advanced morphological operation to image. Applies an advanced morphological operation to image.
:param src: Source image. Supports ``CV_8UC1`` and ``CV_8UC4`` source type. :param src: Source image. Supports ``CV_8UC1`` and ``CV_8UC4`` source type.
:param dst: Destination image. It will have the same size and the same type as ``src`` :param dst: Destination image. It will have the same size and the same type as ``src``
:param op: Type of morphological operation, one of the following: :param op: Type of morphological operation, one of the following:
* **MORPH_OPEN** opening * **MORPH_OPEN** opening
* **MORPH_CLOSE** closing * **MORPH_CLOSE** closing
* **MORPH_GRADIENT** morphological gradient * **MORPH_GRADIENT** morphological gradient
* **MORPH_TOPHAT** "top hat" * **MORPH_TOPHAT** "top hat"
* **MORPH_BLACKHAT** "black hat" * **MORPH_BLACKHAT** "black hat"
:param kernel: Structuring element. :param kernel: Structuring element.
@ -404,11 +404,11 @@ See also:
cv::gpu::createLinearFilter_GPU cv::gpu::createLinearFilter_GPU
------------------------------- -------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Point\& anchor = Point(-1,-1)) .. c:function:: Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Point\& anchor = Point(-1,-1))
Creates the non-separable linear filter. Creates the non-separable linear filter.
.. cfunction:: Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Size\& ksize, Point anchor = Point(-1, -1)) .. c:function:: Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat\& kernel, const Size\& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4`` . :param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4`` .
@ -430,7 +430,7 @@ See also:
cv::gpu::filter2D cv::gpu::filter2D
----------------- -----------------
.. cfunction:: void filter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1)) .. c:function:: void filter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1))
Applies non-separable 2D linear filter to image. Applies non-separable 2D linear filter to image.
@ -454,7 +454,7 @@ See also:
cv::gpu::Laplacian cv::gpu::Laplacian
------------------ ------------------
.. cfunction:: void Laplacian(const GpuMat\& src, GpuMat\& dst, int ddepth, int ksize = 1, double scale = 1) .. c:function:: void Laplacian(const GpuMat\& src, GpuMat\& dst, int ddepth, int ksize = 1, double scale = 1)
Applies Laplacian operator to image. Applies Laplacian operator to image.
@ -480,7 +480,7 @@ See also:
cv::gpu::getLinearRowFilter_GPU cv::gpu::getLinearRowFilter_GPU
------------------------------- -------------------------------
.. cfunction:: Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat\& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT) .. c:function:: Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat\& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates primitive row filter with the specified kernel. Creates primitive row filter with the specified kernel.
@ -504,7 +504,7 @@ See also:,:func:`createSeparableLinearFilter` .
cv::gpu::getLinearColumnFilter_GPU cv::gpu::getLinearColumnFilter_GPU
---------------------------------- ----------------------------------
.. cfunction:: Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat\& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT) .. c:function:: Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat\& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT)
Creates the primitive column filter with the specified kernel. Creates the primitive column filter with the specified kernel.
@ -527,7 +527,7 @@ See also:,:func:`createSeparableLinearFilter` .
cv::gpu::createSeparableLinearFilter_GPU cv::gpu::createSeparableLinearFilter_GPU
---------------------------------------- ----------------------------------------
.. cfunction:: Ptr<FilterEngine_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) .. c:function:: Ptr<FilterEngine_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)
Creates the separable linear filter engine. Creates the separable linear filter engine.
@ -548,7 +548,7 @@ See also:,,
cv::gpu::sepFilter2D cv::gpu::sepFilter2D
-------------------- --------------------
.. cfunction:: void 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) .. c:function:: void 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 separable 2D linear filter to the image. Applies separable 2D linear filter to the image.
@ -572,7 +572,7 @@ See also:,:func:`sepFilter2D` .
cv::gpu::createDerivFilter_GPU cv::gpu::createDerivFilter_GPU
------------------------------ ------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) .. c:function:: Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates filter engine for the generalized Sobel operator. Creates filter engine for the generalized Sobel operator.
@ -594,7 +594,7 @@ See also:,:func:`createDerivFilter` .
cv::gpu::Sobel cv::gpu::Sobel
-------------- --------------
.. cfunction:: void 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) .. c:function:: void 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 generalized Sobel operator to the image. Applies generalized Sobel operator to the image.
@ -620,7 +620,7 @@ See also:,:func:`Sobel` .
cv::gpu::Scharr cv::gpu::Scharr
--------------- ---------------
.. cfunction:: void Scharr(const GpuMat\& src, GpuMat\& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) .. c:function:: void 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 Scharr operator. Calculates the first x- or y- image derivative using Scharr operator.
@ -645,7 +645,7 @@ See also:,:func:`Scharr` .
cv::gpu::createGaussianFilter_GPU cv::gpu::createGaussianFilter_GPU
--------------------------------- ---------------------------------
.. cfunction:: Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) .. c:function:: Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Creates Gaussian filter engine. Creates Gaussian filter engine.
@ -665,7 +665,7 @@ See also:,:func:`createGaussianFilter` .
cv::gpu::GaussianBlur cv::gpu::GaussianBlur
--------------------- ---------------------
.. cfunction:: void GaussianBlur(const GpuMat\& src, GpuMat\& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) .. c:function:: void GaussianBlur(const GpuMat\& src, GpuMat\& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
Smooths the image using Gaussian filter. Smooths the image using Gaussian filter.
@ -687,7 +687,7 @@ See also:,:func:`GaussianBlur` .
cv::gpu::getMaxFilter_GPU cv::gpu::getMaxFilter_GPU
------------------------- -------------------------
.. cfunction:: Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1)) .. c:function:: Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
Creates maximum filter. Creates maximum filter.
@ -708,7 +708,7 @@ This filter doesn't check out of border accesses, so only proper submatrix of bi
cv::gpu::getMinFilter_GPU cv::gpu::getMinFilter_GPU
------------------------- -------------------------
.. cfunction:: Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1)) .. c:function:: Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size\& ksize, Point anchor = Point(-1,-1))
Creates minimum filter. Creates minimum filter.

142
modules/gpu/doc/image_processing.rst
View File

@ -7,7 +7,10 @@ Image Processing
cv::gpu::meanShiftFiltering cv::gpu::meanShiftFiltering
--------------------------- ---------------------------
.. cfunction:: void meanShiftFiltering(const GpuMat\& src, GpuMat\& dst, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) .. c:function:: void 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, and as the result we have new color and new position of each point. Performs mean-shift filtering for each point of the source image. It maps each point of the source image into another point, and as the result we have new color and new position of each point.
@ -25,7 +28,10 @@ cv::gpu::meanShiftFiltering
cv::gpu::meanShiftProc cv::gpu::meanShiftProc
---------------------- ----------------------
.. cfunction:: void meanShiftProc(const GpuMat\& src, GpuMat\& dstr, GpuMat\& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) .. c:function:: void meanShiftProc(const GpuMat\& src, GpuMat\& dstr, GpuMat\& dstsp,
int sp, int sr,
TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
+ TermCriteria::EPS, 5, 1))
Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images. Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images.
@ -48,7 +54,10 @@ See also:
cv::gpu::meanShiftSegmentation cv::gpu::meanShiftSegmentation
------------------------------ ------------------------------
.. cfunction:: void meanShiftSegmentation(const GpuMat\& src, Mat\& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) .. c:function:: void meanShiftSegmentation(const GpuMat\& src, Mat\& dst,
int sp, int sr, int minsize,
TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER
+ TermCriteria::EPS, 5, 1))
Performs mean-shift segmentation of the source image and eleminates small segments. Performs mean-shift segmentation of the source image and eleminates small segments.
@ -68,9 +77,9 @@ cv::gpu::meanShiftSegmentation
cv::gpu::integral cv::gpu::integral
----------------- -----------------
.. cfunction:: void integral(const GpuMat\& src, GpuMat\& sum) .. c:function:: void integral(const GpuMat\& src, GpuMat\& sum)
.. cfunction:: void integral(const GpuMat\& src, GpuMat\& sum, GpuMat\& sqsum) .. c:function:: void integral(const GpuMat\& src, GpuMat\& sum, GpuMat\& sqsum)
Computes integral image and squared integral image. Computes integral image and squared integral image.
@ -87,7 +96,7 @@ See also:
cv::gpu::sqrIntegral cv::gpu::sqrIntegral
-------------------- --------------------
.. cfunction:: void sqrIntegral(const GpuMat\& src, GpuMat\& sqsum) .. c:function:: void sqrIntegral(const GpuMat\& src, GpuMat\& sqsum)
Computes squared integral image. Computes squared integral image.
@ -99,7 +108,7 @@ cv::gpu::sqrIntegral
cv::gpu::columnSum cv::gpu::columnSum
------------------ ------------------
.. cfunction:: void columnSum(const GpuMat\& src, GpuMat\& sum) .. c:function:: void columnSum(const GpuMat\& src, GpuMat\& sum)
Computes vertical (column) sum. Computes vertical (column) sum.
@ -111,7 +120,9 @@ cv::gpu::columnSum
cv::gpu::cornerHarris cv::gpu::cornerHarris
--------------------- ---------------------
.. cfunction:: void cornerHarris(const GpuMat\& src, GpuMat\& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101) .. c:function:: void cornerHarris(const GpuMat\& src, GpuMat\& dst,
int blockSize, int ksize, double k,
int borderType=BORDER_REFLECT101)
Computes Harris cornerness criteria at each image pixel. Computes Harris cornerness criteria at each image pixel.
@ -134,7 +145,9 @@ See also:
cv::gpu::cornerMinEigenVal cv::gpu::cornerMinEigenVal
-------------------------- --------------------------
.. cfunction:: void cornerMinEigenVal(const GpuMat\& src, GpuMat\& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101) .. c:function:: void cornerMinEigenVal(const GpuMat\& src, GpuMat\& dst,
int blockSize, int ksize,
int borderType=BORDER_REFLECT101)
Computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria. Computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria.
@ -157,7 +170,8 @@ See also:
cv::gpu::mulSpectrums cv::gpu::mulSpectrums
--------------------- ---------------------
.. cfunction:: void mulSpectrums(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int flags, bool conjB=false) .. c:function:: void mulSpectrums(const GpuMat\& a, const GpuMat\& b,
GpuMat\& c, int flags, bool conjB=false)
Performs per-element multiplication of two Fourier spectrums. Performs per-element multiplication of two Fourier spectrums.
@ -180,7 +194,8 @@ See also:
cv::gpu::mulAndScaleSpectrums cv::gpu::mulAndScaleSpectrums
----------------------------- -----------------------------
.. cfunction:: void mulAndScaleSpectrums(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int flags, float scale, bool conjB=false) .. c:function:: void mulAndScaleSpectrums(const GpuMat\& a, const GpuMat\& b,
GpuMat\& c, int flags, float scale, bool conjB=false)
Performs per-element multiplication of two Fourier spectrums and scales the result. Performs per-element multiplication of two Fourier spectrums and scales the result.
@ -205,7 +220,7 @@ See also:
cv::gpu::dft cv::gpu::dft
------------ ``_`` ``_`` ------------ ``_`` ``_``
.. cfunction:: void dft(const GpuMat\& src, GpuMat\& dst, Size dft_size, int flags=0) .. c:function:: void dft(const GpuMat\& src, GpuMat\& dst, Size dft_size, int flags=0)
Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Can handle real matrices (CV32FC1) and complex matrices in the interleaved format (CV32FC2). Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Can handle real matrices (CV32FC1) and complex matrices in the interleaved format (CV32FC2).
@ -215,7 +230,7 @@ cv::gpu::dft
:param dft_size: Size of discrete Fourier transform. :param dft_size: Size of discrete Fourier transform.
:param flags: Optional flags: :param flags: Optional flags:
* **DFT_ROWS** Transform each individual row of the source matrix. * **DFT_ROWS** Transform each individual row of the source matrix.
@ -224,7 +239,7 @@ cv::gpu::dft
* **DFT_INVERSE** Inverse DFT must be perfromed for complex-complex case (real-complex and complex-real cases are respectively forward and inverse always). * **DFT_INVERSE** Inverse DFT must be perfromed for complex-complex case (real-complex and complex-real cases are respectively forward and inverse always).
* **DFT_REAL_OUTPUT** The source matrix is the result of real-complex transform, so the destination matrix must be real. * **DFT_REAL_OUTPUT** The source matrix is the result of real-complex transform, so the destination matrix must be real.
The source matrix should be continuous, otherwise reallocation and data copying will be performed. Function chooses the operation mode depending on the flags, size and channel count of the source matrix: The source matrix should be continuous, otherwise reallocation and data copying will be performed. Function chooses the operation mode depending on the flags, size and channel count of the source matrix:
@ -244,9 +259,11 @@ See also:
cv::gpu::convolve cv::gpu::convolve
----------------- -----------------
.. cfunction:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result, bool ccorr=false) .. c:function:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,
bool ccorr=false)
.. cfunction:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result, bool ccorr, ConvolveBuf\& buf) .. c:function:: void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,
bool ccorr, ConvolveBuf\& buf)
Computes convolution (or cross-correlation) of two images. Computes convolution (or cross-correlation) of two images.
@ -266,7 +283,7 @@ cv::gpu::convolve
gpu::ConvolveBuf gpu::ConvolveBuf
---------------- ----------------
.. ctype:: gpu::ConvolveBuf .. c:type:: gpu::ConvolveBuf
Memory buffer for the Memory buffer for the
:func:`gpu::convolve` function. :: :func:`gpu::convolve` function. ::
@ -281,17 +298,17 @@ Memory buffer for the
private: private:
// Hidden // Hidden
}; };
..
.. index:: gpu::ConvolveBuf::ConvolveBuf .. index:: gpu::ConvolveBuf::ConvolveBuf
cv::gpu::ConvolveBuf::ConvolveBuf cv::gpu::ConvolveBuf::ConvolveBuf
--------------------------------- ---------------------------------
.. cfunction:: ConvolveBuf::ConvolveBuf() .. c:function:: ConvolveBuf::ConvolveBuf()
Constructs an empty buffer which will be properly resized after first call of the convolve function. Constructs an empty buffer which will be properly resized after first call of the convolve function.
.. cfunction:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size) .. c:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
Constructs a buffer for the convolve function with respectively arguments. Constructs a buffer for the convolve function with respectively arguments.
@ -299,7 +316,8 @@ Constructs a buffer for the convolve function with respectively arguments.
cv::gpu::matchTemplate cv::gpu::matchTemplate
---------------------- ----------------------
.. cfunction:: void matchTemplate(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result, int method) .. c:function:: void 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. Computes a proximity map for a raster template and an image where the template is searched for.
@ -307,37 +325,24 @@ cv::gpu::matchTemplate
:param templ: Template image. Must have the same size and type as ``image`` . :param templ: Template image. Must have the same size and type as ``image`` .
:param result: Map containing comparison results ( ``CV_32FC1`` ). If ``image`` is :math:`W \times H` and ``templ`` is :math:`w \times h` then ``result`` must be :math:`(W-w+1) \times (H-h+1)` . :param result: Map containing comparison results ( ``CV_32FC1`` ). If ``image`` is :math:`W \times H` and
``templ`` is :math:`w \times h` then ``result`` must be :math:`(W-w+1) \times (H-h+1)` .
:param method: Specifies the way which the template must be compared with the image. :param method: Specifies the way which the template must be compared with the image.
Following methods are supported for the ``CV_8U`` depth images for now: Following methods are supported for the ``CV_8U`` depth images for now:
* * CV_TM_SQDIFF
CV_ TM_ SQDIFF * CV_TM_SQDIFF_NORMED
* CV_TM_CCORR
* * CV_TM_CCORR_NORMED
CV_ TM_ SQDIFF_ NORMED * CV_TM_CCOEFF
* CV_TM_CCOEFF_NORMED
*
CV_ TM_ CCORR
*
CV_ TM_ CCORR_ NORMED
*
CV_ TM_ CCOEFF
*
CV_ TM_ CCOEFF_ NORMED
Following methods are supported for the ``CV_32F`` images for now: Following methods are supported for the ``CV_32F`` images for now:
* * CV_TM_SQDIFF
CV_ TM_ SQDIFF * CV_TM_CCORR
*
CV_ TM_ CCORR
See also: See also:
:func:`matchTemplate` . :func:`matchTemplate` .
@ -346,7 +351,7 @@ See also:
cv::gpu::remap cv::gpu::remap
-------------- --------------
.. cfunction:: void remap(const GpuMat\& src, GpuMat\& dst, const GpuMat\& xmap, const GpuMat\& ymap) .. c:function:: void remap(const GpuMat\& src, GpuMat\& dst, const GpuMat\& xmap, const GpuMat\& ymap)
Applies a generic geometrical transformation to an image. Applies a generic geometrical transformation to an image.
@ -362,7 +367,7 @@ The function transforms the source image using the specified map:
.. math:: .. math::
\texttt{dst} (x,y) = \texttt{src} (xmap(x,y), ymap(x,y)) \texttt{dst} (x,y) = \texttt{src} (xmap(x,y), ymap(x,y))
Values of pixels with non-integer coordinates are computed using bilinear interpolation. Values of pixels with non-integer coordinates are computed using bilinear interpolation.
@ -373,9 +378,9 @@ See also:
cv::gpu::cvtColor cv::gpu::cvtColor
----------------- -----------------
.. cfunction:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn = 0) .. c:function:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn = 0)
.. cfunction:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn, const Stream\& stream) .. c:function:: void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn, const Stream\& stream)
Converts image from one color space to another. Converts image from one color space to another.
@ -398,9 +403,9 @@ See also:
cv::gpu::threshold cv::gpu::threshold
------------------ ------------------
.. cfunction:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type) .. c:function:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type)
.. cfunction:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type, const Stream\& stream) .. c:function:: double threshold(const GpuMat\& src, GpuMat\& dst, double thresh, double maxval, int type, const Stream\& stream)
Applies a fixed-level threshold to each array element. Applies a fixed-level threshold to each array element.
@ -423,7 +428,7 @@ See also:
cv::gpu::resize cv::gpu::resize
--------------- ---------------
.. cfunction:: void resize(const GpuMat\& src, GpuMat\& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR) .. c:function:: void resize(const GpuMat\& src, GpuMat\& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR)
Resizes an image. Resizes an image.
@ -431,25 +436,28 @@ cv::gpu::resize
:param dst: Destination image. It will have size ``dsize`` (when it is non-zero) or the size computed from ``src.size()`` and ``fx`` and ``fy`` . The type of ``dst`` will be the same as of ``src`` . :param dst: Destination image. It will have size ``dsize`` (when it is non-zero) or the size computed from ``src.size()`` and ``fx`` and ``fy`` . The type of ``dst`` will be the same as of ``src`` .
:param dsize: Destination image size. If it is zero, then it is computed as: :param dsize: Destination image size. If it is zero, then it is computed as:
.. math:: .. math::
\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}
\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}
Either ``dsize`` or both ``fx`` or ``fy`` must be non-zero. Either ``dsize`` or both ``fx`` or ``fy`` must be non-zero.
:param fx: Scale factor along the horizontal axis. When 0, it is computed as :param fx: Scale factor along the horizontal axis. When 0, it is computed as
.. math:: .. math::
\texttt{(double)dsize.width/src.cols}
\texttt{(double)dsize.width/src.cols}
:param fy: Scale factor along the vertical axis. When 0, it is computed as :param fy: Scale factor along the vertical axis. When 0, it is computed as
.. math:: .. math::
\texttt{(double)dsize.height/src.rows}
\texttt{(double)dsize.height/src.rows}
:param interpolation: Interpolation method. Supports only ``INTER_NEAREST`` and ``INTER_LINEAR`` . :param interpolation: Interpolation method. Supports only ``INTER_NEAREST`` and ``INTER_LINEAR`` .
@ -460,7 +468,7 @@ See also:
cv::gpu::warpAffine cv::gpu::warpAffine
------------------- -------------------
.. cfunction:: void warpAffine(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR) .. c:function:: void warpAffine(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR)
Applies an affine transformation to an image. Applies an affine transformation to an image.
@ -481,7 +489,7 @@ See also:
cv::gpu::warpPerspective cv::gpu::warpPerspective
------------------------ ------------------------
.. cfunction:: void warpPerspective(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR) .. c:function:: void warpPerspective(const GpuMat\& src, GpuMat\& dst, const Mat\& M, Size dsize, int flags = INTER_LINEAR)
Applies a perspective transformation to an image. Applies a perspective transformation to an image.
@ -503,7 +511,7 @@ See also:
cv::gpu::rotate cv::gpu::rotate
--------------- ---------------
.. cfunction:: void rotate(const GpuMat\& src, GpuMat\& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR) .. c:function:: void rotate(const GpuMat\& src, GpuMat\& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR)
Rotates an image around the origin (0,0) and then shifts it. Rotates an image around the origin (0,0) and then shifts it.
@ -528,7 +536,7 @@ See also:
cv::gpu::copyMakeBorder cv::gpu::copyMakeBorder
----------------------- -----------------------
.. cfunction:: void copyMakeBorder(const GpuMat\& src, GpuMat\& dst, int top, int bottom, int left, int right, const Scalar\& value = Scalar()) .. c:function:: void copyMakeBorder(const GpuMat\& src, GpuMat\& dst, int top, int bottom, int left, int right, const Scalar\& value = Scalar())
Copies 2D array to a larger destination array and pads borders with the given constant. Copies 2D array to a larger destination array and pads borders with the given constant.
@ -546,7 +554,7 @@ See also:
cv::gpu::rectStdDev cv::gpu::rectStdDev
------------------- -------------------
.. cfunction:: void rectStdDev(const GpuMat\& src, const GpuMat\& sqr, GpuMat\& dst, const Rect\& rect) .. c:function:: void rectStdDev(const GpuMat\& src, const GpuMat\& sqr, GpuMat\& dst, const Rect\& rect)
Computes standard deviation of integral images. Computes standard deviation of integral images.
@ -562,7 +570,7 @@ cv::gpu::rectStdDev
cv::gpu::evenLevels cv::gpu::evenLevels
------------------- -------------------
.. cfunction:: void evenLevels(GpuMat\& levels, int nLevels, int lowerLevel, int upperLevel) .. c:function:: void evenLevels(GpuMat\& levels, int nLevels, int lowerLevel, int upperLevel)
Computes levels with even distribution. Computes levels with even distribution.
@ -578,9 +586,9 @@ cv::gpu::evenLevels
cv::gpu::histEven cv::gpu::histEven
----------------- -----------------
.. cfunction:: void histEven(const GpuMat\& src, GpuMat\& hist, int histSize, int lowerLevel, int upperLevel) .. c:function:: void histEven(const GpuMat\& src, GpuMat\& hist, int histSize, int lowerLevel, int upperLevel)
.. cfunction:: void histEven(const GpuMat\& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4]) .. c:function:: void histEven(const GpuMat\& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4])
Calculates histogram with evenly distributed bins. Calculates histogram with evenly distributed bins.
@ -598,9 +606,9 @@ cv::gpu::histEven
cv::gpu::histRange cv::gpu::histRange
------------------ ------------------
.. cfunction:: void histRange(const GpuMat\& src, GpuMat\& hist, const GpuMat\& levels) .. c:function:: void histRange(const GpuMat\& src, GpuMat\& hist, const GpuMat\& levels)
.. cfunction:: void histRange(const GpuMat\& src, GpuMat hist[4], const GpuMat levels[4]) .. c:function:: void histRange(const GpuMat\& src, GpuMat hist[4], const GpuMat levels[4])
Calculates histogram with bins determined by levels array. Calculates histogram with bins determined by levels array.

52
modules/gpu/doc/initalization_and_information.rst
View File

@ -7,7 +7,7 @@ Initalization and Information
cv::gpu::getCudaEnabledDeviceCount cv::gpu::getCudaEnabledDeviceCount
---------------------------------- ----------------------------------
.. cfunction:: int getCudaEnabledDeviceCount() .. c:function:: int getCudaEnabledDeviceCount()
Returns number of CUDA-enabled devices installed. It is to be used before any other GPU functions calls. If OpenCV is compiled without GPU support this function returns 0. Returns number of CUDA-enabled devices installed. It is to be used before any other GPU functions calls. If OpenCV is compiled without GPU support this function returns 0.
@ -15,7 +15,7 @@ cv::gpu::getCudaEnabledDeviceCount
cv::gpu::setDevice cv::gpu::setDevice
------------------ ------------------
.. cfunction:: void setDevice(int device) .. c:function:: void setDevice(int device)
Sets device and initializes it for the current thread. Call of this function can be omitted, but in this case a default device will be initialized on fist GPU usage. Sets device and initializes it for the current thread. Call of this function can be omitted, but in this case a default device will be initialized on fist GPU usage.
@ -25,7 +25,7 @@ cv::gpu::setDevice
cv::gpu::getDevice cv::gpu::getDevice
------------------ ------------------
.. cfunction:: int getDevice() .. c:function:: int getDevice()
Returns the current device index, which was set by {gpu::getDevice} or initialized by default. Returns the current device index, which was set by {gpu::getDevice} or initialized by default.
@ -35,7 +35,7 @@ cv::gpu::getDevice
gpu::GpuFeature gpu::GpuFeature
--------------- ---------------
.. ctype:: gpu::GpuFeature .. c:type:: gpu::GpuFeature
GPU compute features. :: GPU compute features. ::
@ -46,7 +46,7 @@ GPU compute features. ::
COMPUTE_20, COMPUTE_21, COMPUTE_20, COMPUTE_21,
ATOMICS, NATIVE_DOUBLE ATOMICS, NATIVE_DOUBLE
}; };
..
.. index:: gpu::DeviceInfo .. index:: gpu::DeviceInfo
@ -54,7 +54,7 @@ GPU compute features. ::
gpu::DeviceInfo gpu::DeviceInfo
--------------- ---------------
.. ctype:: gpu::DeviceInfo .. c:type:: gpu::DeviceInfo
This class provides functionality for querying the specified GPU properties. :: This class provides functionality for querying the specified GPU properties. ::
@ -77,15 +77,15 @@ This class provides functionality for querying the specified GPU properties. ::
bool supports(GpuFeature feature) const; bool supports(GpuFeature feature) const;
bool isCompatible() const; bool isCompatible() const;
}; };
..
.. index:: gpu::DeviceInfo::DeviceInfo .. index:: gpu::DeviceInfo::DeviceInfo
cv::gpu::DeviceInfo::DeviceInfo cv::gpu::DeviceInfo::DeviceInfo
------------------------------- ``_`` ------------------------------- ``_``
.. cfunction:: DeviceInfo::DeviceInfo() .. c:function:: DeviceInfo::DeviceInfo()
.. cfunction:: DeviceInfo::DeviceInfo(int device_id) .. c:function:: DeviceInfo::DeviceInfo(int device_id)
Constructs DeviceInfo object for the specified device. If deviceidparameter is missed it constructs object for the current device. Constructs DeviceInfo object for the specified device. If deviceidparameter is missed it constructs object for the current device.
@ -95,7 +95,7 @@ cv::gpu::DeviceInfo::DeviceInfo
cv::gpu::DeviceInfo::name cv::gpu::DeviceInfo::name
------------------------- -------------------------
.. cfunction:: string DeviceInfo::name() .. c:function:: string DeviceInfo::name()
Returns the device name. Returns the device name.
@ -103,7 +103,7 @@ cv::gpu::DeviceInfo::name
cv::gpu::DeviceInfo::majorVersion cv::gpu::DeviceInfo::majorVersion
--------------------------------- ---------------------------------
.. cfunction:: int DeviceInfo::majorVersion() .. c:function:: int DeviceInfo::majorVersion()
Returns the major compute capability version. Returns the major compute capability version.
@ -111,7 +111,7 @@ cv::gpu::DeviceInfo::majorVersion
cv::gpu::DeviceInfo::minorVersion cv::gpu::DeviceInfo::minorVersion
--------------------------------- ---------------------------------
.. cfunction:: int DeviceInfo::minorVersion() .. c:function:: int DeviceInfo::minorVersion()
Returns the minor compute capability version. Returns the minor compute capability version.
@ -119,7 +119,7 @@ cv::gpu::DeviceInfo::minorVersion
cv::gpu::DeviceInfo::multiProcessorCount cv::gpu::DeviceInfo::multiProcessorCount
---------------------------------------- ----------------------------------------
.. cfunction:: int DeviceInfo::multiProcessorCount() .. c:function:: int DeviceInfo::multiProcessorCount()
Returns the number of streaming multiprocessors. Returns the number of streaming multiprocessors.
@ -127,7 +127,7 @@ cv::gpu::DeviceInfo::multiProcessorCount
cv::gpu::DeviceInfo::freeMemory cv::gpu::DeviceInfo::freeMemory
------------------------------- -------------------------------
.. cfunction:: size_t DeviceInfo::freeMemory() .. c:function:: size_t DeviceInfo::freeMemory()
Returns the amount of free memory in bytes. Returns the amount of free memory in bytes.
@ -135,7 +135,7 @@ cv::gpu::DeviceInfo::freeMemory
cv::gpu::DeviceInfo::totalMemory cv::gpu::DeviceInfo::totalMemory
-------------------------------- --------------------------------
.. cfunction:: size_t DeviceInfo::totalMemory() .. c:function:: size_t DeviceInfo::totalMemory()
Returns the amount of total memory in bytes. Returns the amount of total memory in bytes.
@ -143,7 +143,7 @@ cv::gpu::DeviceInfo::totalMemory
cv::gpu::DeviceInfo::supports cv::gpu::DeviceInfo::supports
----------------------------- -----------------------------
.. cfunction:: bool DeviceInfo::supports(GpuFeature feature) .. c:function:: bool DeviceInfo::supports(GpuFeature feature)
Returns true if the device has the given GPU feature, otherwise false. Returns true if the device has the given GPU feature, otherwise false.
@ -153,7 +153,7 @@ cv::gpu::DeviceInfo::supports
cv::gpu::DeviceInfo::isCompatible cv::gpu::DeviceInfo::isCompatible
--------------------------------- ---------------------------------
.. cfunction:: bool DeviceInfo::isCompatible() .. c:function:: bool DeviceInfo::isCompatible()
Returns true if the GPU module can be run on the specified device, otherwise false. Returns true if the GPU module can be run on the specified device, otherwise false.
@ -163,32 +163,32 @@ cv::gpu::DeviceInfo::isCompatible
gpu::TargetArchs gpu::TargetArchs
---------------- ----------------
.. ctype:: gpu::TargetArchs .. c:type:: gpu::TargetArchs
This class provides functionality (as set of static methods) for checking which NVIDIA card architectures the GPU module was built for. This class provides functionality (as set of static methods) for checking which NVIDIA card architectures the GPU module was built for.
bigskip bigskip
The following method checks whether the module was built with the support of the given feature: The following method checks whether the module was built with the support of the given feature:
.. cfunction:: static bool builtWith(GpuFeature feature) .. c:function:: static bool builtWith(GpuFeature feature)
:param feature: Feature to be checked. See . :param feature: Feature to be checked. See .
There are a set of methods for checking whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s): There are a set of methods for checking whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s):
.. cfunction:: static bool has(int major, int minor) .. c:function:: static bool has(int major, int minor)
.. cfunction:: static bool hasPtx(int major, int minor) .. c:function:: static bool hasPtx(int major, int minor)
.. cfunction:: static bool hasBin(int major, int minor) .. c:function:: static bool hasBin(int major, int minor)
.. cfunction:: static bool hasEqualOrLessPtx(int major, int minor) .. c:function:: static bool hasEqualOrLessPtx(int major, int minor)
.. cfunction:: static bool hasEqualOrGreater(int major, int minor) .. c:function:: static bool hasEqualOrGreater(int major, int minor)
.. cfunction:: static bool hasEqualOrGreaterPtx(int major, int minor) .. c:function:: static bool hasEqualOrGreaterPtx(int major, int minor)
.. cfunction:: static bool hasEqualOrGreaterBin(int major, int minor) .. c:function:: static bool hasEqualOrGreaterBin(int major, int minor)
* **major** Major compute capability version. * **major** Major compute capability version.

39
modules/gpu/doc/matrix_reductions.rst
View File

@ -7,7 +7,7 @@ Matrix Reductions
cv::gpu::meanStdDev cv::gpu::meanStdDev
------------------- -------------------
.. cfunction:: void meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev) .. c:function:: void meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
Computes mean value and standard deviation of matrix elements. Computes mean value and standard deviation of matrix elements.
@ -24,7 +24,7 @@ See also:
cv::gpu::norm cv::gpu::norm
------------- -------------
.. cfunction:: double norm(const GpuMat\& src, int normType=NORM_L2) .. c:function:: double norm(const GpuMat\& src, int normType=NORM_L2)
Returns norm of matrix (or of two matrices difference). Returns norm of matrix (or of two matrices difference).
@ -32,7 +32,7 @@ cv::gpu::norm
:param normType: Norm type. ``NORM_L1`` , ``NORM_L2`` and ``NORM_INF`` are supported for now. :param normType: Norm type. ``NORM_L1`` , ``NORM_L2`` and ``NORM_INF`` are supported for now.
.. cfunction:: double norm(const GpuMat\& src, int normType, GpuMat\& buf) .. c:function:: double norm(const GpuMat\& src, int normType, GpuMat\& buf)
* **src** Source matrix. Any matrices except 64F are supported. * **src** Source matrix. Any matrices except 64F are supported.
@ -40,7 +40,8 @@ cv::gpu::norm
* **buf** Optional buffer to avoid extra memory allocations. It's resized automatically. * **buf** Optional buffer to avoid extra memory allocations. It's resized automatically.
.. cfunction:: double norm(const GpuMat\& src1, const GpuMat\& src2, int normType=NORM_L2) .. c:function:: double norm(const GpuMat\& src1, const GpuMat\& src2,
int normType=NORM_L2)
* **src1** First source matrix. ``CV_8UC1`` matrices are supported for now. * **src1** First source matrix. ``CV_8UC1`` matrices are supported for now.
@ -56,9 +57,9 @@ See also:
cv::gpu::sum cv::gpu::sum
------------ ------------
.. cfunction:: Scalar sum(const GpuMat\& src) .. c:function:: Scalar sum(const GpuMat\& src)
.. cfunction:: Scalar sum(const GpuMat\& src, GpuMat\& buf) .. c:function:: Scalar sum(const GpuMat\& src, GpuMat\& buf)
Returns sum of matrix elements. Returns sum of matrix elements.
@ -73,9 +74,9 @@ See also:
cv::gpu::absSum cv::gpu::absSum
--------------- ---------------
.. cfunction:: Scalar absSum(const GpuMat\& src) .. c:function:: Scalar absSum(const GpuMat\& src)
.. cfunction:: Scalar absSum(const GpuMat\& src, GpuMat\& buf) .. c:function:: Scalar absSum(const GpuMat\& src, GpuMat\& buf)
Returns sum of matrix elements absolute values. Returns sum of matrix elements absolute values.
@ -87,9 +88,9 @@ cv::gpu::absSum
cv::gpu::sqrSum cv::gpu::sqrSum
--------------- ---------------
.. cfunction:: Scalar sqrSum(const GpuMat\& src) .. c:function:: Scalar sqrSum(const GpuMat\& src)
.. cfunction:: Scalar sqrSum(const GpuMat\& src, GpuMat\& buf) .. c:function:: Scalar sqrSum(const GpuMat\& src, GpuMat\& buf)
Returns squared sum of matrix elements. Returns squared sum of matrix elements.
@ -101,9 +102,11 @@ cv::gpu::sqrSum
cv::gpu::minMax cv::gpu::minMax
--------------- ---------------
.. cfunction:: void minMax(const GpuMat\& src, double* minVal, double* maxVal=0, const GpuMat\& mask=GpuMat()) .. c:function:: void minMax(const GpuMat\& src, double* minVal,
double* maxVal=0, const GpuMat\& mask=GpuMat())
.. cfunction:: void minMax(const GpuMat\& src, double* minVal, double* maxVal, const GpuMat\& mask, GpuMat\& buf) .. c:function:: void minMax(const GpuMat\& src, double* minVal, double* maxVal,
const GpuMat\& mask, GpuMat\& buf)
Finds global minimum and maximum matrix elements and returns their values. Finds global minimum and maximum matrix elements and returns their values.
@ -126,9 +129,13 @@ See also:
cv::gpu::minMaxLoc cv::gpu::minMaxLoc
------------------ ------------------
.. cfunction:: void minMaxLoc(const GpuMat\& src, double\* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const GpuMat\& mask=GpuMat()) .. c:function:: void minMaxLoc(const GpuMat\& src, double\* minVal, double* maxVal=0,
Point* minLoc=0, Point* maxLoc=0,
const GpuMat\& mask=GpuMat())
.. cfunction:: void minMaxLoc(const GpuMat\& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat\& mask, GpuMat\& valbuf, GpuMat\& locbuf) .. c:function:: void minMaxLoc(const GpuMat\& src, double* minVal, double* maxVal,
Point* minLoc, Point* maxLoc, const GpuMat\& mask,
GpuMat\& valbuf, GpuMat\& locbuf)
Finds global minimum and maximum matrix elements and returns their values with locations. Finds global minimum and maximum matrix elements and returns their values with locations.
@ -157,9 +164,9 @@ See also:
cv::gpu::countNonZero cv::gpu::countNonZero
--------------------- ---------------------
.. cfunction:: int countNonZero(const GpuMat\& src) .. c:function:: int countNonZero(const GpuMat\& src)
.. cfunction:: int countNonZero(const GpuMat\& src, GpuMat\& buf) .. c:function:: int countNonZero(const GpuMat\& src, GpuMat\& buf)
Counts non-zero matrix elements. Counts non-zero matrix elements.

56
modules/gpu/doc/object_detection.rst
View File

@ -9,7 +9,7 @@ Object Detection
gpu::HOGDescriptor gpu::HOGDescriptor
------------------ ------------------
.. ctype:: gpu::HOGDescriptor .. c:type:: gpu::HOGDescriptor
Histogram of Oriented Gradients Histogram of Oriented Gradients
dalal_hog dalal_hog
@ -62,7 +62,7 @@ descriptor and detector. ::
private: private:
// Hidden // Hidden
} }
..
Interfaces of all methods are kept similar to CPU HOG descriptor and detector analogues as much as possible. Interfaces of all methods are kept similar to CPU HOG descriptor and detector analogues as much as possible.
@ -70,7 +70,12 @@ Interfaces of all methods are kept similar to CPU HOG descriptor and detector an
cv::gpu::HOGDescriptor::HOGDescriptor cv::gpu::HOGDescriptor::HOGDescriptor
------------------------------------- -------------------------------------
.. cfunction:: HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16), Size block_stride=Size(8, 8), Size cell_size=Size(8, 8), int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA, double threshold_L2hys=0.2, bool gamma_correction=true, int nlevels=DEFAULT_NLEVELS) .. c:function:: HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128),
Size block_size=Size(16, 16), Size block_stride=Size(8, 8),
Size cell_size=Size(8, 8), int nbins=9,
double win_sigma=DEFAULT_WIN_SIGMA,
double threshold_L2hys=0.2, bool gamma_correction=true,
int nlevels=DEFAULT_NLEVELS)
Creates HOG descriptor and detector. Creates HOG descriptor and detector.
@ -96,7 +101,7 @@ cv::gpu::HOGDescriptor::HOGDescriptor
cv::gpu::HOGDescriptor::getDescriptorSize cv::gpu::HOGDescriptor::getDescriptorSize
----------------------------------------- -----------------------------------------
.. cfunction:: size_t HOGDescriptor::getDescriptorSize() const .. c:function:: size_t HOGDescriptor::getDescriptorSize() const
Returns number of coefficients required for the classification. Returns number of coefficients required for the classification.
@ -104,7 +109,7 @@ cv::gpu::HOGDescriptor::getDescriptorSize
cv::gpu::HOGDescriptor::getBlockHistogramSize cv::gpu::HOGDescriptor::getBlockHistogramSize
--------------------------------------------- ---------------------------------------------
.. cfunction:: size_t HOGDescriptor::getBlockHistogramSize() const .. c:function:: size_t HOGDescriptor::getBlockHistogramSize() const
Returns block histogram size. Returns block histogram size.
@ -112,7 +117,7 @@ cv::gpu::HOGDescriptor::getBlockHistogramSize
cv::gpu::HOGDescriptor::setSVMDetector cv::gpu::HOGDescriptor::setSVMDetector
-------------------------------------- --------------------------------------
.. cfunction:: void HOGDescriptor::setSVMDetector(const vector<float>\& detector) .. c:function:: void HOGDescriptor::setSVMDetector(const vector<float>\& detector)
Sets coefficients for the linear SVM classifier. Sets coefficients for the linear SVM classifier.
@ -120,7 +125,7 @@ cv::gpu::HOGDescriptor::setSVMDetector
cv::gpu::HOGDescriptor::getDefaultPeopleDetector cv::gpu::HOGDescriptor::getDefaultPeopleDetector
------------------------------------------------ ------------------------------------------------
.. cfunction:: static vector<float> HOGDescriptor::getDefaultPeopleDetector() .. c:function:: static vector<float> HOGDescriptor::getDefaultPeopleDetector()
Returns coefficients of the classifier trained for people detection (for default window size). Returns coefficients of the classifier trained for people detection (for default window size).
@ -128,7 +133,7 @@ cv::gpu::HOGDescriptor::getDefaultPeopleDetector
cv::gpu::HOGDescriptor::getPeopleDetector48x96 cv::gpu::HOGDescriptor::getPeopleDetector48x96
---------------------------------------------- ----------------------------------------------
.. cfunction:: static vector<float> HOGDescriptor::getPeopleDetector48x96() .. c:function:: static vector<float> HOGDescriptor::getPeopleDetector48x96()
Returns coefficients of the classifier trained for people detection (for 48x96 windows). Returns coefficients of the classifier trained for people detection (for 48x96 windows).
@ -136,7 +141,7 @@ cv::gpu::HOGDescriptor::getPeopleDetector48x96
cv::gpu::HOGDescriptor::getPeopleDetector64x128 cv::gpu::HOGDescriptor::getPeopleDetector64x128
----------------------------------------------- -----------------------------------------------
.. cfunction:: static vector<float> HOGDescriptor::getPeopleDetector64x128() .. c:function:: static vector<float> HOGDescriptor::getPeopleDetector64x128()
Returns coefficients of the classifier trained for people detection (for 64x128 windows). Returns coefficients of the classifier trained for people detection (for 64x128 windows).
@ -144,7 +149,9 @@ cv::gpu::HOGDescriptor::getPeopleDetector64x128
cv::gpu::HOGDescriptor::detect cv::gpu::HOGDescriptor::detect
------------------------------ ------------------------------
.. cfunction:: void HOGDescriptor::detect(const GpuMat\& img, vector<Point>\& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size()) .. c:function:: void HOGDescriptor::detect(const GpuMat\& img,
vector<Point>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size())
Perfroms object detection without multiscale window. Perfroms object detection without multiscale window.
@ -162,7 +169,10 @@ cv::gpu::HOGDescriptor::detect
cv::gpu::HOGDescriptor::detectMultiScale cv::gpu::HOGDescriptor::detectMultiScale
---------------------------------------- ----------------------------------------
.. cfunction:: void HOGDescriptor::detectMultiScale(const GpuMat\& img, vector<Rect>\& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size(), double scale0=1.05, int group_threshold=2) .. c:function:: void HOGDescriptor::detectMultiScale(const GpuMat\& img,
vector<Rect>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size(),
double scale0=1.05, int group_threshold=2)
Perfroms object detection with multiscale window. Perfroms object detection with multiscale window.
@ -185,7 +195,9 @@ cv::gpu::HOGDescriptor::detectMultiScale
cv::gpu::HOGDescriptor::getDescriptors cv::gpu::HOGDescriptor::getDescriptors
-------------------------------------- --------------------------------------
.. cfunction:: void HOGDescriptor::getDescriptors(const GpuMat\& img, Size win_stride, GpuMat\& descriptors, int descr_format=DESCR_FORMAT_COL_BY_COL) .. c:function:: void HOGDescriptor::getDescriptors(const GpuMat\& img,
Size win_stride, GpuMat\& descriptors,
int descr_format=DESCR_FORMAT_COL_BY_COL)
Returns block descriptors computed for the whole image. It's mainly used for classifier learning purposes. Returns block descriptors computed for the whole image. It's mainly used for classifier learning purposes.
@ -195,12 +207,12 @@ cv::gpu::HOGDescriptor::getDescriptors
:param descriptors: 2D array of descriptors. :param descriptors: 2D array of descriptors.
:param descr_format: Descriptor storage format: :param descr_format: Descriptor storage format:
* **DESCR_FORMAT_ROW_BY_ROW** Row-major order. * **DESCR_FORMAT_ROW_BY_ROW** Row-major order.
* **DESCR_FORMAT_COL_BY_COL** Column-major order. * **DESCR_FORMAT_COL_BY_COL** Column-major order.
.. index:: gpu::CascadeClassifier_GPU .. index:: gpu::CascadeClassifier_GPU
@ -208,7 +220,7 @@ cv::gpu::HOGDescriptor::getDescriptors
gpu::CascadeClassifier_GPU gpu::CascadeClassifier_GPU
-------------------------- --------------------------
.. ctype:: gpu::CascadeClassifier_GPU .. c:type:: gpu::CascadeClassifier_GPU
The cascade classifier class for object detection. :: The cascade classifier class for object detection. ::
@ -234,7 +246,7 @@ The cascade classifier class for object detection. ::
Size getClassifierSize() const; Size getClassifierSize() const;
}; };
..
.. index:: cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU .. index:: cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
@ -242,7 +254,7 @@ The cascade classifier class for object detection. ::
cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
----------------------------------------------------- -----------------------------------------------------
.. cfunction:: cv::CascadeClassifier_GPU(const string\& filename) .. c:function:: cv::CascadeClassifier_GPU(const string\& filename)
Loads the classifier from file. Loads the classifier from file.
@ -254,7 +266,7 @@ cv::gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
cv::gpu::CascadeClassifier_GPU::empty cv::gpu::CascadeClassifier_GPU::empty
------------------------------------- -------------------------------------
.. cfunction:: bool CascadeClassifier_GPU::empty() const .. c:function:: bool CascadeClassifier_GPU::empty() const
Checks if the classifier has been loaded or not. Checks if the classifier has been loaded or not.
@ -264,7 +276,7 @@ cv::gpu::CascadeClassifier_GPU::empty
cv::gpu::CascadeClassifier_GPU::load cv::gpu::CascadeClassifier_GPU::load
------------------------------------ ------------------------------------
.. cfunction:: bool CascadeClassifier_GPU::load(const string\& filename) .. c:function:: bool CascadeClassifier_GPU::load(const string\& filename)
Loads the classifier from file. The previous content is destroyed. Loads the classifier from file. The previous content is destroyed.
@ -276,7 +288,7 @@ cv::gpu::CascadeClassifier_GPU::load
cv::gpu::CascadeClassifier_GPU::release cv::gpu::CascadeClassifier_GPU::release
--------------------------------------- ---------------------------------------
.. cfunction:: void CascadeClassifier_GPU::release() .. c:function:: void CascadeClassifier_GPU::release()
Destroys loaded classifier. Destroys loaded classifier.
@ -286,7 +298,7 @@ cv::gpu::CascadeClassifier_GPU::release
cv::gpu::CascadeClassifier_GPU::detectMultiScale cv::gpu::CascadeClassifier_GPU::detectMultiScale
------------------------------------------------ ------------------------------------------------
.. cfunction:: int CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size()) .. c:function:: int CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles. Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
@ -320,7 +332,7 @@ The function returns number of detected objects, so you can retrieve them as in
cv::rectangle(image_cpu, faces[i], Scalar(255)); cv::rectangle(image_cpu, faces[i], Scalar(255));
imshow("Faces", image_cpu); imshow("Faces", image_cpu);
..
See also: See also:
:func:`CascadeClassifier::detectMultiScale` . :func:`CascadeClassifier::detectMultiScale` .

68
modules/gpu/doc/operations_on_matrices.rst
View File

@ -7,7 +7,7 @@ Operations on Matrices
cv::gpu::transpose cv::gpu::transpose
------------------ ------------------
.. cfunction:: void transpose(const GpuMat\& src, GpuMat\& dst) .. c:function:: void transpose(const GpuMat\& src, GpuMat\& dst)
Transposes a matrix. Transposes a matrix.
@ -22,7 +22,7 @@ See also:
cv::gpu::flip cv::gpu::flip
------------- -------------
.. cfunction:: void flip(const GpuMat\& a, GpuMat\& b, int flipCode) .. c:function:: void flip(const GpuMat\& a, GpuMat\& b, int flipCode)
Flips a 2D matrix around vertical, horizontal or both axes. Flips a 2D matrix around vertical, horizontal or both axes.
@ -30,14 +30,14 @@ cv::gpu::flip
:param b: Destination matrix. :param b: Destination matrix.
:param flipCode: Specifies how to flip the source: :param flipCode: Specifies how to flip the source:
* **0** Flip around x-axis. * **0** Flip around x-axis.
* **:math:`>`0** Flip around y-axis. * **:math:`>`0** Flip around y-axis.
* **:math:`<`0** Flip around both axes. * **:math:`<`0** Flip around both axes.
See also: See also:
:func:`flip` . :func:`flip` .
@ -50,7 +50,7 @@ cv::gpu::LUT
dst(I) = lut(src(I)) dst(I) = lut(src(I))
.. cfunction:: void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst) .. c:function:: void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst)
Transforms the source matrix into the destination matrix using given look-up table: Transforms the source matrix into the destination matrix using given look-up table:
@ -67,9 +67,10 @@ See also:
cv::gpu::merge cv::gpu::merge
-------------- --------------
.. cfunction:: void merge(const GpuMat* src, size_t n, GpuMat\& dst) .. c:function:: void merge(const GpuMat* src, size_t n, GpuMat\& dst)
.. cfunction:: void merge(const GpuMat* src, size_t n, GpuMat\& dst, const Stream\& stream) .. c:function:: void merge(const GpuMat* src, size_t n, GpuMat\& dst,
const Stream\& stream)
Makes a multi-channel matrix out of several single-channel matrices. Makes a multi-channel matrix out of several single-channel matrices.
@ -81,9 +82,10 @@ cv::gpu::merge
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
.. cfunction:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst) .. c:function:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst)
.. cfunction:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst, const Stream\& stream) .. c:function:: void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst,
const Stream\& stream)
* **src** Vector of the source matrices. * **src** Vector of the source matrices.
@ -98,9 +100,9 @@ See also:
cv::gpu::split cv::gpu::split
-------------- --------------
.. cfunction:: void split(const GpuMat\& src, GpuMat* dst) .. c:function:: void split(const GpuMat\& src, GpuMat* dst)
.. cfunction:: void split(const GpuMat\& src, GpuMat* dst, const Stream\& stream) .. c:function:: void split(const GpuMat\& src, GpuMat* dst, const Stream\& stream)
Copies each plane of a multi-channel matrix into an array. Copies each plane of a multi-channel matrix into an array.
@ -110,9 +112,10 @@ cv::gpu::split
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
.. cfunction:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst) .. c:function:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst)
.. cfunction:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst, const Stream\& stream) .. c:function:: void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst,
const Stream\& stream)
* **src** Source matrix. * **src** Source matrix.
@ -127,7 +130,7 @@ See also:
cv::gpu::magnitude cv::gpu::magnitude
------------------ ------------------
.. cfunction:: void magnitude(const GpuMat\& x, GpuMat\& magnitude) .. c:function:: void magnitude(const GpuMat\& x, GpuMat\& magnitude)
Computes magnitudes of complex matrix elements. Computes magnitudes of complex matrix elements.
@ -135,9 +138,10 @@ cv::gpu::magnitude
:param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ). :param magnitude: Destination matrix of float magnitudes ( ``CV_32FC1`` ).
.. cfunction:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude) .. c:function:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude)
.. cfunction:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude, const Stream\& stream) .. c:function:: void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
const Stream\& stream)
* **x** Source matrix, containing real components ( ``CV_32FC1`` ). * **x** Source matrix, containing real components ( ``CV_32FC1`` ).
@ -154,7 +158,7 @@ See also:
cv::gpu::magnitudeSqr cv::gpu::magnitudeSqr
--------------------- ---------------------
.. cfunction:: void magnitudeSqr(const GpuMat\& x, GpuMat\& magnitude) .. c:function:: void magnitudeSqr(const GpuMat\& x, GpuMat\& magnitude)
Computes squared magnitudes of complex matrix elements. Computes squared magnitudes of complex matrix elements.
@ -162,9 +166,10 @@ cv::gpu::magnitudeSqr
:param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ). :param magnitude: Destination matrix of float magnitude squares ( ``CV_32FC1`` ).
.. cfunction:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude) .. c:function:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude)
.. cfunction:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude, const Stream\& stream) .. c:function:: void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
const Stream\& stream)
* **x** Source matrix, containing real components ( ``CV_32FC1`` ). * **x** Source matrix, containing real components ( ``CV_32FC1`` ).
@ -178,9 +183,11 @@ cv::gpu::magnitudeSqr
cv::gpu::phase cv::gpu::phase
-------------- --------------
.. cfunction:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle, bool angleInDegrees=false) .. c:function:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,
bool angleInDegrees=false)
.. cfunction:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle, bool angleInDegrees, const Stream\& stream) .. c:function:: void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,
bool angleInDegrees, const Stream\& stream)
Computes polar angles of complex matrix elements. Computes polar angles of complex matrix elements.
@ -201,9 +208,11 @@ See also:
cv::gpu::cartToPolar cv::gpu::cartToPolar
-------------------- --------------------
.. cfunction:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude, GpuMat\& angle, bool angleInDegrees=false) .. c:function:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
GpuMat\& angle, bool angleInDegrees=false)
.. cfunction:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude, GpuMat\& angle, bool angleInDegrees, const Stream\& stream) .. c:function:: void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,
GpuMat\& angle, bool angleInDegrees, const Stream\& stream)
Converts Cartesian coordinates into polar. Converts Cartesian coordinates into polar.
@ -226,9 +235,12 @@ See also:
cv::gpu::polarToCart cv::gpu::polarToCart
-------------------- --------------------
.. cfunction:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle, GpuMat\& x, GpuMat\& y, bool angleInDegrees=false) .. c:function:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,
GpuMat\& x, GpuMat\& y, bool angleInDegrees=false)
.. cfunction:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle, GpuMat\& x, GpuMat\& y, bool angleInDegrees, const Stream\& stream) .. c:function:: void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,
GpuMat\& x, GpuMat\& y, bool angleInDegrees,
const Stream\& stream)
Converts polar coordinates into Cartesian. Converts polar coordinates into Cartesian.

88
modules/gpu/doc/per_element_operations..rst
View File

@ -7,7 +7,7 @@ Per-element Operations.
cv::gpu::add cv::gpu::add
------------ ------------
.. cfunction:: void add(const GpuMat\& a, const GpuMat\& b, GpuMat\& c) .. c:function:: void add(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes matrix-matrix or matrix-scalar sum. Computes matrix-matrix or matrix-scalar sum.
@ -17,7 +17,7 @@ cv::gpu::add
:param c: Destination matrix. Will have the same size and type as ``a`` . :param c: Destination matrix. Will have the same size and type as ``a`` .
.. cfunction:: void add(const GpuMat\& a, const Scalar\& sc, GpuMat\& c) .. c:function:: void add(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now. * **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@ -32,7 +32,7 @@ See also:
cv::gpu::subtract cv::gpu::subtract
----------------- -----------------
.. cfunction:: void subtract(const GpuMat\& a, const GpuMat\& b, GpuMat\& c) .. c:function:: void subtract(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Subtracts matrix from another matrix (or scalar from matrix). Subtracts matrix from another matrix (or scalar from matrix).
@ -42,7 +42,7 @@ cv::gpu::subtract
:param c: Destination matrix. Will have the same size and type as ``a`` . :param c: Destination matrix. Will have the same size and type as ``a`` .
.. cfunction:: void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c) .. c:function:: void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now. * **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@ -57,7 +57,7 @@ See also:
cv::gpu::multiply cv::gpu::multiply
----------------- -----------------
.. cfunction:: void multiply(const GpuMat\& a, const GpuMat\& b, GpuMat\& c) .. c:function:: void multiply(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes per-element product of two matrices (or of matrix and scalar). Computes per-element product of two matrices (or of matrix and scalar).
@ -67,7 +67,7 @@ cv::gpu::multiply
:param c: Destionation matrix. Will have the same size and type as ``a`` . :param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void multiply(const GpuMat\& a, const Scalar\& sc, GpuMat\& c) .. c:function:: void multiply(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now. * **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@ -82,7 +82,7 @@ See also:
cv::gpu::divide cv::gpu::divide
--------------- ---------------
.. cfunction:: void divide(const GpuMat\& a, const GpuMat\& b, GpuMat\& c) .. c:function:: void divide(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Performs per-element division of two matrices (or division of matrix by scalar). Performs per-element division of two matrices (or division of matrix by scalar).
@ -92,7 +92,7 @@ cv::gpu::divide
:param c: Destionation matrix. Will have the same size and type as ``a`` . :param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void divide(const GpuMat\& a, const Scalar\& sc, GpuMat\& c) .. c:function:: void divide(const GpuMat\& a, const Scalar\& sc, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now. * **a** Source matrix. ``CV_32FC1`` and ``CV_32FC2`` matrixes are supported for now.
@ -110,7 +110,7 @@ See also:
cv::gpu::exp cv::gpu::exp
------------ ------------
.. cfunction:: void exp(const GpuMat\& a, GpuMat\& b) .. c:function:: void exp(const GpuMat\& a, GpuMat\& b)
Computes exponent of each matrix element. Computes exponent of each matrix element.
@ -125,7 +125,7 @@ See also:
cv::gpu::log cv::gpu::log
------------ ------------
.. cfunction:: void log(const GpuMat\& a, GpuMat\& b) .. c:function:: void log(const GpuMat\& a, GpuMat\& b)
Computes natural logarithm of absolute value of each matrix element. Computes natural logarithm of absolute value of each matrix element.
@ -140,7 +140,7 @@ See also:
cv::gpu::absdiff cv::gpu::absdiff
---------------- ----------------
.. cfunction:: void absdiff(const GpuMat\& a, const GpuMat\& b, GpuMat\& c) .. c:function:: void absdiff(const GpuMat\& a, const GpuMat\& b, GpuMat\& c)
Computes per-element absolute difference of two matrices (or of matrix and scalar). Computes per-element absolute difference of two matrices (or of matrix and scalar).
@ -150,7 +150,7 @@ cv::gpu::absdiff
:param c: Destionation matrix. Will have the same size and type as ``a`` . :param c: Destionation matrix. Will have the same size and type as ``a`` .
.. cfunction:: void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c) .. c:function:: void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c)
* **a** Source matrix. ``CV_32FC1`` matrixes are supported for now. * **a** Source matrix. ``CV_32FC1`` matrixes are supported for now.
@ -165,7 +165,7 @@ See also:
cv::gpu::compare cv::gpu::compare
---------------- ----------------
.. cfunction:: void compare(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int cmpop) .. c:function:: void compare(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int cmpop)
Compares elements of two matrices. Compares elements of two matrices.
@ -175,15 +175,15 @@ cv::gpu::compare
:param c: Destination matrix. Will have the same size as ``a`` and be ``CV_8UC1`` type. :param c: Destination matrix. Will have the same size as ``a`` and be ``CV_8UC1`` type.
:param cmpop: Flag specifying the relation between the elements to be checked: :param cmpop: Flag specifying the relation between the elements to be checked:
* **CMP_EQ** :math:`=` * **CMP_EQ** :math:`=`
* **CMP_GT** :math:`>` * **CMP_GT** :math:`>`
* **CMP_GE** :math:`\ge` * **CMP_GE** :math:`\ge`
* **CMP_LT** :math:`<` * **CMP_LT** :math:`<`
* **CMP_LE** :math:`\le` * **CMP_LE** :math:`\le`
* **CMP_NE** :math:`\ne` * **CMP_NE** :math:`\ne`
See also: See also:
:func:`compare` . :func:`compare` .
@ -194,9 +194,11 @@ See also:
cv::gpu::bitwise_not cv::gpu::bitwise_not
-------------------- --------------------
.. cfunction:: void bitwise_not(const GpuMat\& src, GpuMat\& dst, const GpuMat\& mask=GpuMat()) .. c:function:: void bitwise_not(const GpuMat\& src, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. cfunction:: void bitwise_not(const GpuMat\& src, GpuMat\& dst, const GpuMat\& mask, const Stream\& stream) .. c:function:: void bitwise_not(const GpuMat\& src, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise inversion. Performs per-element bitwise inversion.
@ -217,9 +219,11 @@ See also:
cv::gpu::bitwise_or cv::gpu::bitwise_or
------------------- -------------------
.. cfunction:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask=GpuMat()) .. c:function:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. cfunction:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask, const Stream\& stream) .. c:function:: void bitwise_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise disjunction of two matrices. Performs per-element bitwise disjunction of two matrices.
@ -242,9 +246,11 @@ See also:
cv::gpu::bitwise_and cv::gpu::bitwise_and
-------------------- --------------------
.. cfunction:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask=GpuMat()) .. c:function:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. cfunction:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask, const Stream\& stream) .. c:function:: void bitwise_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise conjunction of two matrices. Performs per-element bitwise conjunction of two matrices.
@ -267,9 +273,11 @@ See also:
cv::gpu::bitwise_xor cv::gpu::bitwise_xor
-------------------- --------------------
.. cfunction:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask=GpuMat()) .. c:function:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask=GpuMat())
.. cfunction:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const GpuMat\& mask, const Stream\& stream) .. c:function:: void bitwise_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const GpuMat\& mask, const Stream\& stream)
Performs per-element bitwise "exclusive or" of two matrices. Performs per-element bitwise "exclusive or" of two matrices.
@ -290,9 +298,10 @@ See also:
cv::gpu::min cv::gpu::min
------------ ------------
.. cfunction:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst) .. c:function:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst)
.. cfunction:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const Stream\& stream) .. c:function:: void min(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const Stream\& stream)
Computes per-element minimum of two matrices (or of matrix and scalar). Computes per-element minimum of two matrices (or of matrix and scalar).
@ -304,9 +313,10 @@ cv::gpu::min
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
.. cfunction:: void min(const GpuMat\& src1, double src2, GpuMat\& dst) .. c:function:: void min(const GpuMat\& src1, double src2, GpuMat\& dst)
.. cfunction:: void min(const GpuMat\& src1, double src2, GpuMat\& dst, const Stream\& stream) .. c:function:: void min(const GpuMat\& src1, double src2, GpuMat\& dst,
const Stream\& stream)
* **src1** Source matrix. * **src1** Source matrix.
@ -323,9 +333,10 @@ See also:
cv::gpu::max cv::gpu::max
------------ ------------
.. cfunction:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst) .. c:function:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst)
.. cfunction:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst, const Stream\& stream) .. c:function:: void max(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,
const Stream\& stream)
Computes per-element maximum of two matrices (or of matrix and scalar). Computes per-element maximum of two matrices (or of matrix and scalar).
@ -337,9 +348,10 @@ cv::gpu::max
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
.. cfunction:: void max(const GpuMat\& src1, double src2, GpuMat\& dst) .. c:function:: void max(const GpuMat\& src1, double src2, GpuMat\& dst)
.. cfunction:: void max(const GpuMat\& src1, double src2, GpuMat\& dst, const Stream\& stream) .. c:function:: void max(const GpuMat\& src1, double src2, GpuMat\& dst,
const Stream\& stream)
* **src1** Source matrix. * **src1** Source matrix.

27
modules/highgui/doc/highgui__high-level_gui_and_media_i_o.rst
View File

@ -1,27 +0,0 @@
*************************************
highgui. High-level GUI and Media I/O
*************************************
While OpenCV was designed for use in full-scale
applications and can be used within functionally rich UI frameworks (such as Qt, WinForms or Cocoa) or without any UI at all, sometimes there is a need to try some functionality quickly and visualize the results. This is what the HighGUI module has been designed for.
It provides easy interface to:
*
create and manipulate windows that can display images and "remember" their content (no need to handle repaint events from OS)
*
add trackbars to the windows, handle simple mouse events as well as keyboard commmands
*
read and write images to/from disk or memory.
*
read video from camera or file and write video to a file.
.. toctree::
:maxdepth: 2
highgui_user_interface
highgui_reading_and_writing_images_and_video
highgui_qt_new_functions

116
modules/highgui/doc/qt_new_functions.rst
View File

@ -8,7 +8,7 @@ Qt new functions
This figure explains the new functionalities implemented with Qt GUI. As we can see, the new GUI provides a statusbar, a toolbar, and a control panel. The control panel can have trackbars and buttonbars attached to it. This figure explains the new functionalities implemented with Qt GUI. As we can see, the new GUI provides a statusbar, a toolbar, and a control panel. The control panel can have trackbars and buttonbars attached to it.
* *
To attach a trackbar, the window_ name parameter must be NULL. To attach a trackbar, the window name parameter must be NULL.
* *
To attach a buttonbar, a button must be created. To attach a buttonbar, a button must be created.
@ -56,60 +56,59 @@ The following code is an example used to generate the figure. ::
cvReleaseCapture(&video); cvReleaseCapture(&video);
return 0; return 0;
} }
..
.. index:: setWindowProperty .. index:: setWindowProperty
cv::setWindowProperty setWindowProperty
--------------------- ---------------------
.. cfunction:: void setWindowProperty(const string\& name, int prop_id, double prop_value) .. c:function:: void setWindowProperty(const string& name, int prop_id, double prop_value)
Change the parameters of the window dynamically. Change the parameters of the window dynamically.
:param name: Name of the window. :param name: Name of the window.
:param prop_id: Window's property to edit. The operation flags: :param prop_id: Window's property to edit. The operation flags:
* **CV_WND_PROP_FULLSCREEN** Change if the window is fullscreen ( ``CV_WINDOW_NORMAL`` or ``CV_WINDOW_FULLSCREEN`` ). * **CV_WND_PROP_FULLSCREEN** Change if the window is fullscreen ( ``CV_WINDOW_NORMAL`` or ``CV_WINDOW_FULLSCREEN`` ).
* **CV_WND_PROP_AUTOSIZE** Change if the user can resize the window (texttt {CV\_WINDOW\_NORMAL} or ``CV_WINDOW_AUTOSIZE`` ). * **CV_WND_PROP_AUTOSIZE** Change if the user can resize the window (texttt {CV\_WINDOW\_NORMAL} or ``CV_WINDOW_AUTOSIZE`` ).
* **CV_WND_PROP_ASPECTRATIO** Change if the image's aspect ratio is preserved (texttt {CV\_WINDOW\_FREERATIO} or ``CV_WINDOW_KEEPRATIO`` ). * **CV_WND_PROP_ASPECTRATIO** Change if the image's aspect ratio is preserved (texttt {CV\_WINDOW\_FREERATIO} or ``CV_WINDOW_KEEPRATIO`` ).
:param prop_value: New value of the Window's property. The operation flags: :param prop_value: New value of the Window's property. The operation flags:
* **CV_WINDOW_NORMAL** Change the window in normal size, or allows the user to resize the window. * **CV_WINDOW_NORMAL** Change the window in normal size, or allows the user to resize the window.
* **CV_WINDOW_AUTOSIZE** The user cannot resize the window, the size is constrainted by the image displayed. * **CV_WINDOW_AUTOSIZE** The user cannot resize the window, the size is constrainted by the image displayed.
* **CV_WINDOW_FULLSCREEN** Change the window to fullscreen. * **CV_WINDOW_FULLSCREEN** Change the window to fullscreen.
* **CV_WINDOW_FREERATIO** The image expends as much as it can (no ratio constraint) * **CV_WINDOW_FREERATIO** The image expends as much as it can (no ratio constraint)
* **CV_WINDOW_KEEPRATIO** The ration image is respected. * **CV_WINDOW_KEEPRATIO** The ration image is respected.
The function `` setWindowProperty`` allows to change the window's properties. The function `` setWindowProperty`` allows to change the window's properties.
.. index:: getWindowProperty .. index:: getWindowProperty
cv::getWindowProperty getWindowProperty
--------------------- ---------------------
.. cfunction:: void getWindowProperty(const char* name, int prop_id) .. c:function:: void getWindowProperty(const char* name, int prop_id)
Get the parameters of the window. Get the parameters of the window.
:param name: Name of the window. :param name: Name of the window.
:param prop_id: Window's property to retrive. The operation flags: :param prop_id: Window's property to retrive. The operation flags:
* **CV_WND_PROP_FULLSCREEN** Change if the window is fullscreen ( ``CV_WINDOW_NORMAL`` or ``CV_WINDOW_FULLSCREEN`` ). * **CV_WND_PROP_FULLSCREEN** Change if the window is fullscreen ( ``CV_WINDOW_NORMAL`` or ``CV_WINDOW_FULLSCREEN`` ).
* **CV_WND_PROP_AUTOSIZE** Change if the user can resize the window (texttt {CV\_WINDOW\_NORMAL} or ``CV_WINDOW_AUTOSIZE`` ). * **CV_WND_PROP_AUTOSIZE** Change if the user can resize the window (texttt {CV\_WINDOW\_NORMAL} or ``CV_WINDOW_AUTOSIZE`` ).
* **CV_WND_PROP_ASPECTRATIO** Change if the image's aspect ratio is preserved (texttt {CV\_WINDOW\_FREERATIO} or ``CV_WINDOW_KEEPRATIO`` ). * **CV_WND_PROP_ASPECTRATIO** Change if the image's aspect ratio is preserved (texttt {CV\_WINDOW\_FREERATIO} or ``CV_WINDOW_KEEPRATIO`` ).
See See
:ref:`setWindowProperty` to know the meaning of the returned values. :ref:`setWindowProperty` to know the meaning of the returned values.
@ -118,41 +117,40 @@ The function `` getWindowProperty`` return window's properties.
.. index:: fontQt .. index:: fontQt
cv::fontQt fontQt
---------- ----------
.. cfunction:: 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) .. c: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)
Create the font to be used to draw text on an image. Create the font to be used to draw text on an image.
:param nameFont: Name of the font. The name should match the name of a system font (such as ``Times''). If the font is not found, a default one will be used. :param nameFont: Name of the font. The name should match the name of a system font (such as *Times*). If the font is not found, a default one will be used.
:param pointSize: Size of the font. If not specified, equal zero or negative, the point size of the font is set to a system-dependent default value. Generally, this is 12 points. :param pointSize: Size of the font. If not specified, equal zero or negative, the point size of the font is set to a system-dependent default value. Generally, this is 12 points.
:param color: Color of the font in BGRA -- A = 255 is fully transparent. Use the macro CV _ RGB for simplicity. :param color: Color of the font in BGRA -- A = 255 is fully transparent. Use the macro CV _ RGB for simplicity.
:param weight: The operation flags: :param weight: The operation flags:
* **CV_FONT_LIGHT** Weight of 25 * **CV_FONT_LIGHT** Weight of 25
* **CV_FONT_NORMAL** Weight of 50 * **CV_FONT_NORMAL** Weight of 50
* **CV_FONT_DEMIBOLD** Weight of 63 * **CV_FONT_DEMIBOLD** Weight of 63
* **CV_FONT_BOLD** Weight of 75 * **CV_FONT_BOLD** Weight of 75
* **CV_FONT_BLACK** Weight of 87 * **CV_FONT_BLACK** Weight of 87
You can also specify a positive integer for more control. You can also specify a positive integer for more control.
:param style: The operation flags: :param style: The operation flags:
* **CV_STYLE_NORMAL** Font is normal * **CV_STYLE_NORMAL** Font is normal
* **CV_STYLE_ITALIC** Font is in italic * **CV_STYLE_ITALIC** Font is in italic
* **CV_STYLE_OBLIQUE** Font is oblique * **CV_STYLE_OBLIQUE** Font is oblique
:param spacing: Spacing between characters. Can be negative or positive :param spacing: Spacing between characters. Can be negative or positive
The function ``fontQt`` creates a CvFont object. This CvFont is not compatible with putText. The function ``fontQt`` creates a CvFont object. This CvFont is not compatible with putText.
@ -161,13 +159,12 @@ A basic usage of this function is: ::
CvFont font = fontQt(''Times''); CvFont font = fontQt(''Times'');
addText( img1, ``Hello World !'', Point(50,50), font); addText( img1, ``Hello World !'', Point(50,50), font);
..
.. index:: addText .. index:: addText
cv::addText addText
----------- -----------
.. cfunction:: void addText(const Mat\& img, const string\& text, Point location, CvFont *font) .. c:function:: void addText(const Mat& img, const string& text, Point location, CvFont *font)
Create the font to be used to draw text on an image Create the font to be used to draw text on an image
@ -190,9 +187,9 @@ using a specific font
.. index:: displayOverlay .. index:: displayOverlay
cv::displayOverlay displayOverlay
------------------ ------------------
.. cfunction:: void displayOverlay(const string\& name, const string\& text, int delay) .. c:function:: void displayOverlay(const string& name, const string& text, int delay)
Display text on the window's image as an overlay for delay milliseconds. This is not editing the image's data. The text is display on the top of the image. Display text on the window's image as an overlay for delay milliseconds. This is not editing the image's data. The text is display on the top of the image.
@ -208,9 +205,9 @@ The function ``displayOverlay`` aims at displaying useful information/tips on th
.. index:: displayStatusBar .. index:: displayStatusBar
cv::displayStatusBar displayStatusBar
-------------------- --------------------
.. cfunction:: void displayStatusBar(const string\& name, const string\& text, int delayms) .. c:function:: void displayStatusBar(const string& name, const string& text, int delayms)
Display text on the window's statusbar as for delay milliseconds. Display text on the window's statusbar as for delay milliseconds.
@ -226,11 +223,10 @@ The function ``displayOverlay`` aims at displaying useful information/tips on th
.. index:: createOpenGLCallback .. index:: createOpenGLCallback
cv::createOpenGLCallback createOpenGLCallback
------------------------ ------------------------
*_*
.. cfunction:: void createOpenGLCallback( const string\& window_name, OpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1) .. c:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1)
Create a callback function called to draw OpenGL on top the the image display by windowname. Create a callback function called to draw OpenGL on top the the image display by windowname.
@ -278,15 +274,13 @@ The function ``createOpenGLCallback`` can be used to draw 3D data on the window.
glEnd(); glEnd();
} }
} }
..
.. index:: saveWindowParameters .. index:: saveWindowParameters
cv::saveWindowParameters saveWindowParameters
------------------------ ------------------------
*_*
.. cfunction:: void saveWindowParameters(const string\& name) .. c:function:: void saveWindowParameters(const string& name)
Save parameters of the window windowname. Save parameters of the window windowname.
@ -297,11 +291,10 @@ The function ``saveWindowParameters`` saves size, location, flags, trackbars' v
.. index:: loadWindowParameters .. index:: loadWindowParameters
cv::loadWindowParameters loadWindowParameters
------------------------ ------------------------
*_*
.. cfunction:: void loadWindowParameters(const string\& name) .. c:function:: void loadWindowParameters(const string& name)
Load parameters of the window windowname. Load parameters of the window windowname.
@ -312,11 +305,10 @@ The function ``loadWindowParameters`` load size, location, flags, trackbars' va
.. index:: createButton .. index:: createButton
cv::createButton createButton
---------------- ----------------
*_*
.. cfunction:: createButton( const string\& button_name CV_DEFAULT(NULL),ButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL) , int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0) .. c:function:: createButton( const string& button_name CV_DEFAULT(NULL),ButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL), int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0))
Create a callback function called to draw OpenGL on top the the image display by windowname. Create a callback function called to draw OpenGL on top the the image display by windowname.
@ -329,7 +321,7 @@ cv::createButton
:param userdata: pointer passed to the callback function. *(Optional)* :param userdata: pointer passed to the callback function. *(Optional)*
The ``button_type`` parameter can be : The ``button_type`` parameter can be :
*(Optional -- Will be a push button by default.) * (Optional -- Will be a push button by default.)
* **CV_PUSH_BUTTON** The button will be a push button. * **CV_PUSH_BUTTON** The button will be a push button.
@ -337,8 +329,6 @@ The ``button_type`` parameter can be :
* **CV_RADIOBOX** The button will be a radiobox button. The radiobox on the same buttonbar (same line) are exclusive; one on can be select at the time. * **CV_RADIOBOX** The button will be a radiobox button. The radiobox on the same buttonbar (same line) are exclusive; one on can be select at the time.
*
* **initial_button_state** Default state of the button. Use for checkbox and radiobox, its value could be 0 or 1. *(Optional)* * **initial_button_state** Default state of the button. Use for checkbox and radiobox, its value could be 0 or 1. *(Optional)*
The function ``createButton`` attach a button to the control panel. Each button is added to a buttonbar on the right of the last button. The function ``createButton`` attach a button to the control panel. Each button is added to a buttonbar on the right of the last button.
@ -351,5 +341,7 @@ Here are various example of ``createButton`` function call: ::
createButton("button3",callbackButton,&value); createButton("button3",callbackButton,&value);
createButton("button5",callbackButton1,NULL,CV_RADIOBOX); createButton("button5",callbackButton1,NULL,CV_RADIOBOX);
createButton("button6",callbackButton2,NULL,CV_PUSH_BUTTON,1); createButton("button6",callbackButton2,NULL,CV_PUSH_BUTTON,1);
.. ..

36
modules/highgui/doc/reading_and_writing_images_and_video.rst
View File

@ -5,9 +5,9 @@ Reading and Writing Images and Video
.. index:: imdecode .. index:: imdecode
cv::imdecode imdecode
------------ ------------
.. cfunction:: Mat imdecode( const Mat\& buf, int flags ) .. c:function:: Mat imdecode( const Mat\& buf, int flags )
Reads an image from a buffer in memory. Reads an image from a buffer in memory.
@ -22,9 +22,9 @@ See
.. index:: imencode .. index:: imencode
cv::imencode imencode
------------ ------------
.. cfunction:: bool imencode( const string\& ext, const Mat\& img, vector<uchar>\& buf, const vector<int>\& params=vector<int>()) .. c:function:: bool imencode( const string\& ext, const Mat\& img, vector<uchar>\& buf, const vector<int>\& params=vector<int>())
Encode an image into a memory buffer. Encode an image into a memory buffer.
@ -41,9 +41,9 @@ See
.. index:: imread .. index:: imread
cv::imread imread
---------- ----------
.. cfunction:: Mat imread( const string\& filename, int flags=1 ) .. c:function:: Mat imread( const string\& filename, int flags=1 )
Loads an image from a file. Loads an image from a file.
@ -98,9 +98,9 @@ On Linux, BSD flavors and other Unix-like open-source operating systems OpenCV l
.. index:: imwrite .. index:: imwrite
cv::imwrite imwrite
----------- -----------
.. cfunction:: bool imwrite( const string\& filename, const Mat\& img, const vector<int>\& params=vector<int>()) .. c:function:: bool imwrite( const string\& filename, const Mat\& img, const vector<int>\& params=vector<int>())
Saves an image to a specified file. Saves an image to a specified file.
@ -127,7 +127,7 @@ The function ``imwrite`` saves the image to the specified file. The image format
VideoCapture VideoCapture
------------ ------------
.. ctype:: VideoCapture .. c:type:: VideoCapture
Class for video capturing from video files or cameras :: Class for video capturing from video files or cameras ::
@ -209,13 +209,13 @@ The class provides C++ video capturing API. Here is how the class can be used: :
.. index:: VideoCapture::VideoCapture .. index:: VideoCapture::VideoCapture
cv::VideoCapture::VideoCapture VideoCapture::VideoCapture
------------------------------ ------------------------------
.. cfunction:: VideoCapture::VideoCapture() .. c:function:: VideoCapture::VideoCapture()
.. cfunction:: VideoCapture::VideoCapture(const string\& filename) .. c:function:: VideoCapture::VideoCapture(const string\& filename)
.. cfunction:: VideoCapture::VideoCapture(int device) .. c:function:: VideoCapture::VideoCapture(int device)
:param filename: TOWRITE :param filename: TOWRITE
@ -225,9 +225,9 @@ VideoCapture constructors.
.. index:: VideoCapture::get .. index:: VideoCapture::get
cv::VideoCapture::get VideoCapture::get
--------------------- ---------------------
.. cfunction:: double VideoCapture::get(int property_id) .. c:function:: double VideoCapture::get(int property_id)
:param property_id: Property identifier. Can be one of the following: :param property_id: Property identifier. Can be one of the following:
@ -273,9 +273,9 @@ Note that when querying a property which is unsupported by the backend used by t
.. index:: VideoCapture::set .. index:: VideoCapture::set
cv::VideoCapture::set VideoCapture::set
--------------------- ---------------------
.. cfunction:: bool VideoCapture::set(int property_id, double value) .. c:function:: bool VideoCapture::set(int property_id, double value)
:param property_id: Property identifier. Can be one of the following: :param property_id: Property identifier. Can be one of the following:
@ -327,7 +327,7 @@ Sets a property in the VideoCapture backend.
VideoWriter VideoWriter
----------- -----------
.. ctype:: VideoWriter .. c:type:: VideoWriter
Video writer class :: Video writer class ::

24
modules/highgui/doc/user_interface.rst
View File

@ -5,9 +5,9 @@ User Interface
.. index:: createTrackbar .. index:: createTrackbar
cv::createTrackbar createTrackbar
------------------ ------------------
.. cfunction:: int createTrackbar( const string\& trackbarname, const string\& winname, int* value, int count, TrackbarCallback onChange CV_DEFAULT(0), void* userdata CV_DEFAULT(0)) .. c:function:: int createTrackbar( const string\& trackbarname, const string\& winname, int* value, int count, TrackbarCallback onChange CV_DEFAULT(0), void* userdata CV_DEFAULT(0))
Creates a trackbar and attaches it to the specified window Creates a trackbar and attaches it to the specified window
@ -41,9 +41,9 @@ By clicking on the label of each trackbar, it is possible to edit the trackbar's
.. index:: getTrackbarPos .. index:: getTrackbarPos
cv::getTrackbarPos getTrackbarPos
------------------ ------------------
.. cfunction:: int getTrackbarPos( const string\& trackbarname, const string\& winname ) .. c:function:: int getTrackbarPos( const string\& trackbarname, const string\& winname )
Returns the trackbar position. Returns the trackbar position.
@ -61,9 +61,9 @@ qt-specific details:
.. index:: imshow .. index:: imshow
cv::imshow imshow
---------- ----------
.. cfunction:: void imshow( const string\& winname, const Mat\& image ) .. c:function:: void imshow( const string\& winname, const Mat\& image )
Displays the image in the specified window Displays the image in the specified window
@ -84,9 +84,9 @@ The function ``imshow`` displays the image in the specified window. If the windo
.. index:: namedWindow .. index:: namedWindow
cv::namedWindow namedWindow
--------------- ---------------
.. cfunction:: void namedWindow( const string\& winname, int flags ) .. c:function:: void namedWindow( const string\& winname, int flags )
Creates a window. Creates a window.
@ -122,9 +122,9 @@ qt-specific details:
.. index:: setTrackbarPos .. index:: setTrackbarPos
cv::setTrackbarPos setTrackbarPos
------------------ ------------------
.. cfunction:: void setTrackbarPos( const string\& trackbarname, const string\& winname, int pos ) .. c:function:: void setTrackbarPos( const string\& trackbarname, const string\& winname, int pos )
Sets the trackbar position. Sets the trackbar position.
@ -144,9 +144,9 @@ qt-specific details:
.. index:: waitKey .. index:: waitKey
cv::waitKey waitKey
----------- -----------
.. cfunction:: int waitKey(int delay=0) .. c:function:: int waitKey(int delay=0)
Waits for a pressed key. Waits for a pressed key.

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

@ -5,15 +5,16 @@ Feature Detection
.. index:: Canny .. index:: Canny
cv::Canny Canny
--------- ---------
.. cfunction:: void Canny( const Mat\& image, Mat\& edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false ) .. c:function:: void Canny( const Mat& image, Mat& edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false )
Finds edges in an image using Canny algorithm. Finds edges in an image using Canny algorithm.
:param image: Single-channel 8-bit input image :param image: Single-channel 8-bit input image
:param edges: The output edge map. It will have the same size and the same type as ``image`` :param edges: The output edge map. It will have the same size and the same type as ``image``
:param threshold1: The first threshold for the hysteresis procedure :param threshold1: The first threshold for the hysteresis procedure
:param threshold2: The second threshold for the hysteresis procedure :param threshold2: The second threshold for the hysteresis procedure
@ -27,20 +28,22 @@ http://en.wikipedia.org/wiki/Canny_edge_detector
.. index:: cornerEigenValsAndVecs .. index:: cornerEigenValsAndVecs
cv::cornerEigenValsAndVecs cornerEigenValsAndVecs
-------------------------- --------------------------
.. cfunction:: void cornerEigenValsAndVecs( const Mat\& src, Mat\& dst, int blockSize, int apertureSize, int borderType=BORDER_DEFAULT ) .. c:function:: void cornerEigenValsAndVecs( const Mat& src, Mat& dst, int blockSize, int apertureSize, int borderType=BORDER_DEFAULT )
Calculates eigenvalues and eigenvectors of image blocks for corner detection. Calculates eigenvalues and eigenvectors of image blocks for corner detection.
:param src: Input single-channel 8-bit or floating-point image :param src: Input single-channel 8-bit or floating-point image
:param dst: Image to store the results. It will have the same size as ``src`` and the type ``CV_32FC(6)`` :param dst: Image to store the results. It will have the same size as ``src`` and the type ``CV_32FC(6)``
:param blockSize: Neighborhood size (see discussion) :param blockSize: Neighborhood size (see discussion)
:param apertureSize: Aperture parameter for the :func:`Sobel` operator :param apertureSize: Aperture parameter for the :func:`Sobel` operator
:param boderType: Pixel extrapolation method; see :func:`borderInterpolate` :param boderType: Pixel extrapolation method; see :func:`borderInterpolate`
For every pixel For every pixel
:math:`p` , the function ``cornerEigenValsAndVecs`` considers a ``blockSize`` :math:`\times` ``blockSize`` neigborhood :math:`p` , the function ``cornerEigenValsAndVecs`` considers a ``blockSize`` :math:`\times` ``blockSize`` neigborhood
:math:`S(p)` . It calculates the covariation matrix of derivatives over the neighborhood as: :math:`S(p)` . It calculates the covariation matrix of derivatives over the neighborhood as:
@ -56,28 +59,28 @@ After that it finds eigenvectors and eigenvalues of
:math:`M` and stores them into destination image in the form :math:`M` and stores them into destination image in the form
:math:`(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)` where :math:`(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)` where
* :math:`\lambda_1, \lambda_2` are the eigenvalues of * :math:`\lambda_1, \lambda_2` are the eigenvalues of :math:`M`; not sorted
:math:`M` ; not sorted
* :math:`x_1, y_1` are the eigenvectors corresponding to :math:`\lambda_1`
* :math:`x_2, y_2` are the eigenvectors corresponding to :math:`\lambda_2`
* :math:`x_1, y_1` are the eigenvectors corresponding to
:math:`\lambda_1`
* :math:`x_2, y_2` are the eigenvectors corresponding to
:math:`\lambda_2`
The output of the function can be used for robust edge or corner detection. The output of the function can be used for robust edge or corner detection.
See also: See also:
:func:`cornerMinEigenVal`,:func:`cornerHarris`,:func:`preCornerDetect` :func:`cornerMinEigenVal`,:func:`cornerHarris`,:func:`preCornerDetect`
.. index:: cornerHarris .. index:: cornerHarris
cv::cornerHarris cornerHarris
---------------- ----------------
.. cfunction:: void cornerHarris( const Mat\& src, Mat\& dst, int blockSize, int apertureSize, double k, int borderType=BORDER_DEFAULT ) .. c:function:: void cornerHarris( const Mat& src, Mat& dst, int blockSize, int apertureSize, double k, int borderType=BORDER_DEFAULT )
Harris edge detector. Harris edge detector.
:param src: Input single-channel 8-bit or floating-point image :param src: Input single-channel 8-bit or floating-point image
:param dst: Image to store the Harris detector responses; will have type ``CV_32FC1`` and the same size as ``src`` :param dst: Image to store the Harris detector responses; will have type ``CV_32FC1`` and the same size as ``src``
:param blockSize: Neighborhood size (see the discussion of :func:`cornerEigenValsAndVecs` ) :param blockSize: Neighborhood size (see the discussion of :func:`cornerEigenValsAndVecs` )
:param apertureSize: Aperture parameter for the :func:`Sobel` operator :param apertureSize: Aperture parameter for the :func:`Sobel` operator
@ -85,6 +88,7 @@ cv::cornerHarris
:param k: Harris detector free parameter. See the formula below :param k: Harris detector free parameter. See the formula below
:param boderType: Pixel extrapolation method; see :func:`borderInterpolate` :param boderType: Pixel extrapolation method; see :func:`borderInterpolate`
The function runs the Harris edge detector on the image. Similarly to The function runs the Harris edge detector on the image. Similarly to
:func:`cornerMinEigenVal` and :func:`cornerMinEigenVal` and
:func:`cornerEigenValsAndVecs` , for each pixel :func:`cornerEigenValsAndVecs` , for each pixel
@ -101,20 +105,22 @@ Corners in the image can be found as the local maxima of this response map.
.. index:: cornerMinEigenVal .. index:: cornerMinEigenVal
cv::cornerMinEigenVal cornerMinEigenVal
--------------------- ---------------------
.. cfunction:: void cornerMinEigenVal( const Mat\& src, Mat\& dst, int blockSize, int apertureSize=3, int borderType=BORDER_DEFAULT ) .. c:function:: void cornerMinEigenVal( const Mat& src, Mat& dst, int blockSize, int apertureSize=3, int borderType=BORDER_DEFAULT )
Calculates the minimal eigenvalue of gradient matrices for corner detection. Calculates the minimal eigenvalue of gradient matrices for corner detection.
:param src: Input single-channel 8-bit or floating-point image :param src: Input single-channel 8-bit or floating-point image
:param dst: Image to store the minimal eigenvalues; will have type ``CV_32FC1`` and the same size as ``src`` :param dst: Image to store the minimal eigenvalues; will have type ``CV_32FC1`` and the same size as ``src``
:param blockSize: Neighborhood size (see the discussion of :func:`cornerEigenValsAndVecs` ) :param blockSize: Neighborhood size (see the discussion of :func:`cornerEigenValsAndVecs` )
:param apertureSize: Aperture parameter for the :func:`Sobel` operator :param apertureSize: Aperture parameter for the :func:`Sobel` operator
:param boderType: Pixel extrapolation method; see :func:`borderInterpolate` :param boderType: Pixel extrapolation method; see :func:`borderInterpolate`
The function is similar to The function is similar to
:func:`cornerEigenValsAndVecs` but it calculates and stores only the minimal eigenvalue of the covariation matrix of derivatives, i.e. :func:`cornerEigenValsAndVecs` but it calculates and stores only the minimal eigenvalue of the covariation matrix of derivatives, i.e.
:math:`\min(\lambda_1, \lambda_2)` in terms of the formulae in :math:`\min(\lambda_1, \lambda_2)` in terms of the formulae in
@ -122,9 +128,9 @@ The function is similar to
.. index:: cornerSubPix .. index:: cornerSubPix
cv::cornerSubPix cornerSubPix
---------------- ----------------
.. cfunction:: void cornerSubPix( const Mat\& image, vector<Point2f>\& corners, Size winSize, Size zeroZone, TermCriteria criteria ) .. c:function:: void cornerSubPix( const Mat& image, vector<Point2f>& corners, Size winSize, Size zeroZone, TermCriteria criteria )
Refines the corner locations. Refines the corner locations.
@ -178,9 +184,9 @@ The algorithm sets the center of the neighborhood window at this new center
.. index:: goodFeaturesToTrack .. index:: goodFeaturesToTrack
cv::goodFeaturesToTrack goodFeaturesToTrack
----------------------- -----------------------
.. cfunction:: void goodFeaturesToTrack( const Mat\& image, vector<Point2f>\& corners, int maxCorners, double qualityLevel, double minDistance, const Mat\& mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ) .. c:function:: void goodFeaturesToTrack( const Mat& image, vector<Point2f>& corners, int maxCorners, double qualityLevel, double minDistance, const Mat& mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 )
Determines strong corners on an image. Determines strong corners on an image.
@ -197,18 +203,18 @@ cv::goodFeaturesToTrack
:param mask: The optional region of interest. If the image is not empty (then it needs to have the type ``CV_8UC1`` and the same size as ``image`` ), it will specify the region in which the corners are detected :param mask: The optional region of interest. If the image is not empty (then it needs to have the type ``CV_8UC1`` and the same size as ``image`` ), it will specify the region in which the corners are detected
:param blockSize: Size of the averaging block for computing derivative covariation matrix over each pixel neighborhood, see :func:`cornerEigenValsAndVecs` :param blockSize: Size of the averaging block for computing derivative covariation matrix over each pixel neighborhood, see :func:`cornerEigenValsAndVecs`
:param useHarrisDetector: Indicates, whether to use operator or :func:`cornerMinEigenVal` :param useHarrisDetector: Indicates, whether to use operator or :func:`cornerMinEigenVal`
:param k: Free parameter of Harris detector :param k: Free parameter of Harris detector
The function finds the most prominent corners in the image or in the specified image region, as described The function finds the most prominent corners in the image or in the specified image region, as described in Shi94:
in
Shi94
:
#. #.
the function first calculates the corner quality measure at every source image pixel using the the function first calculates the corner quality measure at every source image pixel using the
:func:`cornerMinEigenVal` or :func:`cornerMinEigenVal` or
:func:`cornerHarris` :func:`cornerHarris`
#. #.
then it performs non-maxima suppression (the local maxima in then it performs non-maxima suppression (the local maxima in
:math:`3\times 3` neighborhood :math:`3\times 3` neighborhood
@ -226,23 +232,25 @@ Shi94
:math:`pt_j` if there is a stronger corner :math:`pt_j` if there is a stronger corner
:math:`pt_i` ( :math:`pt_i` (
:math:`i < j` ) such that the distance between them is less than ``minDistance`` :math:`i < j` ) such that the distance between them is less than ``minDistance``
The function can be used to initialize a point-based tracker of an object. The function can be used to initialize a point-based tracker of an object.
Note that the 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`` . Note that the 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: See also: :func:`cornerMinEigenVal`, :func:`cornerHarris`, :func:`calcOpticalFlowPyrLK`, :func:`estimateRigidMotion`, :func:`PlanarObjectDetector`, :func:`OneWayDescriptor`
:func:`cornerMinEigenVal`,:func:`cornerHarris`,:func:`calcOpticalFlowPyrLK`,:func:`estimateRigidMotion`,:func:`PlanarObjectDetector`,:func:`OneWayDescriptor`
.. index:: HoughCircles .. index:: HoughCircles
cv::HoughCircles HoughCircles
---------------- ----------------
.. cfunction:: void HoughCircles( Mat\& image, vector<Vec3f>\& circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 ) .. c:function:: void HoughCircles( Mat& image, vector<Vec3f>& 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 a Hough transform. Finds circles in a grayscale image using a Hough transform.
:param image: The 8-bit, single-channel, grayscale input image :param image: The 8-bit, single-channel, grayscale input image
:param circles: The output vector of found circles. Each vector is encoded as 3-element floating-point vector :math:`(x, y, radius)` :param circles: The output vector of found circles. Each vector is encoded as 3-element floating-point vector :math:`(x, y, radius)`
:param method: Currently, the only implemented method is ``CV_HOUGH_GRADIENT`` , which is basically *21HT* , described in Yuen90 . :param method: Currently, the only implemented method is ``CV_HOUGH_GRADIENT`` , which is basically *21HT* , described in Yuen90 .
:param dp: The inverse ratio of the accumulator resolution to the image resolution. For example, if ``dp=1`` , the accumulator will have the same resolution as the input image, if ``dp=2`` - accumulator will have half as big width and height, etc :param dp: The inverse ratio of the accumulator resolution to the image resolution. For example, if ``dp=1`` , the accumulator will have the same resolution as the input image, if ``dp=2`` - accumulator will have half as big width and height, etc
@ -289,7 +297,6 @@ The function finds circles in a grayscale image using some modification of Hough
imshow( "circles", img ); imshow( "circles", img );
return 0; return 0;
} }
..
Note that usually the function detects the circles' centers well, however it may fail to find the correct radii. You can assist 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 some additional procedure. Note that usually the function detects the circles' centers well, however it may fail to find the correct radii. You can assist 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 some additional procedure.
@ -297,9 +304,9 @@ See also:
:func:`fitEllipse`,:func:`minEnclosingCircle` :func:`fitEllipse`,:func:`minEnclosingCircle`
.. index:: HoughLines .. index:: HoughLines
cv::HoughLines HoughLines
-------------- --------------
.. cfunction:: void HoughLines( Mat\& image, vector<Vec2f>\& lines, double rho, double theta, int threshold, double srn=0, double stn=0 ) .. c:function:: void HoughLines( Mat& image, vector<Vec2f>& lines, double rho, double theta, int threshold, double srn=0, double stn=0 )
Finds lines in a binary image using standard Hough transform. Finds lines in a binary image using standard Hough transform.
@ -316,14 +323,15 @@ cv::HoughLines
:param srn: For the multi-scale Hough transform it is the divisor for the distance resolution ``rho`` . The coarse accumulator distance resolution will be ``rho`` and the accurate accumulator resolution will be ``rho/srn`` . If both ``srn=0`` and ``stn=0`` then the classical Hough transform is used, otherwise both these parameters should be positive. :param srn: For the multi-scale Hough transform it is the divisor for the distance resolution ``rho`` . The coarse accumulator distance resolution will be ``rho`` and the accurate accumulator resolution will be ``rho/srn`` . If both ``srn=0`` and ``stn=0`` then the classical Hough transform is used, otherwise both these parameters should be positive.
:param stn: For the multi-scale Hough transform it is the divisor for the distance resolution ``theta`` :param stn: For the multi-scale Hough transform it is the divisor for the distance resolution ``theta``
The function implements standard or standard multi-scale Hough transform algorithm for line detection. See The function implements standard or standard multi-scale Hough transform algorithm for line detection. See
:func:`HoughLinesP` for the code example. :func:`HoughLinesP` for the code example.
.. index:: HoughLinesP .. index:: HoughLinesP
cv::HoughLinesP HoughLinesP
--------------- ---------------
.. cfunction:: void HoughLinesP( Mat\& image, vector<Vec4i>\& lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 ) .. c:function:: void HoughLinesP( Mat& image, vector<Vec4i>& lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 )
Finds lines segments in a binary image using probabilistic Hough transform. Finds lines segments in a binary image using probabilistic Hough transform.
@ -397,7 +405,6 @@ Matas00
waitKey(0); waitKey(0);
return 0; return 0;
} }
..
This is the sample picture the function parameters have been tuned for: This is the sample picture the function parameters have been tuned for:
@ -409,17 +416,20 @@ And this is the output of the above program in the case of probabilistic Hough t
.. index:: preCornerDetect .. index:: preCornerDetect
cv::preCornerDetect preCornerDetect
------------------- -------------------
.. cfunction:: void preCornerDetect( const Mat\& src, Mat\& dst, int apertureSize, int borderType=BORDER_DEFAULT ) .. c:function:: void preCornerDetect( const Mat& src, Mat& dst, int apertureSize, int borderType=BORDER_DEFAULT )
Calculates the feature map for corner detection Calculates the feature map for corner detection
:param src: The source single-channel 8-bit of floating-point image :param src: The source single-channel 8-bit of floating-point image
:param dst: The output image; will have type ``CV_32F`` and the same size as ``src`` :param dst: The output image; will have type ``CV_32F`` and the same size as ``src``
:param apertureSize: Aperture size of :func:`Sobel` :param apertureSize: Aperture size of :func:`Sobel`
:param borderType: The pixel extrapolation method; see :func:`borderInterpolate` :param borderType: The pixel extrapolation method; see :func:`borderInterpolate`
The function calculates the complex spatial derivative-based function of the source image The function calculates the complex spatial derivative-based function of the source image
.. math:: .. math::
@ -438,5 +448,5 @@ The corners can be found as local maximums of the functions, as shown below: ::
// dilation with 3x3 rectangular structuring element // dilation with 3x3 rectangular structuring element
dilate(corners, dilated_corners, Mat(), 1); dilate(corners, dilated_corners, Mat(), 1);
Mat corner_mask = corners == dilated_corners; Mat corner_mask = corners == dilated_corners;
..

158
modules/imgproc/doc/filtering.rst
View File

@ -18,7 +18,7 @@ OpenCV let the user to specify the extrapolation method; see the function :func
BaseColumnFilter BaseColumnFilter
---------------- ----------------
.. ctype:: BaseColumnFilter .. c:type:: BaseColumnFilter
Base class for filters with single-column kernels :: Base class for filters with single-column kernels ::
@ -43,7 +43,7 @@ Base class for filters with single-column kernels ::
int anchor; // position of the anchor point, int anchor; // position of the anchor point,
// normally not used during the processing // normally not used during the processing
}; };
..
The class ``BaseColumnFilter`` is the base class for filtering data using single-column kernels. The filtering does not have to be a linear operation. In general, it could be written as following: The class ``BaseColumnFilter`` is the base class for filtering data using single-column kernels. The filtering does not have to be a linear operation. In general, it could be written as following:
@ -64,7 +64,7 @@ See also:
BaseFilter BaseFilter
---------- ----------
.. ctype:: BaseFilter .. c:type:: BaseFilter
Base class for 2D image filters :: Base class for 2D image filters ::
@ -88,7 +88,7 @@ Base class for 2D image filters ::
Size ksize; Size ksize;
Point anchor; Point anchor;
}; };
..
The class ``BaseFilter`` is the base class for filtering data using 2D kernels. The filtering does not have to be a linear operation. In general, it could be written as following: The class ``BaseFilter`` is the base class for filtering data using 2D kernels. The filtering does not have to be a linear operation. In general, it could be written as following:
@ -111,7 +111,7 @@ See also:
BaseRowFilter BaseRowFilter
------------- -------------
.. ctype:: BaseRowFilter .. c:type:: BaseRowFilter
Base class for filters with single-row kernels :: Base class for filters with single-row kernels ::
@ -129,7 +129,7 @@ Base class for filters with single-row kernels ::
int width, int cn) = 0; int width, int cn) = 0;
int ksize, anchor; int ksize, anchor;
}; };
..
The class ``BaseRowFilter`` is the base class for filtering data using single-row kernels. The filtering does not have to be a linear operation. In general, it could be written as following: The class ``BaseRowFilter`` is the base class for filtering data using single-row kernels. The filtering does not have to be a linear operation. In general, it could be written as following:
@ -150,7 +150,7 @@ See also:
FilterEngine FilterEngine
------------ ------------
.. ctype:: FilterEngine .. c:type:: FilterEngine
Generic image filtering class :: Generic image filtering class ::
@ -166,7 +166,7 @@ Generic image filtering class ::
// _rowBorderType and _columnBorderType determine how the image // _rowBorderType and _columnBorderType determine how the image
// will be extrapolated beyond the image boundaries. // will be extrapolated beyond the image boundaries.
// _borderValue is only used when _rowBorderType and/or _columnBorderType // _borderValue is only used when _rowBorderType and/or _columnBorderType
// == cv::BORDER_CONSTANT // == BORDER_CONSTANT
FilterEngine(const Ptr<BaseFilter>& _filter2D, FilterEngine(const Ptr<BaseFilter>& _filter2D,
const Ptr<BaseRowFilter>& _rowFilter, const Ptr<BaseRowFilter>& _rowFilter,
const Ptr<BaseColumnFilter>& _columnFilter, const Ptr<BaseColumnFilter>& _columnFilter,
@ -217,7 +217,7 @@ Generic image filtering class ::
Ptr<BaseRowFilter> rowFilter; Ptr<BaseRowFilter> rowFilter;
Ptr<BaseColumnFilter> columnFilter; Ptr<BaseColumnFilter> columnFilter;
}; };
..
The class ``FilterEngine`` can be used to apply an arbitrary filtering operation to an image. The class ``FilterEngine`` can be used to apply an arbitrary filtering operation to an image.
It contains all the necessary intermediate buffers, it computes extrapolated values It contains all the necessary intermediate buffers, it computes extrapolated values
@ -278,7 +278,7 @@ This class makes it easier (though, maybe not very easy yet) to combine filterin
} }
} }
} }
..
If you do not need that much control of the filtering process, you can simply use the ``FilterEngine::apply`` method. Here is how the method is actually implemented: :: If you do not need that much control of the filtering process, you can simply use the ``FilterEngine::apply`` method. Here is how the method is actually implemented: ::
@ -310,7 +310,7 @@ If you do not need that much control of the filtering process, you can simply us
dst.data + dstOfs.y*dst.step + dst.data + dstOfs.y*dst.step +
dstOfs.x*dst.elemSize(), (int)dst.step ); dstOfs.x*dst.elemSize(), (int)dst.step );
} }
..
Unlike the earlier versions of OpenCV, now the filtering operations fully support the notion of image ROI, that is, pixels outside of the ROI but inside the image can be used in the filtering operations. For example, you can take a ROI of a single pixel and filter it - that will be a filter response at that particular pixel (however, it's possible to emulate the old behavior by passing ``isolated=false`` to ``FilterEngine::start`` or ``FilterEngine::apply`` ). You can pass the ROI explicitly to ``FilterEngine::apply`` , or construct a new matrix headers: :: Unlike the earlier versions of OpenCV, now the filtering operations fully support the notion of image ROI, that is, pixels outside of the ROI but inside the image can be used in the filtering operations. For example, you can take a ROI of a single pixel and filter it - that will be a filter response at that particular pixel (however, it's possible to emulate the old behavior by passing ``isolated=false`` to ``FilterEngine::start`` or ``FilterEngine::apply`` ). You can pass the ROI explicitly to ``FilterEngine::apply`` , or construct a new matrix headers: ::
@ -334,7 +334,7 @@ Unlike the earlier versions of OpenCV, now the filtering operations fully suppor
Sobel(pix_roi, dst2, dst2.type(), 1, 0, 3, 1, 0, BORDER_REFLECT_101); Sobel(pix_roi, dst2, dst2.type(), 1, 0, 3, 1, 0, BORDER_REFLECT_101);
printf("method1 = printf("method1 =
..
Note on the data types. As it was mentioned in Note on the data types. As it was mentioned in
: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: :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:
@ -351,9 +351,9 @@ See also:
:func:`BaseColumnFilter`,:func:`BaseFilter`,:func:`BaseRowFilter`,:func:`createBoxFilter`,:func:`createDerivFilter`,:func:`createGaussianFilter`,:func:`createLinearFilter`,:func:`createMorphologyFilter`,:func:`createSeparableLinearFilter` :func:`BaseColumnFilter`,:func:`BaseFilter`,:func:`BaseRowFilter`,:func:`createBoxFilter`,:func:`createDerivFilter`,:func:`createGaussianFilter`,:func:`createLinearFilter`,:func:`createMorphologyFilter`,:func:`createSeparableLinearFilter`
.. index:: bilateralFilter .. index:: bilateralFilter
cv::bilateralFilter bilateralFilter
------------------- -------------------
.. cfunction:: void bilateralFilter( const Mat\& src, Mat\& dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT ) .. c:function:: void bilateralFilter( const Mat\& src, Mat\& dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT )
Applies bilateral filter to the image Applies bilateral filter to the image
@ -369,9 +369,9 @@ http://www.dai.ed.ac.uk/CVonline/LOCAL\_COPIES/MANDUCHI1/Bilateral\_Filtering.ht
.. index:: blur .. index:: blur
cv::blur blur
-------- --------
.. cfunction:: void blur( const Mat\& src, Mat\& dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT ) .. c:function:: void blur( const Mat\& src, Mat\& dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT )
Smoothes image using normalized box filter Smoothes image using normalized box filter
@ -397,9 +397,9 @@ See also:
.. index:: borderInterpolate .. index:: borderInterpolate
cv::borderInterpolate borderInterpolate
--------------------- ---------------------
.. cfunction:: int borderInterpolate( int p, int len, int borderType ) .. c:function:: int borderInterpolate( int p, int len, int borderType )
Computes source location of extrapolated pixel Computes source location of extrapolated pixel
@ -411,7 +411,7 @@ The function computes and returns the coordinate of the donor pixel, correspondi
float val = img.at<float>(borderInterpolate(100, img.rows, BORDER_REFLECT_101), float val = img.at<float>(borderInterpolate(100, img.rows, BORDER_REFLECT_101),
borderInterpolate(-5, img.cols, BORDER_WRAP)); borderInterpolate(-5, img.cols, BORDER_WRAP));
..
Normally, the function is not called directly; it is used inside Normally, the function is not called directly; it is used inside
:func:`FilterEngine` and :func:`FilterEngine` and
@ -421,9 +421,9 @@ See also:
:func:`FilterEngine`,:func:`copyMakeBorder` :func:`FilterEngine`,:func:`copyMakeBorder`
.. index:: boxFilter .. index:: boxFilter
cv::boxFilter boxFilter
------------- -------------
.. cfunction:: void boxFilter( const Mat\& src, Mat\& dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT ) .. c:function:: void boxFilter( const Mat\& src, Mat\& dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT )
Smoothes image using box filter Smoothes image using box filter
@ -459,9 +459,9 @@ See also:
.. index:: buildPyramid .. index:: buildPyramid
cv::buildPyramid buildPyramid
---------------- ----------------
.. cfunction:: void buildPyramid( const Mat\& src, vector<Mat>\& dst, int maxlevel ) .. c:function:: void buildPyramid( const Mat\& src, vector<Mat>\& dst, int maxlevel )
Constructs Gaussian pyramid for an image Constructs Gaussian pyramid for an image
@ -477,9 +477,9 @@ The function constructs a vector of images and builds the gaussian pyramid by re
.. index:: copyMakeBorder .. index:: copyMakeBorder
cv::copyMakeBorder copyMakeBorder
------------------ ------------------
.. cfunction:: void copyMakeBorder( const Mat\& src, Mat\& dst, int top, int bottom, int left, int right, int borderType, const Scalar\& value=Scalar() ) .. c:function:: void copyMakeBorder( const Mat\& src, Mat\& dst, int top, int bottom, int left, int right, int borderType, const Scalar\& value=Scalar() )
Forms a border around the image Forms a border around the image
@ -508,19 +508,19 @@ The function supports the mode when ``src`` is already in the middle of ``dst``
border, border, BORDER_REPLICATE); border, border, BORDER_REPLICATE);
// now do some custom filtering ... // now do some custom filtering ...
... ...
..
See also: See also:
:func:`borderInterpolate` :func:`borderInterpolate`
.. index:: createBoxFilter .. index:: createBoxFilter
cv::createBoxFilter createBoxFilter
------------------- -------------------
.. cfunction:: Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) .. c:function:: Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
.. cfunction:: Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1) .. c:function:: Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1)
.. cfunction:: Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1) .. c:function:: Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
Returns box filter engine Returns box filter engine
@ -549,9 +549,9 @@ See also:
.. index:: createDerivFilter .. index:: createDerivFilter
cv::createDerivFilter createDerivFilter
--------------------- ---------------------
.. cfunction:: Ptr<FilterEngine> createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT ) .. c:function:: Ptr<FilterEngine> createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT )
Returns engine for computing image derivatives Returns engine for computing image derivatives
@ -576,9 +576,9 @@ See also:
.. index:: createGaussianFilter .. index:: createGaussianFilter
cv::createGaussianFilter createGaussianFilter
------------------------ ------------------------
.. cfunction:: Ptr<FilterEngine> createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT) .. c:function:: Ptr<FilterEngine> createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
Returns engine for smoothing images with a Gaussian filter Returns engine for smoothing images with a Gaussian filter
@ -599,11 +599,11 @@ See also:
.. index:: createLinearFilter .. index:: createLinearFilter
cv::createLinearFilter createLinearFilter
---------------------- ----------------------
.. cfunction:: Ptr<FilterEngine> createLinearFilter(int srcType, int dstType, const Mat\& kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar\& borderValue=Scalar()) .. c:function:: Ptr<FilterEngine> createLinearFilter(int srcType, int dstType, const Mat\& kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar\& borderValue=Scalar())
.. cfunction:: Ptr<BaseFilter> getLinearFilter(int srcType, int dstType, const Mat\& kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) .. c:function:: Ptr<BaseFilter> getLinearFilter(int srcType, int dstType, const Mat\& kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
Creates non-separable linear filter engine Creates non-separable linear filter engine
@ -629,17 +629,17 @@ See also:
:func:`createSeparableLinearFilter`,:func:`FilterEngine`,:func:`filter2D` :func:`createSeparableLinearFilter`,:func:`FilterEngine`,:func:`filter2D`
.. index:: createMorphologyFilter .. index:: createMorphologyFilter
cv::createMorphologyFilter createMorphologyFilter
-------------------------- --------------------------
.. cfunction:: Ptr<FilterEngine> createMorphologyFilter(int op, int type, const Mat\& element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar\& borderValue=morphologyDefaultBorderValue()) .. c:function:: Ptr<FilterEngine> createMorphologyFilter(int op, int type, const Mat\& element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar\& borderValue=morphologyDefaultBorderValue())
.. cfunction:: Ptr<BaseFilter> getMorphologyFilter(int op, int type, const Mat\& element, Point anchor=Point(-1,-1)) .. c:function:: Ptr<BaseFilter> getMorphologyFilter(int op, int type, const Mat\& element, Point anchor=Point(-1,-1))
.. cfunction:: Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int esize, int anchor=-1) .. c:function:: Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int esize, int anchor=-1)
.. cfunction:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1) .. c:function:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1)
.. cfunction:: static inline Scalar morphologyDefaultBorderValue(){ return Scalar::all(DBL_MAX) } .. c:function:: static inline Scalar morphologyDefaultBorderValue(){ return Scalar::all(DBL_MAX) }
Creates engine for non-separable morphological operations Creates engine for non-separable morphological operations
@ -665,13 +665,13 @@ See also:
:func:`erode`,:func:`dilate`,:func:`morphologyEx`,:func:`FilterEngine` :func:`erode`,:func:`dilate`,:func:`morphologyEx`,:func:`FilterEngine`
.. index:: createSeparableLinearFilter .. index:: createSeparableLinearFilter
cv::createSeparableLinearFilter createSeparableLinearFilter
------------------------------- -------------------------------
.. cfunction:: Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType, const Mat\& rowKernel, const Mat\& columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar\& borderValue=Scalar()) .. c:function:: Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType, const Mat\& rowKernel, const Mat\& columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar\& borderValue=Scalar())
.. cfunction:: Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType, const Mat\& columnKernel, int anchor, int symmetryType, double delta=0, int bits=0) .. c:function:: Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType, const Mat\& columnKernel, int anchor, int symmetryType, double delta=0, int bits=0)
.. cfunction:: Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType, const Mat\& rowKernel, int anchor, int symmetryType) .. c:function:: Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType, const Mat\& rowKernel, int anchor, int symmetryType)
Creates engine for separable linear filter Creates engine for separable linear filter
@ -705,9 +705,9 @@ See also:
:func:`sepFilter2D`,:func:`createLinearFilter`,:func:`FilterEngine`,:func:`getKernelType` :func:`sepFilter2D`,:func:`createLinearFilter`,:func:`FilterEngine`,:func:`getKernelType`
.. index:: dilate .. index:: dilate
cv::dilate dilate
---------- ----------
.. cfunction:: void dilate( const Mat\& src, Mat\& dst, const Mat\& element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar\& borderValue=morphologyDefaultBorderValue() ) .. c:function:: void dilate( const Mat\& src, Mat\& dst, const Mat\& 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. Dilates an image by using a specific structuring element.
@ -734,9 +734,9 @@ See also:
:func:`erode`,:func:`morphologyEx`,:func:`createMorphologyFilter` :func:`erode`,:func:`morphologyEx`,:func:`createMorphologyFilter`
.. index:: erode .. index:: erode
cv::erode erode
--------- ---------
.. cfunction:: void erode( const Mat\& src, Mat\& dst, const Mat\& element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar\& borderValue=morphologyDefaultBorderValue() ) .. c:function:: void erode( const Mat\& src, Mat\& dst, const Mat\& 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. Erodes an image by using a specific structuring element.
@ -763,9 +763,9 @@ See also:
:func:`dilate`,:func:`morphologyEx`,:func:`createMorphologyFilter` :func:`dilate`,:func:`morphologyEx`,:func:`createMorphologyFilter`
.. index:: filter2D .. index:: filter2D
cv::filter2D filter2D
------------ ------------
.. cfunction:: void filter2D( const Mat\& src, Mat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) .. c:function:: void filter2D( const Mat\& src, Mat\& dst, int ddepth, const Mat\& kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
Convolves an image with the kernel Convolves an image with the kernel
@ -799,9 +799,9 @@ See also:
:func:`sepFilter2D`,:func:`createLinearFilter`,:func:`dft`,:func:`matchTemplate` :func:`sepFilter2D`,:func:`createLinearFilter`,:func:`dft`,:func:`matchTemplate`
.. index:: GaussianBlur .. index:: GaussianBlur
cv::GaussianBlur GaussianBlur
---------------- ----------------
.. cfunction:: void GaussianBlur( const Mat\& src, Mat\& dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT ) .. c:function:: void GaussianBlur( const Mat\& src, Mat\& dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT )
Smoothes image using a Gaussian filter Smoothes image using a Gaussian filter
@ -817,9 +817,9 @@ See also:
:func:`sepFilter2D`,:func:`filter2D`,:func:`blur`,:func:`boxFilter`,:func:`bilateralFilter`,:func:`medianBlur` :func:`sepFilter2D`,:func:`filter2D`,:func:`blur`,:func:`boxFilter`,:func:`bilateralFilter`,:func:`medianBlur`
.. index:: getDerivKernels .. index:: getDerivKernels
cv::getDerivKernels getDerivKernels
------------------- -------------------
.. cfunction:: void getDerivKernels( Mat\& kx, Mat\& ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F ) .. c:function:: void getDerivKernels( Mat\& kx, Mat\& ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F )
Returns filter coefficients for computing spatial image derivatives Returns filter coefficients for computing spatial image derivatives
@ -843,9 +843,9 @@ The function computes and returns the filter coefficients for spatial image deri
.. index:: getGaussianKernel .. index:: getGaussianKernel
cv::getGaussianKernel getGaussianKernel
--------------------- ---------------------
.. cfunction:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F ) .. c:function:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F )
Returns Gaussian filter coefficients Returns Gaussian filter coefficients
@ -873,9 +873,9 @@ See also:
.. index:: getKernelType .. index:: getKernelType
cv::getKernelType getKernelType
----------------- -----------------
.. cfunction:: int getKernelType(const Mat\& kernel, Point anchor) .. c:function:: int getKernelType(const Mat\& kernel, Point anchor)
Returns the kernel type Returns the kernel type
@ -895,9 +895,9 @@ The function analyzes the kernel coefficients and returns the corresponding kern
* **KERNEL_INTEGER** Al the kernel coefficients are integer numbers. This flag can be combined with ``KERNEL_SYMMETRICAL`` or ``KERNEL_ASYMMETRICAL`` * **KERNEL_INTEGER** Al the kernel coefficients are integer numbers. This flag can be combined with ``KERNEL_SYMMETRICAL`` or ``KERNEL_ASYMMETRICAL``
.. index:: getStructuringElement .. index:: getStructuringElement
cv::getStructuringElement getStructuringElement
------------------------- -------------------------
.. cfunction:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1)) .. c:function:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1))
Returns the structuring element of the specified size and shape for morphological operations Returns the structuring element of the specified size and shape for morphological operations
@ -927,9 +927,9 @@ The function constructs and returns the structuring element that can be then pas
.. index:: medianBlur .. index:: medianBlur
cv::medianBlur medianBlur
-------------- --------------
.. cfunction:: void medianBlur( const Mat\& src, Mat\& dst, int ksize ) .. c:function:: void medianBlur( const Mat\& src, Mat\& dst, int ksize )
Smoothes image using median filter Smoothes image using median filter
@ -944,9 +944,9 @@ See also:
:func:`bilateralFilter`,:func:`blur`,:func:`boxFilter`,:func:`GaussianBlur` :func:`bilateralFilter`,:func:`blur`,:func:`boxFilter`,:func:`GaussianBlur`
.. index:: morphologyEx .. index:: morphologyEx
cv::morphologyEx morphologyEx
---------------- ----------------
.. cfunction:: void morphologyEx( const Mat\& src, Mat\& dst, int op, const Mat\& element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar\& borderValue=morphologyDefaultBorderValue() ) .. c:function:: void morphologyEx( const Mat\& src, Mat\& dst, int op, const Mat\& element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar\& borderValue=morphologyDefaultBorderValue() )
Performs advanced morphological transformations Performs advanced morphological transformations
@ -1009,9 +1009,9 @@ See also:
:func:`dilate`,:func:`erode`,:func:`createMorphologyFilter` :func:`dilate`,:func:`erode`,:func:`createMorphologyFilter`
.. index:: Laplacian .. index:: Laplacian
cv::Laplacian Laplacian
------------- -------------
.. cfunction:: void Laplacian( const Mat\& src, Mat\& dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) .. c:function:: void Laplacian( const Mat\& src, Mat\& dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
Calculates the Laplacian of an image Calculates the Laplacian of an image
@ -1043,9 +1043,9 @@ See also:
:func:`Sobel`,:func:`Scharr` :func:`Sobel`,:func:`Scharr`
.. index:: pyrDown .. index:: pyrDown
cv::pyrDown pyrDown
----------- -----------
.. cfunction:: void pyrDown( const Mat\& src, Mat\& dst, const Size\& dstsize=Size()) .. c:function:: void pyrDown( const Mat\& src, Mat\& dst, const Size\& dstsize=Size())
Smoothes an image and downsamples it. Smoothes an image and downsamples it.
@ -1069,9 +1069,9 @@ and then downsamples the image by rejecting even rows and columns.
.. index:: pyrUp .. index:: pyrUp
cv::pyrUp pyrUp
--------- ---------
.. cfunction:: void pyrUp( const Mat\& src, Mat\& dst, const Size\& dstsize=Size()) .. c:function:: void pyrUp( const Mat\& src, Mat\& dst, const Size\& dstsize=Size())
Upsamples an image and then smoothes it Upsamples an image and then smoothes it
@ -1090,9 +1090,9 @@ The function performs the upsampling step of the Gaussian pyramid construction (
.. index:: sepFilter2D .. index:: sepFilter2D
cv::sepFilter2D sepFilter2D
--------------- ---------------
.. cfunction:: void sepFilter2D( const Mat\& src, Mat\& dst, int ddepth, const Mat\& rowKernel, const Mat\& columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) .. c:function:: void sepFilter2D( const Mat\& src, Mat\& dst, int ddepth, const Mat\& rowKernel, const Mat\& columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT )
Applies separable linear filter to an image Applies separable linear filter to an image
@ -1117,9 +1117,9 @@ See also:
.. index:: Sobel .. index:: Sobel
cv::Sobel Sobel
--------- ---------
.. cfunction:: void Sobel( const Mat\& src, Mat\& dst, int ddepth, int xorder, int yorder, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) .. c:function:: void Sobel( const Mat\& src, Mat\& 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 Calculates the first, second, third or mixed image derivatives using an extended Sobel operator
@ -1183,9 +1183,9 @@ See also:
:func:`Scharr`,:func:`Lapacian`,:func:`sepFilter2D`,:func:`filter2D`,:func:`GaussianBlur` :func:`Scharr`,:func:`Lapacian`,:func:`sepFilter2D`,:func:`filter2D`,:func:`GaussianBlur`
.. index:: Scharr .. index:: Scharr
cv::Scharr Scharr
---------- ----------
.. cfunction:: void Scharr( const Mat\& src, Mat\& dst, int ddepth, int xorder, int yorder, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) .. c:function:: void Scharr( const Mat\& src, Mat\& 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 Calculates the first x- or y- image derivative using Scharr operator

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

@ -36,9 +36,9 @@ The actual implementations of the geometrical transformations, from the most gen
.. index:: convertMaps .. index:: convertMaps
cv::convertMaps convertMaps
--------------- ---------------
.. cfunction:: void convertMaps( const Mat\& map1, const Mat\& map2, Mat\& dstmap1, Mat\& dstmap2, int dstmap1type, bool nninterpolation=false ) .. c:function:: void convertMaps( const Mat\& map1, const Mat\& map2, Mat\& dstmap1, Mat\& dstmap2, int dstmap1type, bool nninterpolation=false )
Converts image transformation maps from one representation to another Converts image transformation maps from one representation to another
@ -68,9 +68,9 @@ See also:
:func:`remap`,:func:`undisort`,:func:`initUndistortRectifyMap` :func:`remap`,:func:`undisort`,:func:`initUndistortRectifyMap`
.. index:: getAffineTransform .. index:: getAffineTransform
cv::getAffineTransform getAffineTransform
---------------------- ----------------------
.. cfunction:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] ) .. c:function:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] )
Calculates the affine transform from 3 pairs of the corresponding points Calculates the affine transform from 3 pairs of the corresponding points
@ -97,9 +97,9 @@ See also:
:func:`warpAffine`,:func:`transform` :func:`warpAffine`,:func:`transform`
.. index:: getPerspectiveTransform .. index:: getPerspectiveTransform
cv::getPerspectiveTransform getPerspectiveTransform
--------------------------- ---------------------------
.. cfunction:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] ) .. c:function:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] )
Calculates the perspective transform from 4 pairs of the corresponding points Calculates the perspective transform from 4 pairs of the corresponding points
@ -126,9 +126,9 @@ See also:
:func:`findHomography`,:func:`warpPerspective`,:func:`perspectiveTransform` :func:`findHomography`,:func:`warpPerspective`,:func:`perspectiveTransform`
.. index:: getRectSubPix .. index:: getRectSubPix
cv::getRectSubPix getRectSubPix
----------------- -----------------
.. cfunction:: void getRectSubPix( const Mat\& image, Size patchSize, Point2f center, Mat\& dst, int patchType=-1 ) .. c:function:: void getRectSubPix( const Mat\& image, Size patchSize, Point2f center, Mat\& dst, int patchType=-1 )
Retrieves the pixel rectangle from an image with sub-pixel accuracy Retrieves the pixel rectangle from an image with sub-pixel accuracy
@ -158,9 +158,9 @@ See also:
:func:`warpAffine`,:func:`warpPerspective` :func:`warpAffine`,:func:`warpPerspective`
.. index:: getRotationMatrix2D .. index:: getRotationMatrix2D
cv::getRotationMatrix2D getRotationMatrix2D
----------------------- -----------------------
.. cfunction:: Mat getRotationMatrix2D( Point2f center, double angle, double scale ) .. c:function:: Mat getRotationMatrix2D( Point2f center, double angle, double scale )
Calculates the affine matrix of 2d rotation. Calculates the affine matrix of 2d rotation.
@ -188,9 +188,9 @@ See also:
:func:`getAffineTransform`,:func:`warpAffine`,:func:`transform` :func:`getAffineTransform`,:func:`warpAffine`,:func:`transform`
.. index:: invertAffineTransform .. index:: invertAffineTransform
cv::invertAffineTransform invertAffineTransform
------------------------- -------------------------
.. cfunction:: void invertAffineTransform(const Mat\& M, Mat\& iM) .. c:function:: void invertAffineTransform(const Mat\& M, Mat\& iM)
Inverts an affine transformation Inverts an affine transformation
@ -210,9 +210,9 @@ The result will also be a
.. index:: remap .. index:: remap
cv::remap remap
--------- ---------
.. cfunction:: void remap( const Mat\& src, Mat\& dst, const Mat\& map1, const Mat\& map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar()) .. c:function:: void remap( const Mat\& src, Mat\& dst, const Mat\& map1, const Mat\& map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar())
Applies a generic geometrical transformation to an image. Applies a generic geometrical transformation to an image.
@ -252,9 +252,9 @@ This function can not operate in-place.
.. index:: resize .. index:: resize
cv::resize resize
---------- ----------
.. cfunction:: void resize( const Mat\& src, Mat\& dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR ) .. c:function:: void resize( const Mat\& src, Mat\& dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR )
Resizes an image Resizes an image
@ -300,28 +300,29 @@ Note that the initial ``dst`` type or size are not taken into account. Instead t
// explicitly specify dsize=dst.size(); fx and fy will be computed from that. // explicitly specify dsize=dst.size(); fx and fy will be computed from that.
resize(src, dst, dst.size(), 0, 0, interpolation); resize(src, dst, dst.size(), 0, 0, interpolation);
..
If you want to decimate the image by factor of 2 in each direction, you can call the function this way: :: If you want to decimate the image by factor of 2 in each direction, you can call the function this way: ::
// specify fx and fy and let the function to compute the destination image size. // specify fx and fy and let the function to compute the destination image size.
resize(src, dst, Size(), 0.5, 0.5, interpolation); resize(src, dst, Size(), 0.5, 0.5, interpolation);
..
See also: See also:
:func:`warpAffine`,:func:`warpPerspective`,:func:`remap` . :func:`warpAffine`,:func:`warpPerspective`,:func:`remap` .
.. index:: warpAffine .. index:: warpAffine
cv::warpAffine warpAffine
-------------- --------------
.. cfunction:: void warpAffine( const Mat\& src, Mat\& dst, const Mat\& M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar()) .. c:function:: void warpAffine( const Mat\& src, Mat\& dst, const Mat\& M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar())
Applies an affine transformation to an image. Applies an affine transformation to an image.
:param src: Source image :param src: Source image
:param dst: Destination image; will have size ``dsize`` and the same type as ``src`` :param dst: Destination image; will have size ``dsize`` and the same type as ``src``
:param M: :math:`2\times 3` transformation matrix :param M: :math:`2\times 3` transformation matrix
:param dsize: Size of the destination image :param dsize: Size of the destination image
@ -346,9 +347,9 @@ See also:
:func:`warpPerspective`,:func:`resize`,:func:`remap`,:func:`getRectSubPix`,:func:`transform` :func:`warpPerspective`,:func:`resize`,:func:`remap`,:func:`getRectSubPix`,:func:`transform`
.. index:: warpPerspective .. index:: warpPerspective
cv::warpPerspective warpPerspective
------------------- -------------------
.. cfunction:: void warpPerspective( const Mat\& src, Mat\& dst, const Mat\& M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar()) .. c:function:: void warpPerspective( const Mat\& src, Mat\& dst, const Mat\& M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar\& borderValue=Scalar())
Applies a perspective transformation to an image. Applies a perspective transformation to an image.

24
modules/imgproc/doc/histograms.rst
View File

@ -5,11 +5,11 @@ Histograms
.. index:: calcHist .. index:: calcHist
cv::calcHist calcHist
------------ ------------
.. cfunction:: void calcHist( const Mat* arrays, int narrays, const int* channels, const Mat\& mask, MatND\& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) .. c:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, const Mat\& mask, MatND\& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false )
.. cfunction:: void calcHist( const Mat* arrays, int narrays, const int* channels, const Mat\& mask, SparseMat\& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) .. c:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, const Mat\& mask, SparseMat\& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false )
Calculates histogram of a set of arrays Calculates histogram of a set of arrays
@ -93,15 +93,15 @@ input arrays. The sample below shows how to compute 2D Hue-Saturation histogram
imshow( "H-S Histogram", histImg ); imshow( "H-S Histogram", histImg );
waitKey(); waitKey();
} }
..
.. index:: calcBackProject .. index:: calcBackProject
cv::calcBackProject calcBackProject
------------------- -------------------
.. cfunction:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const MatND\& hist, Mat\& backProject, const float** ranges, double scale=1, bool uniform=true ) .. c:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const MatND\& hist, Mat\& backProject, const float** ranges, double scale=1, bool uniform=true )
.. cfunction:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const SparseMat\& hist, Mat\& backProject, const float** ranges, double scale=1, bool uniform=true ) .. c:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const SparseMat\& hist, Mat\& backProject, const float** ranges, double scale=1, bool uniform=true )
Calculates the back projection of a histogram. Calculates the back projection of a histogram.
@ -137,11 +137,11 @@ See also:
:func:`calcHist` :func:`calcHist`
.. index:: compareHist .. index:: compareHist
cv::compareHist compareHist
--------------- ---------------
.. cfunction:: double compareHist( const MatND\& H1, const MatND\& H2, int method ) .. c:function:: double compareHist( const MatND\& H1, const MatND\& H2, int method )
.. cfunction:: double compareHist( const SparseMat\& H1, const SparseMat\& H2, int method ) .. c:function:: double compareHist( const SparseMat\& H1, const SparseMat\& H2, int method )
Compares two histograms Compares two histograms
@ -201,9 +201,9 @@ While the function works well with 1-, 2-, 3-dimensional dense histograms, it ma
.. index:: equalizeHist .. index:: equalizeHist
cv::equalizeHist equalizeHist
---------------- ----------------
.. cfunction:: void equalizeHist( const Mat\& src, Mat\& dst ) .. c:function:: void equalizeHist( const Mat\& src, Mat\& dst )
Equalizes the histogram of a grayscale image. Equalizes the histogram of a grayscale image.

82
modules/imgproc/doc/miscellaneous_transformations.rst
View File

@ -5,15 +5,16 @@ Miscellaneous Image Transformations
.. index:: adaptiveThreshold .. index:: adaptiveThreshold
cv::adaptiveThreshold adaptiveThreshold
--------------------- ---------------------
.. cfunction:: void adaptiveThreshold( const Mat\& src, Mat\& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C ) .. c:function:: void adaptiveThreshold( const Mat& src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C )
Applies an adaptive threshold to an array. Applies an adaptive threshold to an array.
:param src: Source 8-bit single-channel image :param src: Source 8-bit single-channel image
:param dst: Destination image; will have the same size and the same type as ``src`` :param dst: Destination image; will have the same size and the same type as ``src``
:param maxValue: The non-zero value assigned to the pixels for which the condition is satisfied. See the discussion :param maxValue: The non-zero value assigned to the pixels for which the condition is satisfied. See the discussion
:param adaptiveMethod: Adaptive thresholding algorithm to use, ``ADAPTIVE_THRESH_MEAN_C`` or ``ADAPTIVE_THRESH_GAUSSIAN_C`` (see the discussion) :param adaptiveMethod: Adaptive thresholding algorithm to use, ``ADAPTIVE_THRESH_MEAN_C`` or ``ADAPTIVE_THRESH_GAUSSIAN_C`` (see the discussion)
@ -59,9 +60,9 @@ See also:
:func:`threshold`,:func:`blur`,:func:`GaussianBlur` :func:`threshold`,:func:`blur`,:func:`GaussianBlur`
.. index:: cvtColor .. index:: cvtColor
cv::cvtColor cvtColor
------------ ------------
.. cfunction:: void cvtColor( const Mat\& src, Mat\& dst, int code, int dstCn=0 ) .. c:function:: void cvtColor( const Mat& src, Mat& dst, int code, int dstCn=0 )
Converts image from one color space to another Converts image from one color space to another
@ -71,6 +72,7 @@ cv::cvtColor
:param code: The color space conversion code; see the discussion :param code: The color space conversion code; see the discussion
:param dstCn: The number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from ``src`` and the ``code`` :param dstCn: The number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from ``src`` and the ``code``
The function converts the input image from one color The function converts the input image from one color
space to another. In the case of transformation to-from RGB color space the ordering of the channels should be specified explicitly (RGB or BGR). space to another. In the case of transformation to-from RGB color space the ordering of the channels should be specified explicitly (RGB or BGR).
@ -91,7 +93,6 @@ but in the non-linear cases the input RGB image should be normalized to the prop
img *= 1./255; img *= 1./255;
cvtColor(img, img, CV_BGR2Luv); cvtColor(img, img, CV_BGR2Luv);
..
The function can do the following transformations: The function can do the following transformations:
@ -178,8 +179,7 @@ The function can do the following transformations:
Y, Cr and Cb cover the whole value range. Y, Cr and Cb cover the whole value range.
* *
RGB RGB :math:`\leftrightarrow` HSV ( ``CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB`` )
:math:`\leftrightarrow` HSV ( ``CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB`` )
in the case of 8-bit and 16-bit images in the case of 8-bit and 16-bit images
R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range
@ -218,8 +218,7 @@ The function can do the following transformations:
H, S, V are left as is H, S, V are left as is
* *
RGB RGB :math:`\leftrightarrow` HLS ( ``CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR, CV_HLS2RGB`` ).
:math:`\leftrightarrow` HLS ( ``CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR, CV_HLS2RGB`` ).
in the case of 8-bit and 16-bit images in the case of 8-bit and 16-bit images
R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range. R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range.
@ -269,8 +268,7 @@ The function can do the following transformations:
H, S, V are left as is H, S, V are left as is
* *
RGB RGB :math:`\leftrightarrow` CIE L*a*b* ( ``CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR, CV_Lab2RGB`` )
:math:`\leftrightarrow` CIE L*a*b* ( ``CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR, CV_Lab2RGB`` )
in the case of 8-bit and 16-bit images in the case of 8-bit and 16-bit images
R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range
@ -326,8 +324,7 @@ The function can do the following transformations:
L, a, b are left as is L, a, b are left as is
* *
RGB RGB :math:`\leftrightarrow` CIE L*u*v* ( ``CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR, CV_Luv2RGB`` )
:math:`\leftrightarrow` CIE L*u*v* ( ``CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR, CV_Luv2RGB`` )
in the case of 8-bit and 16-bit images in the case of 8-bit and 16-bit images
R, G and B are converted to floating-point format and scaled to fit 0 to 1 range R, G and B are converted to floating-point format and scaled to fit 0 to 1 range
@ -376,8 +373,7 @@ The function can do the following transformations:
http://www.poynton.com/ColorFAQ.html http://www.poynton.com/ColorFAQ.html
* *
Bayer Bayer :math:`\rightarrow` RGB ( ``CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB, CV_BayerRG2RGB, CV_BayerGR2RGB`` ) The Bayer pattern is widely used in CCD and CMOS cameras. It allows one to get color pictures from a single plane where R,G and B pixels (sensors of a particular component) are interleaved like this:
:math:`\rightarrow` RGB ( ``CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB, CV_BayerRG2RGB, CV_BayerGR2RGB`` ) The Bayer pattern is widely used in CCD and CMOS cameras. It allows one to get color pictures from a single plane where R,G and B pixels (sensors of a particular component) are interleaved like this:
.. math:: .. math::
@ -395,11 +391,11 @@ The function can do the following transformations:
.. index:: distanceTransform .. index:: distanceTransform
cv::distanceTransform distanceTransform
--------------------- ---------------------
.. cfunction:: void distanceTransform( const Mat\& src, Mat\& dst, int distanceType, int maskSize ) .. c:function:: void distanceTransform( const Mat& src, Mat& dst, int distanceType, int maskSize )
.. cfunction:: void distanceTransform( const Mat\& src, Mat\& dst, Mat\& labels, int distanceType, int maskSize ) .. c:function:: void distanceTransform( const Mat& src, Mat& dst, Mat& labels, int distanceType, int maskSize )
Calculates the distance to the closest zero pixel for each pixel of the source image. Calculates the distance to the closest zero pixel for each pixel of the source image.
@ -438,8 +434,12 @@ gives more accurate results). For ``a``,``b`` and ``c`` OpenCV uses the values s
.. table:: .. table::
============== =================== ====================== ``CV_DIST_C`` :math:`(3\times 3)` a = 1, b = 1 \ ============== =================== ======================
============== =================== ====================== ``CV_DIST_L1`` :math:`(3\times 3)` a = 1, b = 2 \ ``CV_DIST_L2`` :math:`(3\times 3)` a=0.955, b=1.3693 \ ``CV_DIST_L2`` :math:`(5\times 5)` a=1, b=1.4, c=2.1969 \ ``CV_DIST_C`` :math:`(3\times 3)` a = 1, b = 1 \
============== =================== ======================
``CV_DIST_L1`` :math:`(3\times 3)` a = 1, b = 2 \
``CV_DIST_L2`` :math:`(3\times 3)` a=0.955, b=1.3693 \
``CV_DIST_L2`` :math:`(5\times 5)` a=1, b=1.4, c=2.1969 \
============== =================== ====================== ============== =================== ======================
Typically, for a fast, coarse distance estimation ``CV_DIST_L2``,a Typically, for a fast, coarse distance estimation ``CV_DIST_L2``,a
@ -459,11 +459,11 @@ Currently, this second variant can only use the approximate distance transform a
.. index:: floodFill .. index:: floodFill
cv::floodFill floodFill
------------- -------------
.. cfunction:: int floodFill( Mat\& image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) .. c:function:: int floodFill( Mat& image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )
.. cfunction:: int floodFill( Mat\& image, Mat\& mask, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) .. c:function:: int floodFill( Mat& image, Mat& 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. Fills a connected component with the given color.
@ -544,9 +544,9 @@ See also:
:func:`findContours` :func:`findContours`
.. index:: inpaint .. index:: inpaint
cv::inpaint inpaint
----------- -----------
.. cfunction:: void inpaint( const Mat\& src, const Mat\& inpaintMask, Mat\& dst, double inpaintRadius, int flags ) .. c:function:: void inpaint( const Mat& src, const Mat& inpaintMask, Mat& dst, double inpaintRadius, int flags )
Inpaints the selected region in the image. Inpaints the selected region in the image.
@ -555,6 +555,7 @@ cv::inpaint
:param inpaintMask: The inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted. :param inpaintMask: The inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted.
:param dst: The output image; will have the same size and the same type as ``src`` :param dst: The output image; will have the same size and the same type as ``src``
:param inpaintRadius: The radius of a circlular neighborhood of each point inpainted that is considered by the algorithm. :param inpaintRadius: The radius of a circlular neighborhood of each point inpainted that is considered by the algorithm.
:param flags: The inpainting method, one of the following: :param flags: The inpainting method, one of the following:
@ -569,13 +570,13 @@ for more details.
.. index:: integral .. index:: integral
cv::integral integral
------------ ------------
.. cfunction:: void integral( const Mat\& image, Mat\& sum, int sdepth=-1 ) .. c:function:: void integral( const Mat& image, Mat& sum, int sdepth=-1 )
.. cfunction:: void integral( const Mat\& image, Mat\& sum, Mat\& sqsum, int sdepth=-1 ) .. c:function:: void integral( const Mat& image, Mat& sum, Mat& sqsum, int sdepth=-1 )
.. cfunction:: void integral( const Mat\& image, Mat\& sum, Mat\& sqsum, Mat\& tilted, int sdepth=-1 ) .. c:function:: void integral( const Mat& image, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth=-1 )
Calculates the integral of an image. Calculates the integral of an image.
@ -586,8 +587,10 @@ cv::integral
:param sqsum: The integral image for squared pixel values, :math:`(W+1)\times (H+1)` , double precision floating-point (64f) :param sqsum: The integral image for squared pixel values, :math:`(W+1)\times (H+1)` , double precision floating-point (64f)
:param tilted: The integral for the image rotated by 45 degrees, :math:`(W+1)\times (H+1)` , the same data type as ``sum`` :param tilted: The integral for the image rotated by 45 degrees, :math:`(W+1)\times (H+1)` , the same data type as ``sum``
:param sdepth: The desired depth of the integral and the tilted integral images, ``CV_32S`` , ``CV_32F`` or ``CV_64F`` :param sdepth: The desired depth of the integral and the tilted integral images, ``CV_32S`` , ``CV_32F`` or ``CV_64F``
The functions ``integral`` calculate one or more integral images for the source image as following:
The functions calculate one or more integral images for the source image as following:
.. math:: .. math::
@ -619,15 +622,16 @@ As a practical example, the next figure shows the calculation of the integral of
.. index:: threshold .. index:: threshold
cv::threshold threshold
------------- -------------
.. cfunction:: double threshold( const Mat\& src, Mat\& dst, double thresh, double maxVal, int thresholdType ) .. c:function:: double threshold( const Mat& src, Mat& dst, double thresh, double maxVal, int thresholdType )
Applies a fixed-level threshold to each array element Applies a fixed-level threshold to each array element
:param src: Source array (single-channel, 8-bit of 32-bit floating point) :param src: Source array (single-channel, 8-bit of 32-bit floating point)
:param dst: Destination array; will have the same size and the same type as ``src`` :param dst: Destination array; will have the same size and the same type as ``src``
:param thresh: Threshold value :param thresh: Threshold value
:param maxVal: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` thresholding types :param maxVal: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` thresholding types
@ -684,15 +688,16 @@ See also:
:func:`adaptiveThreshold`,:func:`findContours`,:func:`compare`,:func:`min`,:func:`max` :func:`adaptiveThreshold`,:func:`findContours`,:func:`compare`,:func:`min`,:func:`max`
.. index:: watershed .. index:: watershed
cv::watershed watershed
------------- -------------
.. cfunction:: void watershed( const Mat\& image, Mat\& markers ) .. c:function:: void watershed( const Mat& image, Mat& markers )
Does marker-based image segmentation using watershed algrorithm Does marker-based image segmentation using watershed algrorithm
:param image: The input 8-bit 3-channel image. :param image: The input 8-bit 3-channel image.
:param markers: The input/output 32-bit single-channel image (map) of markers. It should have the same size as ``image`` :param markers: The input/output 32-bit single-channel image (map) of markers. It should have the same size as ``image``
The function implements one of the variants The function implements one of the variants
of watershed, non-parametric marker-based segmentation algorithm, of watershed, non-parametric marker-based segmentation algorithm,
described in described in
@ -722,9 +727,9 @@ See also:
:func:`findContours` :func:`findContours`
.. index:: grabCut .. index:: grabCut
cv::grabCut grabCut
----------- -----------
.. cfunction:: void grabCut(const Mat\& image, Mat\& mask, Rect rect, Mat\& bgdModel, Mat\& fgdModel, int iterCount, int mode ) .. c:function:: void grabCut(const Mat& image, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode )
Runs GrabCut algorithm Runs GrabCut algorithm
@ -740,15 +745,16 @@ cv::grabCut
* **GC_PR_BGD** Likely a foreground pixel * **GC_PR_BGD** Likely a foreground pixel
:param rect: The ROI containing the segmented object. The pixels outside of the ROI are marked as "certainly a background". The parameter is only used when ``mode==GC_INIT_WITH_RECT`` :param rect: The ROI containing the segmented object. The pixels outside of the ROI are marked as "certainly a background". The parameter is only used when ``mode==GC_INIT_WITH_RECT``
:param bgdModel, fgdModel: Temporary arrays used for segmentation. Do not modify them while you are processing the same image :param bgdModel, fgdModel: Temporary arrays used for segmentation. Do not modify them while you are processing the same image
:param iterCount: The number of iterations the algorithm should do before returning the result. Note that the result can be refined with further calls with the ``mode==GC_INIT_WITH_MASK`` or ``mode==GC_EVAL`` :param iterCount: The number of iterations the algorithm should do before returning the result. Note that the result can be refined with further calls with the ``mode==GC_INIT_WITH_MASK`` or ``mode==GC_EVAL``
:param mode: The operation mode :param mode: The operation mode
* **GC_INIT_WITH_RECT** The function initializes the state and the mask using the provided rectangle. After that it runs ``iterCount`` iterations of the algorithm * **GC_INIT_WITH_RECT** The function initializes the state and the mask using the provided rectangle. After that it runs ``iterCount`` iterations of the algorithm
* **GC_INIT_WITH_MASK** The function initializes the state using the provided mask. Note that ``GC_INIT_WITH_RECT`` and ``GC_INIT_WITH_MASK`` can be combined, then all the pixels outside of the ROI are automatically initialized with ``GC_BGD`` * **GC_INIT_WITH_MASK** The function initializes the state using the provided mask. Note that ``GC_INIT_WITH_RECT`` and ``GC_INIT_WITH_MASK`` can be combined, then all the pixels outside of the ROI are automatically initialized with ``GC_BGD``.
.
* **GC_EVAL** The value means that algorithm should just resume. * **GC_EVAL** The value means that algorithm should just resume.

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

@ -5,9 +5,9 @@ Motion Analysis and Object Tracking
.. index:: accumulate .. index:: accumulate
cv::accumulate accumulate
-------------- --------------
.. cfunction:: void accumulate( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() ) .. c:function:: void accumulate( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() )
Adds image to the accumulator. Adds image to the accumulator.
@ -31,9 +31,9 @@ See also:
:func:`accumulateSquare`,:func:`accumulateProduct`,:func:`accumulateWeighted` :func:`accumulateSquare`,:func:`accumulateProduct`,:func:`accumulateWeighted`
.. index:: accumulateSquare .. index:: accumulateSquare
cv::accumulateSquare accumulateSquare
-------------------- --------------------
.. cfunction:: void accumulateSquare( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() ) .. c:function:: void accumulateSquare( const Mat\& src, Mat\& dst, const Mat\& mask=Mat() )
Adds the square of the source image to the accumulator. Adds the square of the source image to the accumulator.
@ -55,9 +55,9 @@ See also:
:func:`accumulateSquare`,:func:`accumulateProduct`,:func:`accumulateWeighted` :func:`accumulateSquare`,:func:`accumulateProduct`,:func:`accumulateWeighted`
.. index:: accumulateProduct .. index:: accumulateProduct
cv::accumulateProduct accumulateProduct
--------------------- ---------------------
.. cfunction:: void accumulateProduct( const Mat\& src1, const Mat\& src2, Mat\& dst, const Mat\& mask=Mat() ) .. c:function:: void accumulateProduct( const Mat\& src1, const Mat\& src2, Mat\& dst, const Mat\& mask=Mat() )
Adds the per-element product of two input images to the accumulator. Adds the per-element product of two input images to the accumulator.
@ -80,9 +80,9 @@ See also:
:func:`accumulate`,:func:`accumulateSquare`,:func:`accumulateWeighted` :func:`accumulate`,:func:`accumulateSquare`,:func:`accumulateWeighted`
.. index:: accumulateWeighted .. index:: accumulateWeighted
cv::accumulateWeighted accumulateWeighted
---------------------- ----------------------
.. cfunction:: void accumulateWeighted( const Mat\& src, Mat\& dst, double alpha, const Mat\& mask=Mat() ) .. c:function:: void accumulateWeighted( const Mat\& src, Mat\& dst, double alpha, const Mat\& mask=Mat() )
Updates the running average. Updates the running average.

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

@ -5,9 +5,9 @@ Object Detection
.. index:: matchTemplate .. index:: matchTemplate
cv::matchTemplate matchTemplate
----------------- -----------------
.. cfunction:: void matchTemplate( const Mat\& image, const Mat\& templ, Mat\& result, int method ) .. c:function:: void matchTemplate( const Mat\& image, const Mat\& templ, Mat\& result, int method )
Compares a template against overlapped image regions. Compares a template against overlapped image regions.

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

@ -5,9 +5,9 @@ Structural Analysis and Shape Descriptors
.. index:: moments .. index:: moments
cv::moments moments
----------- -----------
.. cfunction:: Moments moments( const Mat\& array, bool binaryImage=false ) .. c:function:: Moments moments( const Mat& array, bool binaryImage=false )
Calculates all of the moments up to the third order of a polygon or rasterized shape. Calculates all of the moments up to the third order of a polygon or rasterized shape.
@ -29,7 +29,6 @@ where the class ``Moments`` is defined as: ::
// central normalized moments // central normalized moments
double nu20, nu11, nu02, nu30, nu21, nu12, nu03; double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
}; };
..
:param array: A raster image (single-channel, 8-bit or floating-point 2D array) or an array :param array: A raster image (single-channel, 8-bit or floating-point 2D array) or an array
( :math:`1 \times N` or :math:`N \times 1` ) of 2D points ( ``Point`` or ``Point2f`` ) ( :math:`1 \times N` or :math:`N \times 1` ) of 2D points ( ``Point`` or ``Point2f`` )
@ -77,9 +76,9 @@ See also:
:func:`contourArea`,:func:`arcLength` :func:`contourArea`,:func:`arcLength`
.. index:: HuMoments .. index:: HuMoments
cv::HuMoments HuMoments
------------- -------------
.. cfunction:: void HuMoments( const Moments\& moments, double h[7] ) .. c:function:: void HuMoments( const Moments& moments, double h[7] )
Calculates the seven Hu invariants. Calculates the seven Hu invariants.
@ -104,11 +103,11 @@ See also:
:func:`matchShapes` :func:`matchShapes`
.. index:: findContours .. index:: findContours
cv::findContours findContours
---------------- ----------------
.. cfunction:: void findContours( const Mat\& image, vector<vector<Point> >\& contours, vector<Vec4i>\& hierarchy, int mode, int method, Point offset=Point()) .. c:function:: void findContours( const Mat& image, vector<vector<Point> >& contours, vector<Vec4i>& hierarchy, int mode, int method, Point offset=Point())
.. cfunction:: void findContours( const Mat\& image, vector<vector<Point> >\& contours, int mode, int method, Point offset=Point()) .. c:function:: void findContours( const Mat& image, vector<vector<Point> >& contours, int mode, int method, Point offset=Point())
Finds the contours in a binary image. Finds the contours in a binary image.
@ -148,9 +147,9 @@ the source ``image`` is modified by this function.
.. index:: drawContours .. index:: drawContours
cv::drawContours drawContours
---------------- ----------------
.. cfunction:: void drawContours( Mat\& image, const vector<vector<Point> >\& contours, int contourIdx, const Scalar\& color, int thickness=1, int lineType=8, const vector<Vec4i>\& hierarchy=vector<Vec4i>(), int maxLevel=INT_MAX, Point offset=Point() ) .. c:function:: void drawContours( Mat& image, const vector<vector<Point> >& contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, const vector<Vec4i>& hierarchy=vector<Vec4i>(), int maxLevel=INT_MAX, Point offset=Point() )
Draws contours' outlines or filled contours. Draws contours' outlines or filled contours.
@ -174,6 +173,7 @@ cv::drawContours
the specified contour is drawn. If 1, the function draws the contour(s) and all the nested contours. If 2, the function draws the contours, all the nested contours and all the nested into nested contours etc. This parameter is only taken into account when there is ``hierarchy`` available. the specified contour is drawn. If 1, the function draws the contour(s) and all the nested contours. If 2, the function draws the contours, all the nested contours and all the nested into nested contours etc. This parameter is only taken into account when there is ``hierarchy`` available.
:param offset: The optional contour shift parameter. Shift all the drawn contours by the specified :math:`\texttt{offset}=(dx,dy)` :param offset: The optional contour shift parameter. Shift all the drawn contours by the specified :math:`\texttt{offset}=(dx,dy)`
The function draws contour outlines in the image if The function draws contour outlines in the image if
:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if :math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
:math:`\texttt{thickness}<0` . Here is the example on how to retrieve connected components from the binary image and label them :: :math:`\texttt{thickness}<0` . Here is the example on how to retrieve connected components from the binary image and label them ::
@ -216,15 +216,14 @@ The function draws contour outlines in the image if
imshow( "Components", dst ); imshow( "Components", dst );
waitKey(0); waitKey(0);
} }
..
.. index:: approxPolyDP .. index:: approxPolyDP
cv::approxPolyDP approxPolyDP
---------------- ----------------
.. cfunction:: void approxPolyDP( const Mat\& curve, vector<Point>\& approxCurve, double epsilon, bool closed ) .. c:function:: void approxPolyDP( const Mat& curve, vector<Point>& approxCurve, double epsilon, bool closed )
.. cfunction:: void approxPolyDP( const Mat\& curve, vector<Point2f>\& approxCurve, double epsilon, bool closed ) .. c:function:: void approxPolyDP( const Mat& curve, vector<Point2f>& approxCurve, double epsilon, bool closed )
Approximates polygonal curve(s) with the specified precision. Approximates polygonal curve(s) with the specified precision.
@ -241,9 +240,9 @@ http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
.. index:: arcLength .. index:: arcLength
cv::arcLength arcLength
------------- -------------
.. cfunction:: double arcLength( const Mat\& curve, bool closed ) .. c:function:: double arcLength( const Mat& curve, bool closed )
Calculates a contour perimeter or a curve length. Calculates a contour perimeter or a curve length.
@ -255,9 +254,9 @@ The function computes the curve length or the closed contour perimeter.
.. index:: boundingRect .. index:: boundingRect
cv::boundingRect boundingRect
---------------- ----------------
.. cfunction:: Rect boundingRect( const Mat\& points ) .. c:function:: Rect boundingRect( const Mat& points )
Calculates the up-right bounding rectangle of a point set. Calculates the up-right bounding rectangle of a point set.
@ -267,9 +266,9 @@ The function calculates and returns the minimal up-right bounding rectangle for
.. index:: estimateRigidTransform .. index:: estimateRigidTransform
cv::estimateRigidTransform estimateRigidTransform
-------------------------- --------------------------
.. cfunction:: Mat estimateRigidTransform( const Mat\& srcpt, const Mat\& dstpt, bool fullAffine ) .. c:function:: Mat estimateRigidTransform( const Mat& srcpt, const Mat& dstpt, bool fullAffine )
Computes optimal affine transformation between two 2D point sets Computes optimal affine transformation between two 2D point sets
@ -301,9 +300,9 @@ See also:
:func:`getAffineTransform`,:func:`getPerspectiveTransform`,:func:`findHomography` :func:`getAffineTransform`,:func:`getPerspectiveTransform`,:func:`findHomography`
.. index:: estimateAffine3D .. index:: estimateAffine3D
cv::estimateAffine3D estimateAffine3D
-------------------- --------------------
.. cfunction:: int estimateAffine3D(const Mat\& srcpt, const Mat\& dstpt, Mat\& out, vector<uchar>\& outliers, double ransacThreshold = 3.0, double confidence = 0.99) .. c:function:: int estimateAffine3D(const Mat& srcpt, const Mat& dstpt, Mat& out, vector<uchar>& outliers, double ransacThreshold = 3.0, double confidence = 0.99)
Computes optimal affine transformation between two 3D point sets Computes optimal affine transformation between two 3D point sets
@ -322,9 +321,9 @@ The function estimates the optimal 3D affine transformation between two 3D point
.. index:: contourArea .. index:: contourArea
cv::contourArea contourArea
--------------- ---------------
.. cfunction:: double contourArea( const Mat\& contour ) .. c:function:: double contourArea( const Mat& contour )
Calculates the contour area Calculates the contour area
@ -350,17 +349,16 @@ Here is a short example: ::
cout << "area0 =" << area0 << endl << cout << "area0 =" << area0 << endl <<
"area1 =" << area1 << endl << "area1 =" << area1 << endl <<
"approx poly vertices" << approx.size() << endl; "approx poly vertices" << approx.size() << endl;
..
.. index:: convexHull .. index:: convexHull
cv::convexHull convexHull
-------------- --------------
.. cfunction:: void convexHull( const Mat\& points, vector<int>\& hull, bool clockwise=false ) .. c:function:: void convexHull( const Mat& points, vector<int>& hull, bool clockwise=false )
.. cfunction:: void convexHull( const Mat\& points, vector<Point>\& hull, bool clockwise=false ) .. c:function:: void convexHull( const Mat& points, vector<Point>& hull, bool clockwise=false )
.. cfunction:: void convexHull( const Mat\& points, vector<Point2f>\& hull, bool clockwise=false ) .. c:function:: void convexHull( const Mat& points, vector<Point2f>& hull, bool clockwise=false )
Finds the convex hull of a point set. Finds the convex hull of a point set.
@ -380,9 +378,9 @@ that has
.. index:: fitEllipse .. index:: fitEllipse
cv::fitEllipse fitEllipse
-------------- --------------
.. cfunction:: RotatedRect fitEllipse( const Mat\& points ) .. c:function:: RotatedRect fitEllipse( const Mat& points )
Fits an ellipse around a set of 2D points. Fits an ellipse around a set of 2D points.
@ -393,22 +391,20 @@ The function calculates the ellipse that fits best
.. index:: fitLine .. index:: fitLine
cv::fitLine fitLine
----------- -----------
.. cfunction:: void fitLine( const Mat\& points, Vec4f\& line, int distType, double param, double reps, double aeps ) .. c:function:: void fitLine( const Mat& points, Vec4f& line, int distType, double param, double reps, double aeps )
.. cfunction:: void fitLine( const Mat\& points, Vec6f\& line, int distType, double param, double reps, double aeps ) .. c:function:: void fitLine( const Mat& points, Vec6f& line, int distType, double param, double reps, double aeps )
Fits a line to a 2D or 3D point set. Fits a line to a 2D or 3D point set.
:param points: The input 2D point set, represented by ``CV_32SC2`` or ``CV_32FC2`` matrix, or by ``vector<Point>`` , ``vector<Point2f>`` , ``vector<Point3i>`` or ``vector<Point3f>`` converted to the matrix by ``Mat(const vector<T>&)`` constructor :param points: The input 2D point set, represented by ``CV_32SC2`` or ``CV_32FC2`` matrix, or by ``vector<Point>`` , ``vector<Point2f>`` , ``vector<Point3i>`` or ``vector<Point3f>`` converted to the matrix by ``Mat(const vector<T>&)`` constructor
:param line: The output line parameters. In the case of a 2d fitting, :param line: The output line parameters. In the case of a 2d fitting,
it is a vector of 4 floats ``(vx, vy, it is a vector of 4 floats ``(vx, vy, x0, y0)`` where ``(vx, vy)`` is a normalized vector collinear to the
x0, y0)`` where ``(vx, vy)`` is a normalized vector collinear to the
line and ``(x0, y0)`` is some point on the line. in the case of a line and ``(x0, y0)`` is some point on the line. in the case of a
3D fitting it is vector of 6 floats ``(vx, vy, vz, x0, y0, z0)`` where ``(vx, vy, vz)`` is a normalized vector collinear to the line 3D fitting it is vector of 6 floats ``(vx, vy, vz, x0, y0, z0)`` where ``(vx, vy, vz)`` is a normalized vector collinear to the line and ``(x0, y0, z0)`` is some point on the line
and ``(x0, y0, z0)`` is some point on the line
:param distType: The distance used by the M-estimator (see the discussion) :param distType: The distance used by the M-estimator (see the discussion)
@ -466,9 +462,9 @@ http://en.wikipedia.org/wiki/M-estimator
.. index:: isContourConvex .. index:: isContourConvex
cv::isContourConvex isContourConvex
------------------- -------------------
.. cfunction:: bool isContourConvex( const Mat\& contour ) .. c:function:: bool isContourConvex( const Mat& contour )
Tests contour convexity. Tests contour convexity.
@ -478,9 +474,9 @@ The function tests whether the input contour is convex or not. The contour must
.. index:: minAreaRect .. index:: minAreaRect
cv::minAreaRect minAreaRect
--------------- ---------------
.. cfunction:: RotatedRect minAreaRect( const Mat\& points ) .. c:function:: RotatedRect minAreaRect( const Mat& points )
Finds the minimum area rotated rectangle enclosing a 2D point set. Finds the minimum area rotated rectangle enclosing a 2D point set.
@ -489,9 +485,9 @@ cv::minAreaRect
The function calculates and returns the minimum area bounding rectangle (possibly rotated) for the specified point set. See the OpenCV sample ``minarea.c`` The function calculates and returns the minimum area bounding rectangle (possibly rotated) for the specified point set. See the OpenCV sample ``minarea.c``
.. index:: minEnclosingCircle .. index:: minEnclosingCircle
cv::minEnclosingCircle minEnclosingCircle
---------------------- ----------------------
.. cfunction:: void minEnclosingCircle( const Mat\& points, Point2f\& center, float\& radius ) .. c:function:: void minEnclosingCircle( const Mat& points, Point2f& center, float& radius )
Finds the minimum area circle enclosing a 2D point set. Finds the minimum area circle enclosing a 2D point set.
@ -504,9 +500,9 @@ cv::minEnclosingCircle
The function finds the minimal enclosing circle of a 2D point set using iterative algorithm. See the OpenCV sample ``minarea.c`` The function finds the minimal enclosing circle of a 2D point set using iterative algorithm. See the OpenCV sample ``minarea.c``
.. index:: matchShapes .. index:: matchShapes
cv::matchShapes matchShapes
--------------- ---------------
.. cfunction:: double matchShapes( const Mat\& object1, const Mat\& object2, int method, double parameter=0 ) .. c:function:: double matchShapes( const Mat& object1, const Mat& object2, int method, double parameter=0 )
Compares two shapes. Compares two shapes.
@ -554,9 +550,9 @@ and
.. index:: pointPolygonTest .. index:: pointPolygonTest
cv::pointPolygonTest pointPolygonTest
-------------------- --------------------
.. cfunction:: double pointPolygonTest( const Mat\& contour, Point2f pt, bool measureDist ) .. c:function:: double pointPolygonTest( const Mat& contour, Point2f pt, bool measureDist )
Performs point-in-contour test. Performs point-in-contour test.

14
modules/ml/doc/boosting.rst
View File

@ -83,7 +83,7 @@ training examples are recomputed at each training iteration. Examples deleted at
CvBoostParams CvBoostParams
------------- -------------
.. ctype:: CvBoostParams .. c:type:: CvBoostParams
Boosting training parameters. :: Boosting training parameters. ::
@ -109,7 +109,7 @@ The structure is derived from
CvBoostTree CvBoostTree
----------- -----------
.. ctype:: CvBoostTree .. c:type:: CvBoostTree
Weak tree classifier. :: Weak tree classifier. ::
@ -148,7 +148,7 @@ Note, that in the case of LogitBoost and Gentle AdaBoost each weak predictor is
CvBoost CvBoost
------- -------
.. ctype:: CvBoost .. c:type:: CvBoost
Boosted tree classifier. :: Boosted tree classifier. ::
@ -212,7 +212,7 @@ Boosted tree classifier. ::
CvBoost::train CvBoost::train
-------------- --------------
.. cfunction:: bool CvBoost::train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvBoostParams params=CvBoostParams(), bool update=false ) .. c:function:: bool CvBoost::train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvBoostParams params=CvBoostParams(), bool update=false )
Trains a boosted tree classifier. Trains a boosted tree classifier.
@ -224,7 +224,7 @@ The train method follows the common template; the last parameter ``update`` spec
CvBoost::predict CvBoost::predict
---------------- ----------------
.. cfunction:: float CvBoost::predict( const CvMat* sample, const CvMat* missing=0, CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ, bool raw_mode=false ) const .. c:function:: float CvBoost::predict( const CvMat* sample, const CvMat* missing=0, CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ, bool raw_mode=false ) const
Predicts a response for the input sample. Predicts a response for the input sample.
@ -236,7 +236,7 @@ The method ``CvBoost::predict`` runs the sample through the trees in the ensembl
CvBoost::prune CvBoost::prune
-------------- --------------
.. cfunction:: void CvBoost::prune( CvSlice slice ) .. c:function:: void CvBoost::prune( CvSlice slice )
Removes the specified weak classifiers. Removes the specified weak classifiers.
@ -248,7 +248,7 @@ The method removes the specified weak classifiers from the sequence. Note that t
CvBoost::get_weak_predictors CvBoost::get_weak_predictors
---------------------------- ----------------------------
.. cfunction:: CvSeq* CvBoost::get_weak_predictors() .. c:function:: CvSeq* CvBoost::get_weak_predictors()
Returns the sequence of weak tree classifiers. Returns the sequence of weak tree classifiers.

16
modules/ml/doc/decision_trees.rst
View File

@ -68,7 +68,7 @@ Importance of each variable is computed over all the splits on this variable in
CvDTreeSplit CvDTreeSplit
------------ ------------
.. ctype:: CvDTreeSplit .. c:type:: CvDTreeSplit
Decision tree node split. :: Decision tree node split. ::
@ -97,7 +97,7 @@ Decision tree node split. ::
CvDTreeNode CvDTreeNode
----------- -----------
.. ctype:: CvDTreeNode .. c:type:: CvDTreeNode
Decision tree node. :: Decision tree node. ::
@ -127,7 +127,7 @@ Other numerous fields of ``CvDTreeNode`` are used internally at the training sta
CvDTreeParams CvDTreeParams
------------- -------------
.. ctype:: CvDTreeParams .. c:type:: CvDTreeParams
Decision tree training parameters. :: Decision tree training parameters. ::
@ -164,7 +164,7 @@ The structure contains all the decision tree training parameters. There is a def
CvDTreeTrainData CvDTreeTrainData
---------------- ----------------
.. ctype:: CvDTreeTrainData .. c:type:: CvDTreeTrainData
Decision tree training data and shared data for tree ensembles. :: Decision tree training data and shared data for tree ensembles. ::
@ -289,7 +289,7 @@ There are 2 ways of using this structure. In simple cases (e.g. a standalone tre
CvDTree CvDTree
------- -------
.. ctype:: CvDTree .. c:type:: CvDTree
Decision tree. :: Decision tree. ::
@ -376,9 +376,9 @@ Decision tree. ::
CvDTree::train CvDTree::train
-------------- --------------
.. cfunction:: bool CvDTree::train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvDTreeParams params=CvDTreeParams() ) .. c:function:: bool CvDTree::train( const CvMat* _train_data, int _tflag, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const CvMat* _var_type=0, const CvMat* _missing_mask=0, CvDTreeParams params=CvDTreeParams() )
.. cfunction:: bool CvDTree::train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx ) .. c:function:: bool CvDTree::train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx )
Trains a decision tree. Trains a decision tree.
@ -396,7 +396,7 @@ The second method ``train`` is mostly used for building tree ensembles. It takes
CvDTree::predict CvDTree::predict
---------------- ----------------
.. cfunction:: CvDTreeNode* CvDTree::predict( const CvMat* _sample, const CvMat* _missing_data_mask=0, bool raw_mode=false ) const .. c:function:: CvDTreeNode* CvDTree::predict( const CvMat* _sample, const CvMat* _missing_data_mask=0, bool raw_mode=false ) const
Returns the leaf node of the decision tree corresponding to the input vector. Returns the leaf node of the decision tree corresponding to the input vector.

6
modules/ml/doc/expectation_maximization.rst
View File

@ -88,7 +88,7 @@ already a good enough approximation).
CvEMParams CvEMParams
---------- ----------
.. ctype:: CvEMParams .. c:type:: CvEMParams
Parameters of the EM algorithm. :: Parameters of the EM algorithm. ::
@ -134,7 +134,7 @@ The structure has 2 constructors, the default one represents a rough rule-of-thu
CvEM CvEM
---- ----
.. ctype:: CvEM .. c:type:: CvEM
EM model. :: EM model. ::
@ -194,7 +194,7 @@ EM model. ::
CvEM::train CvEM::train
----------- -----------
.. cfunction:: void CvEM::train( const CvMat* samples, const CvMat* sample_idx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 ) .. c:function:: void CvEM::train( const CvMat* samples, const CvMat* sample_idx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 )
Estimates the Gaussian mixture parameters from the sample set. Estimates the Gaussian mixture parameters from the sample set.

6
modules/ml/doc/k_nearest_neighbors.rst
View File

@ -13,7 +13,7 @@ The algorithm caches all of the training samples, and predicts the response for
CvKNearest CvKNearest
---------- ----------
.. ctype:: CvKNearest .. c:type:: CvKNearest
K Nearest Neighbors model. :: K Nearest Neighbors model. ::
@ -51,7 +51,7 @@ K Nearest Neighbors model. ::
CvKNearest::train CvKNearest::train
----------------- -----------------
.. cfunction:: bool CvKNearest::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _sample_idx=0, bool is_regression=false, int _max_k=32, bool _update_base=false ) .. c:function:: bool CvKNearest::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _sample_idx=0, bool is_regression=false, int _max_k=32, bool _update_base=false )
Trains the model. Trains the model.
@ -68,7 +68,7 @@ The parameter ``_update_base`` specifies whether the model is trained from scrat
CvKNearest::find_nearest CvKNearest::find_nearest
------------------------ ------------------------
.. cfunction:: float CvKNearest::find_nearest( const CvMat* _samples, int k, CvMat* results=0, const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const .. c:function:: float CvKNearest::find_nearest( const CvMat* _samples, int k, CvMat* results=0, const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const
Finds the neighbors for the input vectors. Finds the neighbors for the input vectors.

2
modules/ml/doc/ml.rst
View File

@ -16,6 +16,6 @@ Most of the classification and regression algorithms are implemented as C++ clas
decision_trees decision_trees
boosting boosting
random_trees random_trees
expectation-maximization expectation_maximization
neural_networks neural_networks

10
modules/ml/doc/neural_networks.rst
View File

@ -98,7 +98,7 @@ References:
CvANN_MLP_TrainParams CvANN_MLP_TrainParams
--------------------- ---------------------
.. ctype:: CvANN_MLP_TrainParams .. c:type:: CvANN_MLP_TrainParams
Parameters of the MLP training algorithm. :: Parameters of the MLP training algorithm. ::
@ -120,6 +120,7 @@ Parameters of the MLP training algorithm. ::
// rprop parameters // rprop parameters
double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max; double rp_dw0, rp_dw_plus, rp_dw_minus, rp_dw_min, rp_dw_max;
}; };
.. ..
The structure has default constructor that initializes parameters for ``RPROP`` algorithm. There is also more advanced constructor to customize the parameters and/or choose backpropagation algorithm. Finally, the individual parameters can be adjusted after the structure is created. The structure has default constructor that initializes parameters for ``RPROP`` algorithm. There is also more advanced constructor to customize the parameters and/or choose backpropagation algorithm. Finally, the individual parameters can be adjusted after the structure is created.
@ -130,7 +131,7 @@ The structure has default constructor that initializes parameters for ``RPROP``
CvANN_MLP CvANN_MLP
--------- ---------
.. ctype:: CvANN_MLP .. c:type:: CvANN_MLP
MLP model. :: MLP model. ::
@ -210,6 +211,7 @@ MLP model. ::
CvANN_MLP_TrainParams params; CvANN_MLP_TrainParams params;
CvRNG rng; CvRNG rng;
}; };
.. ..
Unlike many other models in ML that are constructed and trained at once, in the MLP model these steps are separated. First, a network with the specified topology is created using the non-default constructor or the method ``create`` . All the weights are set to zeros. Then the network is trained using the set of input and output vectors. The training procedure can be repeated more than once, i.e. the weights can be adjusted based on the new training data. Unlike many other models in ML that are constructed and trained at once, in the MLP model these steps are separated. First, a network with the specified topology is created using the non-default constructor or the method ``create`` . All the weights are set to zeros. Then the network is trained using the set of input and output vectors. The training procedure can be repeated more than once, i.e. the weights can be adjusted based on the new training data.
@ -220,7 +222,7 @@ Unlike many other models in ML that are constructed and trained at once, in the
CvANN_MLP::create CvANN_MLP::create
----------------- -----------------
.. cfunction:: void CvANN_MLP::create( const CvMat* _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ) .. c:function:: void CvANN_MLP::create( const CvMat* _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 )
Constructs the MLP with the specified topology Constructs the MLP with the specified topology
@ -238,7 +240,7 @@ The method creates a MLP network with the specified topology and assigns the sam
CvANN_MLP::train CvANN_MLP::train
---------------- ----------------
.. cfunction:: int CvANN_MLP::train( const CvMat* _inputs, const CvMat* _outputs, const CvMat* _sample_weights, const CvMat* _sample_idx=0, CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 ) .. c:function:: int CvANN_MLP::train( const CvMat* _inputs, const CvMat* _outputs, const CvMat* _sample_weights, const CvMat* _sample_idx=0, CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 )
Trains/updates MLP. Trains/updates MLP.

6
modules/ml/doc/normal_bayes_classifier.rst
View File

@ -13,7 +13,7 @@ This is a simple classification model assuming that feature vectors from each cl
CvNormalBayesClassifier CvNormalBayesClassifier
----------------------- -----------------------
.. ctype:: CvNormalBayesClassifier .. c:type:: CvNormalBayesClassifier
Bayes classifier for normally distributed data. :: Bayes classifier for normally distributed data. ::
@ -48,7 +48,7 @@ Bayes classifier for normally distributed data. ::
CvNormalBayesClassifier::train CvNormalBayesClassifier::train
------------------------------ ------------------------------
.. cfunction:: bool CvNormalBayesClassifier::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx =0, const CvMat* _sample_idx=0, bool update=false ) .. c:function:: bool CvNormalBayesClassifier::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx =0, const CvMat* _sample_idx=0, bool update=false )
Trains the model. Trains the model.
@ -62,7 +62,7 @@ In addition, there is an ``update`` flag that identifies whether the model shoul
CvNormalBayesClassifier::predict CvNormalBayesClassifier::predict
-------------------------------- --------------------------------
.. cfunction:: float CvNormalBayesClassifier::predict( const CvMat* samples, CvMat* results=0 ) const .. c:function:: float CvNormalBayesClassifier::predict( const CvMat* samples, CvMat* results=0 ) const
Predicts the response for sample(s) Predicts the response for sample(s)

12
modules/ml/doc/random_trees.rst
View File

@ -53,7 +53,7 @@ In random trees there is no need for any accuracy estimation procedures, such as
CvRTParams CvRTParams
---------- ----------
.. ctype:: CvRTParams .. c:type:: CvRTParams
Training Parameters of Random Trees. :: Training Parameters of Random Trees. ::
@ -86,7 +86,7 @@ The set of training parameters for the forest is the superset of the training pa
CvRTrees CvRTrees
-------- --------
.. ctype:: CvRTrees .. c:type:: CvRTrees
Random Trees. :: Random Trees. ::
@ -136,7 +136,7 @@ Random Trees. ::
CvRTrees::train CvRTrees::train
--------------- ---------------
.. cfunction:: bool CvRTrees::train( const CvMat* train_data, int tflag, const CvMat* responses, const CvMat* comp_idx=0, const CvMat* sample_idx=0, const CvMat* var_type=0, const CvMat* missing_mask=0, CvRTParams params=CvRTParams() ) .. c:function:: bool CvRTrees::train( const CvMat* train_data, int tflag, const CvMat* responses, const CvMat* comp_idx=0, const CvMat* sample_idx=0, const CvMat* var_type=0, const CvMat* missing_mask=0, CvRTParams params=CvRTParams() )
Trains the Random Trees model. Trains the Random Trees model.
@ -149,7 +149,7 @@ The method ``CvRTrees::train`` is very similar to the first form of ``CvDTree::t
CvRTrees::predict CvRTrees::predict
----------------- -----------------
.. cfunction:: double CvRTrees::predict( const CvMat* sample, const CvMat* missing=0 ) const .. c:function:: double CvRTrees::predict( const CvMat* sample, const CvMat* missing=0 ) const
Predicts the output for the input sample. Predicts the output for the input sample.
@ -161,7 +161,7 @@ The input parameters of the prediction method are the same as in ``CvDTree::pred
CvRTrees::get_var_importance CvRTrees::get_var_importance
---------------------------- ----------------------------
.. cfunction:: const CvMat* CvRTrees::get_var_importance() const .. c:function:: const CvMat* CvRTrees::get_var_importance() const
Retrieves the variable importance array. Retrieves the variable importance array.
@ -173,7 +173,7 @@ The method returns the variable importance vector, computed at the training stag
CvRTrees::get_proximity CvRTrees::get_proximity
----------------------- -----------------------
.. cfunction:: float CvRTrees::get_proximity( const CvMat* sample_1, const CvMat* sample_2 ) const .. c:function:: float CvRTrees::get_proximity( const CvMat* sample_1, const CvMat* sample_2 ) const
Retrieves the proximity measure between two training samples. Retrieves the proximity measure between two training samples.

22
modules/ml/doc/statistical_models.rst
View File

@ -9,7 +9,7 @@ Statistical Models
CvStatModel CvStatModel
----------- -----------
.. ctype:: CvStatModel .. c:type:: CvStatModel
Base class for the statistical models in ML. :: Base class for the statistical models in ML. ::
@ -48,7 +48,7 @@ In this declaration some methods are commented off. Actually, these are methods
CvStatModel::CvStatModel CvStatModel::CvStatModel
------------------------ ------------------------
.. cfunction:: CvStatModel::CvStatModel() .. c:function:: CvStatModel::CvStatModel()
Default constructor. Default constructor.
@ -60,7 +60,7 @@ Each statistical model class in ML has a default constructor without parameters.
CvStatModel::CvStatModel(...) CvStatModel::CvStatModel(...)
----------------------------- -----------------------------
.. cfunction:: CvStatModel::CvStatModel( const CvMat* train_data ... ) .. c:function:: CvStatModel::CvStatModel( const CvMat* train_data ... )
Training constructor. Training constructor.
@ -72,7 +72,7 @@ Most ML classes provide single-step construct and train constructors. This const
CvStatModel::~CvStatModel CvStatModel::~CvStatModel
------------------------- -------------------------
.. cfunction:: CvStatModel::~CvStatModel() .. c:function:: CvStatModel::~CvStatModel()
Virtual destructor. Virtual destructor.
@ -95,7 +95,7 @@ Normally, the destructor of each derived class does nothing, but in this instanc
CvStatModel::clear CvStatModel::clear
------------------ ------------------
.. cfunction:: void CvStatModel::clear() .. c:function:: void CvStatModel::clear()
Deallocates memory and resets the model state. Deallocates memory and resets the model state.
@ -107,7 +107,7 @@ The method ``clear`` does the same job as the destructor; it deallocates all the
CvStatModel::save CvStatModel::save
----------------- -----------------
.. cfunction:: void CvStatModel::save( const char* filename, const char* name=0 ) .. c:function:: void CvStatModel::save( const char* filename, const char* name=0 )
Saves the model to a file. Saves the model to a file.
@ -119,7 +119,7 @@ The method ``save`` stores the complete model state to the specified XML or YAML
CvStatModel::load CvStatModel::load
----------------- -----------------
.. cfunction:: void CvStatModel::load( const char* filename, const char* name=0 ) .. c:function:: void CvStatModel::load( const char* filename, const char* name=0 )
Loads the model from a file. Loads the model from a file.
@ -135,7 +135,7 @@ cross{cvLoad}, here the model type must be known, because an empty model must be
CvStatModel::write CvStatModel::write
------------------ ------------------
.. cfunction:: void CvStatModel::write( CvFileStorage* storage, const char* name ) .. c:function:: void CvStatModel::write( CvFileStorage* storage, const char* name )
Writes the model to file storage. Writes the model to file storage.
@ -147,7 +147,7 @@ The method ``write`` stores the complete model state to the file storage with th
CvStatModel::read CvStatModel::read
----------------- -----------------
.. cfunction:: void CvStatMode::read( CvFileStorage* storage, CvFileNode* node ) .. c:function:: void CvStatMode::read( CvFileStorage* storage, CvFileNode* node )
Reads the model from file storage. Reads the model from file storage.
@ -162,7 +162,7 @@ The previous model state is cleared by ``clear()`` .
CvStatModel::train CvStatModel::train
------------------ ------------------
.. cfunction:: bool CvStatMode::train( const CvMat* train_data, [int tflag,] ..., const CvMat* responses, ..., [const CvMat* var_idx,] ..., [const CvMat* sample_idx,] ... [const CvMat* var_type,] ..., [const CvMat* missing_mask,] <misc_training_alg_params> ... ) .. c:function:: bool CvStatMode::train( const CvMat* train_data, [int tflag,] ..., const CvMat* responses, ..., [const CvMat* var_idx,] ..., [const CvMat* sample_idx,] ... [const CvMat* var_type,] ..., [const CvMat* missing_mask,] <misc_training_alg_params> ... )
Trains the model. Trains the model.
@ -194,7 +194,7 @@ Usually, the previous model state is cleared by ``clear()`` before running the t
CvStatModel::predict CvStatModel::predict
-------------------- --------------------
.. cfunction:: float CvStatMode::predict( const CvMat* sample[, <prediction_params>] ) const .. c:function:: float CvStatMode::predict( const CvMat* sample[, <prediction_params>] ) const
Predicts the response for the sample. Predicts the response for the sample.

16
modules/ml/doc/support_vector_machines.rst
View File

@ -27,7 +27,7 @@ There are a lot of good references on SVM. Here are only a few ones to start wit
CvSVM CvSVM
----- -----
.. ctype:: CvSVM .. c:type:: CvSVM
Support Vector Machines. :: Support Vector Machines. ::
@ -90,7 +90,7 @@ Support Vector Machines. ::
CvSVMParams CvSVMParams
----------- -----------
.. ctype:: CvSVMParams .. c:type:: CvSVMParams
SVM training parameters. :: SVM training parameters. ::
@ -125,7 +125,7 @@ The structure must be initialized and passed to the training method of
CvSVM::train CvSVM::train
------------ ------------
.. cfunction:: bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, CvSVMParams _params=CvSVMParams() ) .. c:function:: bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, CvSVMParams _params=CvSVMParams() )
Trains SVM. Trains SVM.
@ -140,7 +140,7 @@ All the other parameters are gathered in
CvSVM::train_auto CvSVM::train_auto
----------------- -----------------
.. cfunction:: train_auto( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams params, int k_fold = 10, CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid p_grid = get_default_grid(CvSVM::P), CvParamGrid nu_grid = get_default_grid(CvSVM::NU), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) ) .. c:function:: train_auto( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams params, int k_fold = 10, CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid p_grid = get_default_grid(CvSVM::P), CvParamGrid nu_grid = get_default_grid(CvSVM::NU), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) )
Trains SVM with optimal parameters. Trains SVM with optimal parameters.
@ -182,7 +182,7 @@ as well as for the regression
CvSVM::get_default_grid CvSVM::get_default_grid
----------------------- -----------------------
.. cfunction:: CvParamGrid CvSVM::get_default_grid( int param_id ) .. c:function:: CvParamGrid CvSVM::get_default_grid( int param_id )
Generates a grid for the SVM parameters. Generates a grid for the SVM parameters.
@ -211,7 +211,7 @@ The function generates a grid for the specified parameter of the SVM algorithm.
CvSVM::get_params CvSVM::get_params
----------------- -----------------
.. cfunction:: CvSVMParams CvSVM::get_params() const .. c:function:: CvSVMParams CvSVM::get_params() const
Returns the current SVM parameters. Returns the current SVM parameters.
@ -223,9 +223,9 @@ This function may be used to get the optimal parameters that were obtained while
CvSVM::get_support_vector* CvSVM::get_support_vector*
-------------------------- --------------------------
.. cfunction:: int CvSVM::get_support_vector_count() const .. c:function:: int CvSVM::get_support_vector_count() const
.. cfunction:: const float* CvSVM::get_support_vector(int i) const .. c:function:: const float* CvSVM::get_support_vector(int i) const
Retrieves the number of support vectors and the particular vector. Retrieves the number of support vectors and the particular vector.

68
modules/objdetect/doc/cascade_classification.rst
View File

@ -9,7 +9,7 @@ Cascade Classification
FeatureEvaluator FeatureEvaluator
---------------- ----------------
.. ctype:: FeatureEvaluator .. c:type:: FeatureEvaluator
Base class for computing feature values in cascade classifiers. :: Base class for computing feature values in cascade classifiers. ::
@ -34,9 +34,9 @@ Base class for computing feature values in cascade classifiers. ::
.. index:: FeatureEvaluator::read .. index:: FeatureEvaluator::read
cv::FeatureEvaluator::read FeatureEvaluator::read
-------------------------- --------------------------
.. cfunction:: bool FeatureEvaluator::read(const FileNode\& node) .. c:function:: bool FeatureEvaluator::read(const FileNode\& node)
Reads parameters of the features from a FileStorage node. Reads parameters of the features from a FileStorage node.
@ -44,25 +44,25 @@ cv::FeatureEvaluator::read
.. index:: FeatureEvaluator::clone .. index:: FeatureEvaluator::clone
cv::FeatureEvaluator::clone FeatureEvaluator::clone
--------------------------- ---------------------------
.. cfunction:: Ptr<FeatureEvaluator> FeatureEvaluator::clone() const .. c:function:: Ptr<FeatureEvaluator> FeatureEvaluator::clone() const
Returns a full copy of the feature evaluator. Returns a full copy of the feature evaluator.
.. index:: FeatureEvaluator::getFeatureType .. index:: FeatureEvaluator::getFeatureType
cv::FeatureEvaluator::getFeatureType FeatureEvaluator::getFeatureType
------------------------------------ ------------------------------------
.. cfunction:: int FeatureEvaluator::getFeatureType() const .. c:function:: int FeatureEvaluator::getFeatureType() const
Returns the feature type (HAAR or LBP for now). Returns the feature type (HAAR or LBP for now).
.. index:: FeatureEvaluator::setImage .. index:: FeatureEvaluator::setImage
cv::FeatureEvaluator::setImage FeatureEvaluator::setImage
------------------------------ ------------------------------
.. cfunction:: bool FeatureEvaluator::setImage(const Mat\& img, Size origWinSize) .. c:function:: bool FeatureEvaluator::setImage(const Mat\& img, Size origWinSize)
Sets the image in which to compute the features. Sets the image in which to compute the features.
@ -72,10 +72,10 @@ cv::FeatureEvaluator::setImage
.. index:: FeatureEvaluator::setWindow .. index:: FeatureEvaluator::setWindow
cv::FeatureEvaluator::setWindow FeatureEvaluator::setWindow
------------------------------- -------------------------------
:func:`CascadeClassifier::runAt` :func:`CascadeClassifier::runAt`
.. cfunction:: bool FeatureEvaluator::setWindow(Point p) .. c:function:: bool FeatureEvaluator::setWindow(Point p)
Sets window in the current image in which the features will be computed (called by ). Sets window in the current image in which the features will be computed (called by ).
@ -83,9 +83,9 @@ cv::FeatureEvaluator::setWindow
.. index:: FeatureEvaluator::calcOrd .. index:: FeatureEvaluator::calcOrd
cv::FeatureEvaluator::calcOrd FeatureEvaluator::calcOrd
----------------------------- -----------------------------
.. cfunction:: double FeatureEvaluator::calcOrd(int featureIdx) const .. c:function:: double FeatureEvaluator::calcOrd(int featureIdx) const
Computes value of an ordered (numerical) feature. Computes value of an ordered (numerical) feature.
@ -95,9 +95,9 @@ Returns computed value of ordered feature.
.. index:: FeatureEvaluator::calcCat .. index:: FeatureEvaluator::calcCat
cv::FeatureEvaluator::calcCat FeatureEvaluator::calcCat
----------------------------- -----------------------------
.. cfunction:: int FeatureEvaluator::calcCat(int featureIdx) const .. c:function:: int FeatureEvaluator::calcCat(int featureIdx) const
Computes value of a categorical feature. Computes value of a categorical feature.
@ -107,9 +107,9 @@ Returns computed label of categorical feature, i.e. value from [0,... (number of
.. index:: FeatureEvaluator::create .. index:: FeatureEvaluator::create
cv::FeatureEvaluator::create FeatureEvaluator::create
---------------------------- ----------------------------
.. cfunction:: static Ptr<FeatureEvaluator> FeatureEvaluator::create(int type) .. c:function:: static Ptr<FeatureEvaluator> FeatureEvaluator::create(int type)
Constructs feature evaluator. Constructs feature evaluator.
@ -121,7 +121,7 @@ cv::FeatureEvaluator::create
CascadeClassifier CascadeClassifier
----------------- -----------------
.. ctype:: CascadeClassifier .. c:type:: CascadeClassifier
The cascade classifier class for object detection. :: The cascade classifier class for object detection. ::
@ -194,9 +194,9 @@ The cascade classifier class for object detection. ::
.. index:: CascadeClassifier::CascadeClassifier .. index:: CascadeClassifier::CascadeClassifier
cv::CascadeClassifier::CascadeClassifier CascadeClassifier::CascadeClassifier
---------------------------------------- ----------------------------------------
.. cfunction:: CascadeClassifier::CascadeClassifier(const string\& filename) .. c:function:: CascadeClassifier::CascadeClassifier(const string\& filename)
Loads the classifier from file. Loads the classifier from file.
@ -204,17 +204,17 @@ cv::CascadeClassifier::CascadeClassifier
.. index:: CascadeClassifier::empty .. index:: CascadeClassifier::empty
cv::CascadeClassifier::empty CascadeClassifier::empty
---------------------------- ----------------------------
.. cfunction:: bool CascadeClassifier::empty() const .. c:function:: bool CascadeClassifier::empty() const
Checks if the classifier has been loaded or not. Checks if the classifier has been loaded or not.
.. index:: CascadeClassifier::load .. index:: CascadeClassifier::load
cv::CascadeClassifier::load CascadeClassifier::load
--------------------------- ---------------------------
.. cfunction:: bool CascadeClassifier::load(const string\& filename) .. c:function:: bool CascadeClassifier::load(const string\& filename)
Loads the classifier from file. The previous content is destroyed. Loads the classifier from file. The previous content is destroyed.
@ -222,17 +222,17 @@ cv::CascadeClassifier::load
.. index:: CascadeClassifier::read .. index:: CascadeClassifier::read
cv::CascadeClassifier::read CascadeClassifier::read
--------------------------- ---------------------------
.. cfunction:: bool CascadeClassifier::read(const FileNode\& node) .. c:function:: bool CascadeClassifier::read(const FileNode\& node)
Reads the classifier from a FileStorage node. File may contain a new cascade classifier (trained traincascade application) only. Reads the classifier from a FileStorage node. File may contain a new cascade classifier (trained traincascade application) only.
.. index:: CascadeClassifier::detectMultiScale .. index:: CascadeClassifier::detectMultiScale
cv::CascadeClassifier::detectMultiScale CascadeClassifier::detectMultiScale
--------------------------------------- ---------------------------------------
.. cfunction:: void CascadeClassifier::detectMultiScale( const Mat\& image, vector<Rect>\& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size()) .. c:function:: void CascadeClassifier::detectMultiScale( const Mat\& image, vector<Rect>\& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size())
Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles. Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
@ -250,9 +250,9 @@ cv::CascadeClassifier::detectMultiScale
.. index:: CascadeClassifier::setImage .. index:: CascadeClassifier::setImage
cv::CascadeClassifier::setImage CascadeClassifier::setImage
------------------------------- -------------------------------
.. cfunction:: bool CascadeClassifier::setImage( Ptr<FeatureEvaluator>\& feval, const Mat\& image ) .. c:function:: bool CascadeClassifier::setImage( Ptr<FeatureEvaluator>\& feval, const Mat\& image )
Sets the image for detection (called by detectMultiScale at each image level). Sets the image for detection (called by detectMultiScale at each image level).
@ -262,9 +262,9 @@ cv::CascadeClassifier::setImage
.. index:: CascadeClassifier::runAt .. index:: CascadeClassifier::runAt
cv::CascadeClassifier::runAt CascadeClassifier::runAt
---------------------------- ----------------------------
.. cfunction:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>\& feval, Point pt ) .. c:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>\& feval, Point pt )
Runs the detector at the specified point (the image that the detector is working with should be set by setImage). Runs the detector at the specified point (the image that the detector is working with should be set by setImage).
@ -278,9 +278,9 @@ Returns:
.. index:: groupRectangles .. index:: groupRectangles
cv::groupRectangles groupRectangles
------------------- -------------------
.. cfunction:: void groupRectangles(vector<Rect>\& rectList, int groupThreshold, double eps=0.2) .. c:function:: void groupRectangles(vector<Rect>\& rectList, int groupThreshold, double eps=0.2)
Groups the object candidate rectangles Groups the object candidate rectangles

30
modules/video/doc/motion_analysis_and_object_tracking.rst
View File

@ -5,9 +5,9 @@ Motion Analysis and Object Tracking
.. index:: calcOpticalFlowPyrLK .. index:: calcOpticalFlowPyrLK
cv::calcOpticalFlowPyrLK calcOpticalFlowPyrLK
------------------------ ------------------------
.. cfunction:: void calcOpticalFlowPyrLK( const Mat\& prevImg, const Mat\& nextImg, const vector<Point2f>\& prevPts, vector<Point2f>\& nextPts, vector<uchar>\& status, vector<float>\& err, Size winSize=Size(15,15), int maxLevel=3, TermCriteria criteria=TermCriteria( TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0 ) .. c:function:: void calcOpticalFlowPyrLK( const Mat\& prevImg, const Mat\& nextImg, const vector<Point2f>\& prevPts, vector<Point2f>\& nextPts, vector<uchar>\& status, vector<float>\& err, Size winSize=Size(15,15), int maxLevel=3, TermCriteria criteria=TermCriteria( TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0 )
Calculates the optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids Calculates the optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids
@ -38,9 +38,9 @@ Bouguet00
.. index:: calcOpticalFlowFarneback .. index:: calcOpticalFlowFarneback
cv::calcOpticalFlowFarneback calcOpticalFlowFarneback
---------------------------- ----------------------------
.. cfunction:: void calcOpticalFlowFarneback( const Mat\& prevImg, const Mat\& nextImg, Mat\& flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags ) .. c:function:: void calcOpticalFlowFarneback( const Mat\& prevImg, const Mat\& nextImg, Mat\& flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags )
Computes dense optical flow using Gunnar Farneback's algorithm Computes dense optical flow using Gunnar Farneback's algorithm
@ -73,9 +73,9 @@ The function finds optical flow for each ``prevImg`` pixel using the alorithm so
.. index:: updateMotionHistory .. index:: updateMotionHistory
cv::updateMotionHistory updateMotionHistory
----------------------- -----------------------
.. cfunction:: void updateMotionHistory( const Mat\& silhouette, Mat\& mhi, double timestamp, double duration ) .. c:function:: void updateMotionHistory( const Mat\& silhouette, Mat\& mhi, double timestamp, double duration )
Updates the motion history image by a moving silhouette. Updates the motion history image by a moving silhouette.
@ -105,9 +105,9 @@ See also the OpenCV sample ``motempl.c`` that demonstrates the use of all the mo
.. index:: calcMotionGradient .. index:: calcMotionGradient
cv::calcMotionGradient calcMotionGradient
---------------------- ----------------------
.. cfunction:: void calcMotionGradient( const Mat\& mhi, Mat\& mask, Mat\& orientation, double delta1, double delta2, int apertureSize=3 ) .. c:function:: void calcMotionGradient( const Mat\& mhi, Mat\& mask, Mat\& orientation, double delta1, double delta2, int apertureSize=3 )
Calculates the gradient orientation of a motion history image. Calculates the gradient orientation of a motion history image.
@ -138,9 +138,9 @@ The function calculates the gradient orientation at each pixel
.. index:: calcGlobalOrientation .. index:: calcGlobalOrientation
cv::calcGlobalOrientation calcGlobalOrientation
------------------------- -------------------------
.. cfunction:: double calcGlobalOrientation( const Mat\& orientation, const Mat\& mask, const Mat\& mhi, double timestamp, double duration ) .. c:function:: double calcGlobalOrientation( const Mat\& orientation, const Mat\& mask, const Mat\& mhi, double timestamp, double duration )
Calculates the global motion orientation in some selected region. Calculates the global motion orientation in some selected region.
@ -158,9 +158,9 @@ weight and the motion occurred in the past has smaller weight, as recorded in ``
.. index:: CamShift .. index:: CamShift
cv::CamShift CamShift
------------ ------------
.. cfunction:: RotatedRect CamShift( const Mat\& probImage, Rect\& window, TermCriteria criteria ) .. c:function:: RotatedRect CamShift( const Mat\& probImage, Rect\& window, TermCriteria criteria )
Finds the object center, size, and orientation Finds the object center, size, and orientation
@ -178,9 +178,9 @@ See the OpenCV sample ``camshiftdemo.c`` that tracks colored objects.
.. index:: meanShift .. index:: meanShift
cv::meanShift meanShift
------------- -------------
.. cfunction:: int meanShift( const Mat\& probImage, Rect\& window, TermCriteria criteria ) .. c:function:: int meanShift( const Mat\& probImage, Rect\& window, TermCriteria criteria )
Finds the object on a back projection image. Finds the object on a back projection image.
@ -203,7 +203,7 @@ The function implements iterative object search algorithm. It takes the object b
KalmanFilter KalmanFilter
------------ ------------
.. ctype:: KalmanFilter .. c:type:: KalmanFilter
Kalman filter class :: Kalman filter class ::