a lot of small corrections to bring down the number of undocumented functions, reported by the script; added em.cpp sample

This commit is contained in:
Vadim Pisarevsky 2011-06-09 01:16:45 +00:00
parent 3b9e752be7
commit 20aca7440f
30 changed files with 474 additions and 746 deletions

View File

@ -17,13 +17,13 @@ opencv_hdr_list = [
opencv_module_list = [ opencv_module_list = [
"core", "core",
#"imgproc", "imgproc",
#"calib3d", "calib3d",
#"features2d", "features2d",
#"video", "video",
#"objdetect", "objdetect",
#"highgui", "highgui",
#"ml" "ml"
] ]
class RSTParser(object): class RSTParser(object):
@ -49,6 +49,7 @@ class RSTParser(object):
continue continue
rst_decl = None rst_decl = None
if "(" in l: if "(" in l:
l = l.replace("cv::", "")
rst_decl = self.parser.parse_func_decl_no_wrap(l) rst_decl = self.parser.parse_func_decl_no_wrap(l)
fname = rst_decl[0] fname = rst_decl[0]
else: else:
@ -94,6 +95,9 @@ class RSTParser(object):
fname = rst_decl[0] fname = rst_decl[0]
hdr_decls = self.fmap.get(fname, []) hdr_decls = self.fmap.get(fname, [])
if not hdr_decls: if not hdr_decls:
fname = fname.replace("cv.", "")
hdr_decls = self.fmap.get(fname, [])
if not hdr_decls:
print "Documented function %s (%s) in %s:%d is not in the headers" % (fdecl, rst_decl[0].replace(".", "::"), docname, lineno) print "Documented function %s (%s) in %s:%d is not in the headers" % (fdecl, rst_decl[0].replace(".", "::"), docname, lineno)
continue continue
decl_idx = 0 decl_idx = 0
@ -103,7 +107,7 @@ class RSTParser(object):
continue continue
idx = 0 idx = 0
for a in hd[3]: for a in hd[3]:
if a[0] != rst_decl[3][idx][0]: if a[0] != rst_decl[3][idx][0] and a[0].replace("cv::", "") != rst_decl[3][idx][0]:
break break
idx += 1 idx += 1
if idx == len(hd[3]): if idx == len(hd[3]):
@ -162,6 +166,9 @@ class RSTParser(object):
for d in decls: for d in decls:
dstr = self.decl2str(d) dstr = self.decl2str(d)
# special hack for ML: skip old variants of the methods
if name == "ml" and ("CvMat" in dstr):
continue
if dstr not in wlist_decls: if dstr not in wlist_decls:
misscount += 1 misscount += 1
print "%s %s(%s)" % (d[1], d[0].replace(".", "::"), ", ".join([a[0] + " " + a[1] for a in d[3]])) print "%s %s(%s)" % (d[1], d[0].replace(".", "::"), ", ".join([a[0] + " " + a[1] for a in d[3]]))

View File

@ -14,6 +14,7 @@
# full declaration into the file # full declaration into the file
# #
######################################### core #####################################
cv::Mat::MSize cv::Mat::MSize
cv::Mat::MStep cv::Mat::MStep
cv::MatConstIterator cv::MatConstIterator
@ -22,5 +23,59 @@ cv::Algorithm
cv::_InputArray cv::_InputArray
cv::_OutputArray cv::_OutputArray
CvLevMarq ######################################## imgproc ###################################
CvLSHOperations
cv::FilterEngine
cv::BaseFilter
cv::BaseRowFilter
cv::BaseColumnFilter
cv::Moments
######################################## calib3d ###################################
CvLevMarq
Mat cv::findFundamentalMat( InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double param1=3., double param2=0.99)
Mat findHomography( InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3);
########################################## ml ######################################
CvBoostTree
CvForestTree
CvSVMKernel
CvSVMSolver
CvDTreeTrainData
CvERTreeTrainData
CvKNearest::CvKNearest
CvKNearest::clear
CvDTree::CvDTree
CvDTree::clear
CvDTree::read
CvDTree::write
CvEM::CvEM
CvEM::clear
CvEM::read
CvEM::write
CvSVM::CvSVM
CvSVM::clear
CvSVM::read
CvSVM::write
CvRTrees::CvRTrees
CvRTrees::clear
CvRTrees::read
CvRTrees::write
CvBoost::CvBoost
CvBoost::clear
CvBoost::read
CvBoost::write
CvGBTrees::CvGBTrees
CvGBTrees::clear
CvGBTrees::read
CvGBTrees::write
CvNormalBayesClassifier::CvNormalBayerClassifier
CvNormalBayesClassifier::clear
CvNormalBayesClassifier::read
CvNormalBayesClassifier::write
CvANN_MLP::CvANN_MLP
CvANN_MLP::clear
CvANN_MLP::read
CvANN_MLP::write
CvTrainTestSplit

View File

@ -258,7 +258,7 @@ latex_use_parts = False
#latex_appendices = [] #latex_appendices = []
# If false, no module index is generated. # If false, no module index is generated.
#latex_domain_indices = True latex_domain_indices = True
# -- Options for manual page output -------------------------------------------- # -- Options for manual page output --------------------------------------------

View File

@ -345,9 +345,7 @@ The function converts 2D or 3D points from/to homogeneous coordinates by calling
decomposeProjectionMatrix decomposeProjectionMatrix
----------------------------- -----------------------------
.. cpp:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect ) .. cpp:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray() )
.. cpp:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX, OutputArray rotMatrixY, OutputArray rotMatrixZ, Vec3d& eulerAngles )
Decomposes a projection matrix into a rotation matrix and a camera matrix. Decomposes a projection matrix into a rotation matrix and a camera matrix.
@ -365,7 +363,7 @@ decomposeProjectionMatrix
:param rotMatrZ: Optional 3x3 rotation matrix around z-axis. :param rotMatrZ: Optional 3x3 rotation matrix around z-axis.
:param eulerAngles: Optional 3 points containing the three Euler angles of rotation. :param eulerAngles: Optional 3-element vector containing the three Euler angles of rotation.
The function computes a decomposition of a projection matrix into a calibration and a rotation matrix and the position of a camera. The function computes a decomposition of a projection matrix into a calibration and a rotation matrix and the position of a camera.
@ -628,8 +626,6 @@ corresponding to the specified points. It can also be passed to
.. index:: findHomography .. index:: findHomography
.. _findHomography:
findHomography findHomography
------------------ ------------------
.. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() ) .. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() )
@ -707,9 +703,30 @@ See Also:
:ref:`PerspectiveTransform` :ref:`PerspectiveTransform`
.. index:: getOptimalNewCameraMatrix .. index:: estimateAffine3D
.. _getOptimalNewCameraMatrix: estimateAffine3D
--------------------
.. cpp:function:: int estimateAffine3D(InputArray srcpt, InputArray dstpt, OutputArray out, OutputArray outliers, double ransacThreshold = 3.0, double confidence = 0.99)
Computes an optimal affine transformation between two 3D point sets.
:param srcpt: The first input 3D point set.
:param dstpt: The second input 3D point set.
:param out: Output 3D affine transformation matrix :math:`3 \times 4` .
:param outliers: Output vector indicating which points are outliers.
:param ransacThreshold: Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier.
:param confidence: The confidence level, between 0 and 1, that the estimated transformation will have. Anything between 0.95 and 0.99 is usually good enough. Too close to 1 values can slow down the estimation too much, lower than 0.8-0.9 confidence values can result in an incorrectly estimated transformation.
The function estimates an optimal 3D affine transformation between two 3D point sets using the RANSAC algorithm.
.. index:: getOptimalNewCameraMatrix
getOptimalNewCameraMatrix getOptimalNewCameraMatrix
----------------------------- -----------------------------
@ -787,7 +804,7 @@ The function computes partial derivatives of the elements of the matrix product
projectPoints projectPoints
----------------- -----------------
.. cpp:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray dpdrot=noArray(), OutputArray dpdt=noArray(), OutputArray dpdf=noArray(), OutputArray dpdc=noArray(), OutputArray dpddist=noArray(), double aspectRatio=0 ) .. cpp:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0 )
Projects 3D points to an image plane. Projects 3D points to an image plane.
@ -803,15 +820,9 @@ projectPoints
:param imagePoints: Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or ``vector<Point2f>`` . :param imagePoints: Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or ``vector<Point2f>`` .
:param dpdrot: Optional 2Nx3 matrix of derivatives of image points with respect to components of the rotation vector. :param jacobian: Optional output 2Nx(10+<numDistCoeffs>) jacobian matrix of derivatives of image points with respect to components of the rotation vector, translation vector, focal lengths, coordinates of the principal point and the distortion coefficients.
:param dpdt: Optional 2Nx3 matrix of derivatives of image points with respect to components of the translation vector. :param aspectRatio: Optional "fixed aspect ratio" parameter. If the parameter is not 0, the function assumes that the aspect ratio (*fx/fy*) is fixed and correspondingly adjusts the jacobian matrix.
: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 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
points to the image plane given intrinsic and extrinsic camera points to the image plane given intrinsic and extrinsic camera
@ -837,7 +848,7 @@ By setting ``rvec=tvec=(0,0,0)`` or by setting ``cameraMatrix`` to a 3x3 identi
reprojectImageTo3D reprojectImageTo3D
---------------------- ----------------------
.. cpp:function:: void reprojectImageTo3D( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false ) .. cpp:function:: void reprojectImageTo3D( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int depth=-1 )
Reprojects a disparity image to 3D space. Reprojects a disparity image to 3D space.
@ -849,6 +860,8 @@ reprojectImageTo3D
:param handleMissingValues: Indicates, whether the function should handle missing values (i.e. points where the disparity was not computed). If ``handleMissingValues=true``, then pixels with the minimal disparity that corresponds to the outliers (see :ref:`StereoBM::operator ()` ) are transformed to 3D points with a very large Z value (currently set to 10000). :param handleMissingValues: Indicates, whether the function should handle missing values (i.e. points where the disparity was not computed). If ``handleMissingValues=true``, then pixels with the minimal disparity that corresponds to the outliers (see :ref:`StereoBM::operator ()` ) are transformed to 3D points with a very large Z value (currently set to 10000).
:param ddepth: The optional output array depth. If it is ``-1``, the output image will have ``CV_32F`` depth. ``ddepth`` can also be set to ``CV_16S``, ``CV_32S`` or ``CV_32F``.
The function transforms a single-channel disparity map to a 3-channel image representing a 3D surface. That is, for each pixel ``(x,y)`` andthe corresponding disparity ``d=disparity(x,y)`` , it computes: The function transforms a single-channel disparity map to a 3-channel image representing a 3D surface. That is, for each pixel ``(x,y)`` andthe corresponding disparity ``d=disparity(x,y)`` , it computes:
.. math:: .. math::
@ -862,13 +875,10 @@ The matrix ``Q`` can be an arbitrary
.. index:: RQDecomp3x3 .. index:: RQDecomp3x3
.. _RQDecomp3x3:
RQDecomp3x3 RQDecomp3x3
--------------- ---------------
.. cpp:function:: void RQDecomp3x3( InputArray M, OutputArray R, OutputArray Q )
.. cpp:function:: Vec3d RQDecomp3x3( InputArray M, OutputArray R, OutputArray Q, OutputArray Qx, OutputArray Qy, OutputArray Qz ) .. cpp:function:: Vec3d RQDecomp3x3( InputArray M, OutputArray R, OutputArray Q, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray() )
Computes an RQ decomposition of 3x3 matrices. Computes an RQ decomposition of 3x3 matrices.
@ -878,11 +888,11 @@ RQDecomp3x3
:param Q: Output 3x3 orthogonal matrix. :param Q: Output 3x3 orthogonal matrix.
:param Qx: Optional 3x3 rotation matrix around x-axis. :param Qx: Optional output 3x3 rotation matrix around x-axis.
:param Qy: Optional 3x3 rotation matrix around y-axis. :param Qy: Optional output 3x3 rotation matrix around y-axis.
:param Qz: Optional 3x3 rotation matrix around z-axis. :param Qz: Optional output 3x3 rotation matrix around z-axis.
The function computes a RQ decomposition using the given rotations. This function is used in The function computes a RQ decomposition using the given rotations. This function is used in
:ref:`DecomposeProjectionMatrix` to decompose the left 3x3 submatrix of a projection matrix into a camera and a rotation matrix. :ref:`DecomposeProjectionMatrix` to decompose the left 3x3 submatrix of a projection matrix into a camera and a rotation matrix.

View File

@ -290,6 +290,6 @@ useOptimized
----------------- -----------------
.. cpp:function:: bool useOptimized() .. cpp:function:: bool useOptimized()
Returns status if the optimized code use Returns status of the optimized code use
The function returns true if the optimized code is enabled, false otherwise. The function returns true if the optimized code is enabled, false otherwise.

View File

@ -490,7 +490,7 @@ gpu::reprojectImageTo3D
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: :c:cpp:func:`reprojectImageTo3D` . See Also: :cpp:func:`reprojectImageTo3D` .
.. index:: gpu::solvePnPRansac .. index:: gpu::solvePnPRansac
@ -507,7 +507,7 @@ gpu::solvePnPRansac
:param camera_mat: 3x3 matrix of intrinsic camera parameters. :param camera_mat: 3x3 matrix of intrinsic camera parameters.
:param dist_coef: Distortion coefficients. See :c:cpp:func:`undistortPoints` for details. :param dist_coef: Distortion coefficients. See :cpp:func:`undistortPoints` for details.
:param rvec: Output 3D rotation vector. :param rvec: Output 3D rotation vector.
@ -523,5 +523,5 @@ gpu::solvePnPRansac
:param inliers: Output vector of inlier indices. :param inliers: Output vector of inlier indices.
See Also :c:cpp:func:`solvePnPRansac`. See Also :cpp:func:`solvePnPRansac`.

View File

@ -195,7 +195,7 @@ gpu::BruteForceMatcher_GPU::match
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.
See Also: See Also:
:c:cpp:func:`DescriptorMatcher::match` :cpp:func:`DescriptorMatcher::match`
.. index:: gpu::BruteForceMatcher_GPU::matchSingle .. index:: gpu::BruteForceMatcher_GPU::matchSingle

View File

@ -224,7 +224,7 @@ gpu::createBoxFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`boxFilter` See Also: :cpp:func:`boxFilter`
.. index:: gpu::boxFilter .. index:: gpu::boxFilter
@ -248,7 +248,7 @@ gpu::boxFilter
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`boxFilter` See Also: :cpp:func:`boxFilter`
.. index:: gpu::blur .. index:: gpu::blur
@ -270,7 +270,7 @@ gpu::blur
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`blur`, :cpp:func:`gpu::boxFilter` See Also: :cpp:func:`blur`, :cpp:func:`gpu::boxFilter`
.. index:: gpu::createMorphologyFilter_GPU .. index:: gpu::createMorphologyFilter_GPU
@ -296,7 +296,7 @@ gpu::createMorphologyFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`createMorphologyFilter` See Also: :cpp:func:`createMorphologyFilter`
.. index:: gpu::erode .. index:: gpu::erode
@ -320,7 +320,7 @@ gpu::erode
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`erode` See Also: :cpp:func:`erode`
.. index:: gpu::dilate .. index:: gpu::dilate
@ -344,7 +344,7 @@ gpu::dilate
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`dilate` See Also: :cpp:func:`dilate`
.. index:: gpu::morphologyEx .. index:: gpu::morphologyEx
@ -381,7 +381,7 @@ gpu::morphologyEx
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`morphologyEx` See Also: :cpp:func:`morphologyEx`
.. index:: gpu::createLinearFilter_GPU .. index:: gpu::createLinearFilter_GPU
@ -407,7 +407,7 @@ gpu::createLinearFilter_GPU
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`createLinearFilter` See Also: :cpp:func:`createLinearFilter`
.. index:: gpu::filter2D .. index:: gpu::filter2D
@ -431,7 +431,7 @@ gpu::filter2D
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`filter2D` See Also: :cpp:func:`filter2D`
.. index:: gpu::Laplacian .. index:: gpu::Laplacian
@ -447,15 +447,15 @@ gpu::Laplacian
:param ddepth: Desired depth of the destination image. It supports only the same depth as the source image depth. :param ddepth: Desired depth of the destination image. It supports only the same depth as the source image depth.
:param ksize: Aperture size used to compute the second-derivative filters (see :c:cpp:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported. :param ksize: Aperture size used to compute the second-derivative filters (see :cpp:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :c:cpp:func:`getDerivKernels` ). :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :cpp:func:`getDerivKernels` ).
**Note:** **Note:**
This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
See Also: :c:cpp:func:`Laplacian`,:cpp:func:`gpu::filter2D` . See Also: :cpp:func:`Laplacian`,:cpp:func:`gpu::filter2D` .
.. index:: gpu::getLinearRowFilter_GPU .. index:: gpu::getLinearRowFilter_GPU
@ -473,7 +473,7 @@ gpu::getLinearRowFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center. :param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType: Pixel extrapolation method. For details, see :c:cpp:func:`borderInterpolate`. For details on limitations, see below. :param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`. For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV. There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. * NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
@ -497,13 +497,13 @@ gpu::getLinearColumnFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center. :param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType: Pixel extrapolation method. For details, see :c:cpp:func:`borderInterpolate` . For details on limitations, see below. :param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` . For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV. There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. * NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image. * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :c:cpp:func:`createSeparableLinearFilter` See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
.. index:: gpu::createSeparableLinearFilter_GPU .. index:: gpu::createSeparableLinearFilter_GPU
@ -521,10 +521,10 @@ gpu::createSeparableLinearFilter_GPU
:param anchor: Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center. :param anchor: Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center.
:param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :c:cpp:func:`borderInterpolate`. For details on limitations, see :cpp:func:`gpu::getLinearRowFilter_GPU`, cpp:cpp:func:`gpu::getLinearColumnFilter_GPU`. :param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :cpp:func:`borderInterpolate`. For details on limitations, see :cpp:func:`gpu::getLinearRowFilter_GPU`, cpp:cpp:func:`gpu::getLinearColumnFilter_GPU`.
See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`gpu::getLinearColumnFilter_GPU`, :c:cpp:func:`createSeparableLinearFilter` See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`gpu::getLinearColumnFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
.. index:: gpu::sepFilter2D .. index:: gpu::sepFilter2D
@ -544,9 +544,9 @@ gpu::sepFilter2D
:param anchor: Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center. :param anchor: Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center.
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :c:cpp:func:`borderInterpolate`. :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :c:cpp:func:`sepFilter2D` See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`sepFilter2D`
.. index:: gpu::createDerivFilter_GPU .. index:: gpu::createDerivFilter_GPU
@ -564,11 +564,11 @@ gpu::createDerivFilter_GPU
:param dy: Derivative order in respect of y. :param dy: Derivative order in respect of y.
:param ksize: Aperture size. See :c:cpp:func:`getDerivKernels` for details. :param ksize: Aperture size. See :cpp:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :c:cpp:func:`borderInterpolate` for details. :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :c:cpp:func:`createDerivFilter` See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createDerivFilter`
.. index:: gpu::Sobel .. index:: gpu::Sobel
@ -590,11 +590,11 @@ gpu::Sobel
:param ksize: Size of the extended Sobel kernel. Possible valies are 1, 3, 5 or 7. :param ksize: Size of the extended Sobel kernel. Possible valies are 1, 3, 5 or 7.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :c:cpp:func:`getDerivKernels` . :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :cpp:func:`getDerivKernels` .
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :c:cpp:func:`borderInterpolate` for details. :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :c:cpp:func:`Sobel` See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Sobel`
.. index:: gpu::Scharr .. index:: gpu::Scharr
@ -614,11 +614,11 @@ gpu::Scharr
:param yorder: Order of the derivative y. :param yorder: Order of the derivative y.
:param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :c:cpp:func:`getDerivKernels` for details. :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details.
:param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :c:cpp:func:`borderInterpolate` and :c:cpp:func:`Scharr` . :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` and :cpp:func:`Scharr` .
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :c:cpp:func:`Scharr` See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Scharr`
.. index:: gpu::createGaussianFilter_GPU .. index:: gpu::createGaussianFilter_GPU
@ -630,15 +630,15 @@ gpu::createGaussianFilter_GPU
:param type: Source and destination image type. ``CV_8UC1``, ``CV_8UC4``, ``CV_16SC1``, ``CV_16SC2``, ``CV_32SC1``, ``CV_32FC1`` are supported. :param type: Source and destination image type. ``CV_8UC1``, ``CV_8UC4``, ``CV_16SC1``, ``CV_16SC2``, ``CV_32SC1``, ``CV_32FC1`` are supported.
:param ksize: Aperture size. See :c:cpp:func:`getGaussianKernel` for details. :param ksize: Aperture size. See :cpp:func:`getGaussianKernel` for details.
:param sigmaX: Gaussian sigma in the horizontal direction. See :c:cpp:func:`getGaussianKernel` for details. :param sigmaX: Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` for details.
:param sigmaY: Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` . :param sigmaY: Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` .
:param rowBorderType, columnBorderType: Border type to use. See :c:cpp:func:`borderInterpolate` for details. :param rowBorderType, columnBorderType: Border type to use. See :cpp:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :c:cpp:func:`createGaussianFilter` See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createGaussianFilter`
.. index:: gpu::GaussianBlur .. index:: gpu::GaussianBlur
@ -654,11 +654,11 @@ gpu::GaussianBlur
:param ksize: Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigmaX`` and ``sigmaY`` . :param ksize: Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigmaX`` and ``sigmaY`` .
:param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :c:cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` . :param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` .
:param rowBorderType, columnBorderType: Pixel extrapolation method. See :c:cpp:func:`borderInterpolate` for details. :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details.
See Also: :cpp:func:`gpu::createGaussianFilter_GPU`, :c:cpp:func:`GaussianBlur` See Also: :cpp:func:`gpu::createGaussianFilter_GPU`, :cpp:func:`GaussianBlur`
.. index:: gpu::getMaxFilter_GPU .. index:: gpu::getMaxFilter_GPU

View File

@ -42,7 +42,7 @@ gpu::meanShiftProc
:param criteria: Termination criteria. See :cpp:class:`TermCriteria`. :param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
See Also: See Also:
:c:cpp:func:`gpu::meanShiftFiltering` :cpp:func:`gpu::meanShiftFiltering`
.. index:: gpu::meanShiftSegmentation .. index:: gpu::meanShiftSegmentation
@ -81,7 +81,7 @@ gpu::integral
:param sqsum: Squared integral image of the ``CV_32FC1`` type. :param sqsum: Squared integral image of the ``CV_32FC1`` type.
See Also: See Also:
:c:cpp:func:`integral` :cpp:func:`integral`
.. index:: gpu::sqrIntegral .. index:: gpu::sqrIntegral
@ -128,7 +128,7 @@ gpu::cornerHarris
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now. :param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
See Also: See Also:
:c:cpp:func:`cornerHarris` :cpp:func:`cornerHarris`
.. index:: gpu::cornerMinEigenVal .. index:: gpu::cornerMinEigenVal
@ -150,7 +150,7 @@ gpu::cornerMinEigenVal
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now. :param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
See also: :c:cpp:func:`cornerMinEigenVal` See also: :cpp:func:`cornerMinEigenVal`
.. index:: gpu::mulSpectrums .. index:: gpu::mulSpectrums
@ -173,7 +173,7 @@ gpu::mulSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now. Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also: See Also:
:c:cpp:func:`mulSpectrums` :cpp:func:`mulSpectrums`
.. index:: gpu::mulAndScaleSpectrums .. index:: gpu::mulAndScaleSpectrums
@ -198,7 +198,7 @@ gpu::mulAndScaleSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now. Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also: See Also:
:c:cpp:func:`mulSpectrums` :cpp:func:`mulSpectrums`
.. index:: gpu::dft .. index:: gpu::dft
@ -237,7 +237,7 @@ gpu::dft
If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width. If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width.
See Also: See Also:
:c:cpp:func:`dft` :cpp:func:`dft`
.. index:: gpu::convolve .. index:: gpu::convolve
@ -268,7 +268,7 @@ gpu::ConvolveBuf
.. cpp:class:: gpu::ConvolveBuf .. cpp:class:: gpu::ConvolveBuf
This class provides a memory buffer for the This class provides a memory buffer for the
:c:cpp:func:`gpu::convolve` function. :cpp:func:`gpu::convolve` function.
:: ::
struct CV_EXPORTS ConvolveBuf struct CV_EXPORTS ConvolveBuf
@ -290,12 +290,12 @@ gpu::ConvolveBuf::ConvolveBuf
.. cpp:function:: ConvolveBuf::ConvolveBuf() .. cpp:function:: ConvolveBuf::ConvolveBuf()
Constructs an empty buffer that is properly resized after the first call of the Constructs an empty buffer that is properly resized after the first call of the
:c:cpp:func:`convolve` function. :cpp:func:`convolve` function.
.. cpp:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size) .. cpp:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size)
Constructs a buffer for the Constructs a buffer for the
:c:cpp:func:`convolve` function with respective arguments. :cpp:func:`convolve` function with respective arguments.
.. index:: gpu::matchTemplate .. index:: gpu::matchTemplate
@ -328,7 +328,7 @@ gpu::matchTemplate
* ``CV_TM_CCORR`` * ``CV_TM_CCORR``
See Also: See Also:
:c:cpp:func:`matchTemplate` :cpp:func:`matchTemplate`
.. index:: gpu::remap .. index:: gpu::remap
@ -354,7 +354,7 @@ gpu::remap
Values of pixels with non-integer coordinates are computed using bilinear the interpolation. Values of pixels with non-integer coordinates are computed using bilinear the interpolation.
See Also: :c:cpp:func:`remap` See Also: :cpp:func:`remap`
.. index:: gpu::cvtColor .. index:: gpu::cvtColor

View File

@ -17,7 +17,7 @@ gpu::meanStdDev
:param stddev: Standard deviation value. :param stddev: Standard deviation value.
See Also: :c:cpp:func:`meanStdDev` See Also: :cpp:func:`meanStdDev`
.. index:: gpu::norm .. index:: gpu::norm
@ -37,7 +37,7 @@ gpu::norm
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically. :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
See Also: :c:cpp:func:`norm` See Also: :cpp:func:`norm`
.. index:: gpu::sum .. index:: gpu::sum
@ -53,7 +53,7 @@ gpu::sum
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically. :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
See Also: :c:cpp:func:`sum` See Also: :cpp:func:`sum`
.. index:: gpu::absSum .. index:: gpu::absSum
@ -105,7 +105,7 @@ gpu::minMax
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3. The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
See Also: :c:cpp:func:`minMaxLoc` See Also: :cpp:func:`minMaxLoc`
.. index:: gpu::minMaxLoc .. index:: gpu::minMaxLoc
@ -135,7 +135,7 @@ gpu::minMaxLoc
The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3. The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
See Also: :c:cpp:func:`minMaxLoc` See Also: :cpp:func:`minMaxLoc`
.. index:: gpu::countNonZero .. index:: gpu::countNonZero
@ -153,4 +153,4 @@ gpu::countNonZero
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3. The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
See Also: :c:cpp:func:`countNonZero` See Also: :cpp:func:`countNonZero`

View File

@ -324,5 +324,5 @@ gpu::CascadeClassifier_GPU::detectMultiScale
imshow("Faces", image_cpu); imshow("Faces", image_cpu);
See Also: :c:cpp:func:`CascadeClassifier::detectMultiScale` See Also: :cpp:func:`CascadeClassifier::detectMultiScale`

View File

@ -16,7 +16,7 @@ gpu::transpose
:param dst: Destination matrix. :param dst: Destination matrix.
See Also: See Also:
:c:cpp:func:`transpose` :cpp:func:`transpose`
.. index:: gpu::flip .. index:: gpu::flip
@ -40,7 +40,7 @@ gpu::flip
See Also: See Also:
:c:cpp:func:`flip` :cpp:func:`flip`
.. index:: gpu::LUT .. index:: gpu::LUT
@ -57,7 +57,7 @@ gpu::LUT
:param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src``. :param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src``.
See Also: :c:cpp:func:`LUT` See Also: :cpp:func:`LUT`
.. index:: gpu::merge .. index:: gpu::merge
@ -81,7 +81,7 @@ gpu::merge
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: :c:cpp:func:`merge` See Also: :cpp:func:`merge`
.. index:: gpu::split .. index:: gpu::split
@ -103,7 +103,7 @@ gpu::split
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: :c:cpp:func:`split` See Also: :cpp:func:`split`
.. index:: gpu::magnitude .. index:: gpu::magnitude
@ -128,7 +128,7 @@ gpu::magnitude
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: See Also:
:c:cpp:func:`magnitude` :cpp:func:`magnitude`
.. index:: gpu::magnitudeSqr .. index:: gpu::magnitudeSqr
@ -173,7 +173,7 @@ gpu::phase
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: See Also:
:c:cpp:func:`phase` :cpp:func:`phase`
.. index:: gpu::cartToPolar .. index:: gpu::cartToPolar
@ -198,7 +198,7 @@ gpu::cartToPolar
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: See Also:
:c:cpp:func:`cartToPolar` :cpp:func:`cartToPolar`
.. index:: gpu::polarToCart .. index:: gpu::polarToCart
@ -223,4 +223,4 @@ gpu::polarToCart
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: See Also:
:c:cpp:func:`polarToCart` :cpp:func:`polarToCart`

View File

@ -21,7 +21,7 @@ gpu::add
:param dst: Destination matrix with the same size and type as ``src1``. :param dst: Destination matrix with the same size and type as ``src1``.
See Also: :c:cpp:func:`add` See Also: :cpp:func:`add`
.. index:: gpu::subtract .. index:: gpu::subtract
@ -39,7 +39,7 @@ gpu::subtract
:param dst: Destination matrix with the same size and type as ``src1``. :param dst: Destination matrix with the same size and type as ``src1``.
See Also: :c:cpp:func:`subtract` See Also: :cpp:func:`subtract`
@ -59,7 +59,7 @@ gpu::multiply
:param dst: Destination matrix with the same size and type as ``src1``. :param dst: Destination matrix with the same size and type as ``src1``.
See Also: :c:cpp:func:`multiply` See Also: :cpp:func:`multiply`
.. index:: gpu::divide .. index:: gpu::divide
@ -78,9 +78,9 @@ gpu::divide
:param dst: Destination matrix with the same size and type as ``src1``. :param dst: Destination matrix with the same size and type as ``src1``.
This function, in contrast to :c:cpp:func:`divide`, uses a round-down rounding mode. This function, in contrast to :cpp:func:`divide`, uses a round-down rounding mode.
See Also: :c:cpp:func:`divide` See Also: :cpp:func:`divide`
@ -96,7 +96,7 @@ gpu::exp
:param dst: Destination matrix with the same size and type as ``src``. :param dst: Destination matrix with the same size and type as ``src``.
See Also: :c:cpp:func:`exp` See Also: :cpp:func:`exp`
@ -112,7 +112,7 @@ gpu::log
:param dst: Destination matrix with the same size and type as ``src``. :param dst: Destination matrix with the same size and type as ``src``.
See Also: :c:cpp:func:`log` See Also: :cpp:func:`log`
@ -132,7 +132,7 @@ gpu::absdiff
:param dst: Destination matrix with the same size and type as ``src1``. :param dst: Destination matrix with the same size and type as ``src1``.
See Also: :c:cpp:func:`absdiff` See Also: :cpp:func:`absdiff`
.. index:: gpu::compare .. index:: gpu::compare
@ -157,7 +157,7 @@ gpu::compare
* **CMP_LE:** ``src1(.) <= src2(.)`` * **CMP_LE:** ``src1(.) <= src2(.)``
* **CMP_NE:** ``src1(.) != src2(.)`` * **CMP_NE:** ``src1(.) != src2(.)``
See Also: :c:cpp:func:`compare` See Also: :cpp:func:`compare`
.. index:: gpu::bitwise_not .. index:: gpu::bitwise_not
@ -268,7 +268,7 @@ gpu::min
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: :c:cpp:func:`min` See Also: :cpp:func:`min`
@ -294,4 +294,4 @@ gpu::max
:param stream: Stream for the asynchronous version. :param stream: Stream for the asynchronous version.
See Also: :c:cpp:func:`max` See Also: :cpp:func:`max`

View File

@ -697,7 +697,7 @@ createMorphologyFilter
.. cpp:function:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1) .. cpp:function:: Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1)
.. cpp:function:: static inline Scalar morphologyDefaultBorderValue(){ return Scalar::all(DBL_MAX) } .. cpp:function:: Scalar morphologyDefaultBorderValue()
Creates an engine for non-separable morphological operations. Creates an engine for non-separable morphological operations.

View File

@ -107,9 +107,9 @@ See Also:
findContours findContours
---------------- ----------------
.. cpp:function:: void findContours( InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) .. cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
.. cpp:function:: void findContours( InputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) .. cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
Finds contours in a binary image. Finds contours in a binary image.
@ -264,75 +264,17 @@ boundingRect
The function calculates and returns the minimal up-right bounding rectangle for the specified point set. The function calculates and returns the minimal up-right bounding rectangle for the specified point set.
.. index:: estimateRigidTransform
estimateRigidTransform
--------------------------
.. cpp:function:: Mat estimateRigidTransform( InputArray srcpt, InputArray dstpt, bool fullAffine )
Computes an optimal affine transformation between two 2D point sets.
:param srcpt: The first input 2D point set, stored in ``std::vector`` or ``Mat``.
:param dst: The second input 2D point set of the same size and the same type as ``A`` .
:param fullAffine: If true, the function finds an optimal affine transformation with no additional resrictions (6 degrees of freedom). Otherwise, the class of transformations to choose from is limited to combinations of translation, rotation, and uniform scaling (5 degrees of freedom).
The function finds an optimal affine transform
:math:`[A|b]` (a
:math:`2 \times 3` floating-point matrix) that approximates best the transformation from
:math:`\texttt{srcpt}_i` to
:math:`\texttt{dstpt}_i` :
.. math::
[A^*|b^*] = arg \min _{[A|b]} \sum _i \| \texttt{dstpt} _i - A { \texttt{srcpt} _i}^T - b \| ^2
where
:math:`[A|b]` can be either arbitrary (when ``fullAffine=true`` ) or have form
.. math::
\begin{bmatrix} a_{11} & a_{12} & b_1 \\ -a_{12} & a_{11} & b_2 \end{bmatrix}
when ``fullAffine=false`` .
See Also:
:cpp:func:`getAffineTransform`,
:cpp:func:`getPerspectiveTransform`,
:cpp:func:`findHomography`
.. index:: estimateAffine3D
estimateAffine3D
--------------------
.. cpp:function:: int estimateAffine3D(InputArray srcpt, InputArray dstpt, OutputArray out, OutputArray outliers, double ransacThreshold = 3.0, double confidence = 0.99)
Computes an optimal affine transformation between two 3D point sets.
:param srcpt: The first input 3D point set.
:param dstpt: The second input 3D point set.
:param out: Output 3D affine transformation matrix :math:`3 \times 4` .
:param outliers: Output vector indicating which points are outliers.
:param ransacThreshold: Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier.
:param confidence: The confidence level, between 0 and 1, that the estimated transformation will have. Anything between 0.95 and 0.99 is usually good enough. Too close to 1 values can slow down the estimation too much, lower than 0.8-0.9 confidence values can result in an incorrectly estimated transformation.
The function estimates an optimal 3D affine transformation between two 3D point sets using the RANSAC algorithm.
.. index:: contourArea .. index:: contourArea
contourArea contourArea
--------------- ---------------
.. cpp:function:: double contourArea( InputArray contour ) .. cpp:function:: double contourArea( InputArray contour, bool oriented=false )
Calculates a contour area. Calculates a contour area.
:param contour: Input vector of 2d points (contour vertices), stored in ``std::vector`` or ``Mat``. :param contour: Input vector of 2d points (contour vertices), stored in ``std::vector`` or ``Mat``.
:param orientation: Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking sign of the area. By default the parameter is ``false``, which means that the absolute value is returned.
The function computes a contour area. Similarly to The function computes a contour area. Similarly to
:cpp:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using :cpp:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using

View File

@ -669,7 +669,7 @@ CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
//! computes back projection for the set of images //! computes back projection for the set of images
CV_EXPORTS void calcBackProject( const Mat* images, int nimages, CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
const int* channels, const SparseMat& hist, const int* channels, const SparseMat& hist,
Mat& backProject, const float** ranges, OutputArray backProject, const float** ranges,
double scale=1, bool uniform=true ); double scale=1, bool uniform=true );
//! compares two histograms stored in dense arrays //! compares two histograms stored in dense arrays

View File

@ -1283,7 +1283,7 @@ calcSparseBackProj_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
} }
void cv::calcBackProject( const Mat* images, int nimages, const int* channels, void cv::calcBackProject( const Mat* images, int nimages, const int* channels,
const SparseMat& hist, Mat& backProject, const SparseMat& hist, OutputArray _backProject,
const float** ranges, double scale, bool uniform ) const float** ranges, double scale, bool uniform )
{ {
vector<uchar*> ptrs; vector<uchar*> ptrs;
@ -1293,7 +1293,8 @@ void cv::calcBackProject( const Mat* images, int nimages, const int* channels,
int dims = hist.dims(); int dims = hist.dims();
CV_Assert( dims > 0 ); CV_Assert( dims > 0 );
backProject.create( images[0].size(), images[0].depth() ); _backProject.create( images[0].size(), images[0].depth() );
Mat backProject = _backProject.getMat();
histPrepareImages( images, nimages, channels, backProject, histPrepareImages( images, nimages, channels, backProject,
dims, hist.hdr->size, ranges, dims, hist.hdr->size, ranges,
uniform, ptrs, deltas, imsize, uniranges ); uniform, ptrs, deltas, imsize, uniranges );

View File

@ -127,7 +127,7 @@ Weak tree classifier ::
virtual ~CvBoostTree(); virtual ~CvBoostTree();
virtual bool train( CvDTreeTrainData* _train_data, virtual bool train( CvDTreeTrainData* _train_data,
const CvMat* subsample_idx, CvBoost* ensemble ); const Mat& subsample_idx, CvBoost* ensemble );
virtual void scale( double s ); virtual void scale( double s );
virtual void read( CvFileStorage* fs, CvFileNode* node, virtual void read( CvFileStorage* fs, CvFileNode* node,
CvBoost* ensemble, CvDTreeTrainData* _data ); CvBoost* ensemble, CvDTreeTrainData* _data );
@ -173,21 +173,21 @@ Boosted tree classifier ::
CvBoost(); CvBoost();
virtual ~CvBoost(); virtual ~CvBoost();
CvBoost( const CvMat* _train_data, int _tflag, CvBoost( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=0,
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=0, const Mat& _var_type=0,
const CvMat* _missing_mask=0, const Mat& _missing_mask=0,
CvBoostParams params=CvBoostParams() ); CvBoostParams params=CvBoostParams() );
virtual bool train( const CvMat* _train_data, int _tflag, virtual bool train( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=0,
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=0, const Mat& _var_type=0,
const CvMat* _missing_mask=0, const Mat& _missing_mask=0,
CvBoostParams params=CvBoostParams(), CvBoostParams params=CvBoostParams(),
bool update=false ); bool update=false );
virtual float predict( const CvMat* _sample, const CvMat* _missing=0, virtual float predict( const Mat& _sample, const Mat& _missing=0,
CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ, Mat& weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
bool raw_mode=false ) const; bool raw_mode=false ) const;
virtual void prune( CvSlice slice ); virtual void prune( CvSlice slice );
@ -221,7 +221,7 @@ Boosted tree classifier ::
CvBoost::train CvBoost::train
-------------- --------------
.. cpp: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 ) .. cpp:function:: bool CvBoost::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvBoostParams params=CvBoostParams(), bool update=false )
Trains a boosted tree classifier. Trains a boosted tree classifier.
@ -233,7 +233,7 @@ The train method follows the common template. The last parameter ``update`` spec
CvBoost::predict CvBoost::predict
---------------- ----------------
.. cpp: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 .. cpp:function:: float CvBoost::predict( const Mat& sample, const Mat& missing=Mat(), const Range& slice=Range::all(), bool rawMode=false, bool returnSum=false ) const
Predicts a response for an input sample. Predicts a response for an input sample.

View File

@ -166,27 +166,27 @@ Decision tree training data and shared data for tree ensembles ::
struct CvDTreeTrainData struct CvDTreeTrainData
{ {
CvDTreeTrainData(); CvDTreeTrainData();
CvDTreeTrainData( const CvMat* _train_data, int _tflag, CvDTreeTrainData( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=Mat(),
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(),
const CvMat* _missing_mask=0, const Mat& _missing_mask=Mat(),
const CvDTreeParams& _params=CvDTreeParams(), const CvDTreeParams& _params=CvDTreeParams(),
bool _shared=false, bool _add_labels=false ); bool _shared=false, bool _add_labels=false );
virtual ~CvDTreeTrainData(); virtual ~CvDTreeTrainData();
virtual void set_data( const CvMat* _train_data, int _tflag, virtual void set_data( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=Mat(),
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(),
const CvMat* _missing_mask=0, const Mat& _missing_mask=Mat(),
const CvDTreeParams& _params=CvDTreeParams(), const CvDTreeParams& _params=CvDTreeParams(),
bool _shared=false, bool _add_labels=false, bool _shared=false, bool _add_labels=false,
bool _update_data=false ); bool _update_data=false );
virtual void get_vectors( const CvMat* _subsample_idx, virtual void get_vectors( const Mat& _subsample_idx,
float* values, uchar* missing, float* responses, float* values, uchar* missing, float* responses,
bool get_class_idx=false ); bool get_class_idx=false );
virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx ); virtual CvDTreeNode* subsample_data( const Mat& _subsample_idx );
virtual void write_params( CvFileStorage* fs ); virtual void write_params( CvFileStorage* fs );
virtual void read_params( CvFileStorage* fs, CvFileNode* node ); virtual void read_params( CvFileStorage* fs, CvFileNode* node );
@ -226,20 +226,20 @@ Decision tree training data and shared data for tree ensembles ::
int buf_count, buf_size; int buf_count, buf_size;
bool shared; bool shared;
CvMat* cat_count; Mat& cat_count;
CvMat* cat_ofs; Mat& cat_ofs;
CvMat* cat_map; Mat& cat_map;
CvMat* counts; Mat& counts;
CvMat* buf; Mat& buf;
CvMat* direction; Mat& direction;
CvMat* split_buf; Mat& split_buf;
CvMat* var_idx; Mat& var_idx;
CvMat* var_type; // i-th element = Mat& var_type; // i-th element =
// k<0 - ordered // k<0 - ordered
// k>=0 - categorical, see k-th element of cat_* arrays // k>=0 - categorical, see k-th element of cat_* arrays
CvMat* priors; Mat& priors;
CvDTreeParams params; CvDTreeParams params;
@ -294,19 +294,19 @@ Decision tree ::
CvDTree(); CvDTree();
virtual ~CvDTree(); virtual ~CvDTree();
virtual bool train( const CvMat* _train_data, int _tflag, virtual bool train( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=Mat(),
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(),
const CvMat* _missing_mask=0, const Mat& _missing_mask=Mat(),
CvDTreeParams params=CvDTreeParams() ); CvDTreeParams params=CvDTreeParams() );
virtual bool train( CvDTreeTrainData* _train_data, virtual bool train( CvDTreeTrainData* _train_data,
const CvMat* _subsample_idx ); const Mat& _subsample_idx );
virtual CvDTreeNode* predict( const CvMat* _sample, virtual CvDTreeNode* predict( const Mat& _sample,
const CvMat* _missing_data_mask=0, const Mat& _missing_data_mask=Mat(),
bool raw_mode=false ) const; bool raw_mode=false ) const;
virtual const CvMat* get_var_importance(); virtual const Mat& get_var_importance();
virtual void clear(); virtual void clear();
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node );
@ -323,7 +323,7 @@ Decision tree ::
protected: protected:
virtual bool do_train( const CvMat* _subsample_idx ); virtual bool do_train( const Mat& _subsample_idx );
virtual void try_split_node( CvDTreeNode* n ); virtual void try_split_node( CvDTreeNode* n );
virtual void split_node_data( CvDTreeNode* n ); virtual void split_node_data( CvDTreeNode* n );
@ -359,7 +359,7 @@ Decision tree ::
CvDTreeNode* root; CvDTreeNode* root;
int pruned_tree_idx; int pruned_tree_idx;
CvMat* var_importance; Mat& var_importance;
CvDTreeTrainData* data; CvDTreeTrainData* data;
}; };
@ -371,9 +371,9 @@ Decision tree ::
CvDTree::train CvDTree::train
-------------- --------------
.. cpp: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() ) .. cpp:function:: bool CvDTree::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvDTreeParams params=CvDTreeParams() )
.. cpp:function:: bool CvDTree::train( CvDTreeTrainData* _train_data, const CvMat* _subsample_idx ) .. cpp:function:: bool CvDTree::train( CvDTreeTrainData* _train_data, const Mat& _subsample_idx )
Trains a decision tree. Trains a decision tree.
@ -391,7 +391,7 @@ There are two ``train`` methods in ``CvDTree`` :
CvDTree::predict CvDTree::predict
---------------- ----------------
.. cpp:function:: CvDTreeNode* CvDTree::predict( const CvMat* _sample, const CvMat* _missing_data_mask=0, bool raw_mode=false ) const .. cpp:function:: CvDTreeNode* CvDTree::predict( const Mat& _sample, const Mat& _missing_data_mask=Mat(), bool raw_mode=false ) const
Returns the leaf node of a decision tree corresponding to the input vector. Returns the leaf node of a decision tree corresponding to the input vector.

View File

@ -108,8 +108,8 @@ Parameters of the EM algorithm ::
CvTermCriteria _term_crit=cvTermCriteria( CvTermCriteria _term_crit=cvTermCriteria(
CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,
100, FLT_EPSILON), 100, FLT_EPSILON),
CvMat* _probs=0, CvMat* _weights=0, const CvMat* _probs=0, const CvMat* _weights=0,
CvMat* _means=0, CvMat** _covs=0 ) : const CvMat* _means=0, const CvMat** _covs=0 ) :
nclusters(_nclusters), cov_mat_type(_cov_mat_type), nclusters(_nclusters), cov_mat_type(_cov_mat_type),
start_step(_start_step), start_step(_start_step),
probs(_probs), weights(_weights), means(_means), covs(_covs), probs(_probs), weights(_weights), means(_means), covs(_covs),
@ -149,21 +149,21 @@ EM model ::
enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 }; enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 };
CvEM(); CvEM();
CvEM( const CvMat* samples, const CvMat* sample_idx=0, CvEM( const Mat& samples, const Mat& sample_idx=Mat(),
CvEMParams params=CvEMParams(), CvMat* labels=0 ); CvEMParams params=CvEMParams(), Mat* labels=0 );
virtual ~CvEM(); virtual ~CvEM();
virtual bool train( const CvMat* samples, const CvMat* sample_idx=0, virtual bool train( const Mat& samples, const Mat& sample_idx=Mat(),
CvEMParams params=CvEMParams(), CvMat* labels=0 ); CvEMParams params=CvEMParams(), Mat* labels=0 );
virtual float predict( const CvMat* sample, CvMat* probs ) const; virtual float predict( const Mat& sample, Mat& probs ) const;
virtual void clear(); virtual void clear();
int get_nclusters() const { return params.nclusters; } int get_nclusters() const { return params.nclusters; }
const CvMat* get_means() const { return means; } const Mat& get_means() const { return means; }
const CvMat** get_covs() const { return covs; } const Mat&* get_covs() const { return covs; }
const CvMat* get_weights() const { return weights; } const Mat& get_weights() const { return weights; }
const CvMat* get_probs() const { return probs; } const Mat& get_probs() const { return probs; }
protected: protected:
@ -173,19 +173,19 @@ EM model ::
virtual double run_em( const CvVectors& train_data ); virtual double run_em( const CvVectors& train_data );
virtual void init_auto( const CvVectors& samples ); virtual void init_auto( const CvVectors& samples );
virtual void kmeans( const CvVectors& train_data, int nclusters, virtual void kmeans( const CvVectors& train_data, int nclusters,
CvMat* labels, CvTermCriteria criteria, Mat& labels, CvTermCriteria criteria,
const CvMat* means ); const Mat& means );
CvEMParams params; CvEMParams params;
double log_likelihood; double log_likelihood;
CvMat* means; Mat& means;
CvMat** covs; Mat&* covs;
CvMat* weights; Mat& weights;
CvMat* probs; Mat& probs;
CvMat* log_weight_div_det; Mat& log_weight_div_det;
CvMat* inv_eigen_values; Mat& inv_eigen_values;
CvMat** cov_rotate_mats; Mat&* cov_rotate_mats;
}; };
@ -195,7 +195,7 @@ EM model ::
CvEM::train CvEM::train
----------- -----------
.. cpp:function:: void CvEM::train( const CvMat* samples, const CvMat* sample_idx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 ) .. cpp:function:: void CvEM::train( const Mat& samples, const Mat& sample_idx=Mat(), CvEMParams params=CvEMParams(), Mat* labels=0 )
Estimates the Gaussian mixture parameters from a sample set. Estimates the Gaussian mixture parameters from a sample set.
@ -210,110 +210,7 @@ Unlike many of the ML models, EM is an unsupervised learning algorithm and it do
The trained model can be used further for prediction, just like any other classifier. The trained model is similar to the The trained model can be used further for prediction, just like any other classifier. The trained model is similar to the
:ref:`Bayes classifier`. :ref:`Bayes classifier`.
Example: Clustering random samples of multi-Gaussian distribution using EM :: For example of clustering random samples of multi-Gaussian distribution using EM see em.cpp sample in OpenCV distribution.
#include "ml.h"
#include "highgui.h"
int main( int argc, char** argv )
{
const int N = 4;
const int N1 = (int)sqrt((double)N);
const CvScalar colors[] = {{0,0,255}},{{0,255,0}},
{{0,255,255}},{{255,255,0}
;
int i, j;
int nsamples = 100;
CvRNG rng_state = cvRNG(-1);
CvMat* samples = cvCreateMat( nsamples, 2, CV_32FC1 );
CvMat* labels = cvCreateMat( nsamples, 1, CV_32SC1 );
IplImage* img = cvCreateImage( cvSize( 500, 500 ), 8, 3 );
float _sample[2];
CvMat sample = cvMat( 1, 2, CV_32FC1, _sample );
CvEM em_model;
CvEMParams params;
CvMat samples_part;
cvReshape( samples, samples, 2, 0 );
for( i = 0; i < N; i++ )
{
CvScalar mean, sigma;
// form the training samples
cvGetRows( samples, &samples_part, i*nsamples/N,
(i+1)*nsamples/N );
mean = cvScalar(((i
((i/N1)+1.)*img->height/(N1+1));
sigma = cvScalar(30,30);
cvRandArr( &rng_state, &samples_part, CV_RAND_NORMAL,
mean, sigma );
}
cvReshape( samples, samples, 1, 0 );
// initialize model parameters
params.covs = NULL;
params.means = NULL;
params.weights = NULL;
params.probs = NULL;
params.nclusters = N;
params.cov_mat_type = CvEM::COV_MAT_SPHERICAL;
params.start_step = CvEM::START_AUTO_STEP;
params.term_crit.max_iter = 10;
params.term_crit.epsilon = 0.1;
params.term_crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS;
// cluster the data
em_model.train( samples, 0, params, labels );
#if 0
// the piece of code shows how to repeatedly optimize the model
// with less-constrained parameters
//(COV_MAT_DIAGONAL instead of COV_MAT_SPHERICAL)
// when the output of the first stage is used as input for the second one.
CvEM em_model2;
params.cov_mat_type = CvEM::COV_MAT_DIAGONAL;
params.start_step = CvEM::START_E_STEP;
params.means = em_model.get_means();
params.covs = (const CvMat**)em_model.get_covs();
params.weights = em_model.get_weights();
em_model2.train( samples, 0, params, labels );
// to use em_model2, replace em_model.predict()
// with em_model2.predict() below
#endif
// classify every image pixel
cvZero( img );
for( i = 0; i < img->height; i++ )
{
for( j = 0; j < img->width; j++ )
{
CvPoint pt = cvPoint(j, i);
sample.data.fl[0] = (float)j;
sample.data.fl[1] = (float)i;
int response = cvRound(em_model.predict( &sample, NULL ));
CvScalar c = colors[response];
cvCircle( img, pt, 1, cvScalar(c.val[0]*0.75,
c.val[1]*0.75,c.val[2]*0.75), CV_FILLED );
}
}
//draw the clustered samples
for( i = 0; i < nsamples; i++ )
{
CvPoint pt;
pt.x = cvRound(samples->data.fl[i*2]);
pt.y = cvRound(samples->data.fl[i*2+1]);
cvCircle( img, pt, 1, colors[labels->data.i[i]], CV_FILLED );
}
cvNamedWindow( "EM-clustering result", 1 );
cvShowImage( "EM-clustering result", img );
cvWaitKey(0);
cvReleaseMat( &samples );
cvReleaseMat( &labels );
return 0;
}

View File

@ -22,15 +22,15 @@ K-Nearest Neighbors model ::
CvKNearest(); CvKNearest();
virtual ~CvKNearest(); virtual ~CvKNearest();
CvKNearest( const CvMat* _train_data, const CvMat* _responses, CvKNearest( const Mat& _train_data, const Mat& _responses,
const CvMat* _sample_idx=0, bool _is_regression=false, int max_k=32 ); const Mat& _sample_idx=Mat(), bool _is_regression=false, int max_k=32 );
virtual bool train( const CvMat* _train_data, const CvMat* _responses, virtual bool train( const Mat& _train_data, const Mat& _responses,
const CvMat* _sample_idx=0, bool is_regression=false, const Mat& _sample_idx=Mat(), bool is_regression=false,
int _max_k=32, bool _update_base=false ); int _max_k=32, bool _update_base=false );
virtual float find_nearest( const CvMat* _samples, int k, CvMat* results, virtual float find_nearest( const Mat& _samples, int k, Mat* results=0,
const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const; const float** neighbors=0, Mat* neighbor_responses=0, Mat* dist=0 ) const;
virtual void clear(); virtual void clear();
int get_max_k() const; int get_max_k() const;
@ -49,7 +49,7 @@ K-Nearest Neighbors model ::
CvKNearest::train CvKNearest::train
----------------- -----------------
.. cpp: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 ) .. cpp:function:: bool CvKNearest::train( const Mat& _train_data, const Mat& _responses, const Mat& _sample_idx=Mat(), bool is_regression=false, int _max_k=32, bool _update_base=false )
Trains the model. Trains the model.
@ -70,7 +70,7 @@ The parameter ``_update_base`` specifies whether the model is trained from scrat
CvKNearest::find_nearest CvKNearest::find_nearest
------------------------ ------------------------
.. cpp: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 .. cpp:function:: float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* results=0, const float** neighbors=0, Mat* neighbor_responses=0, Mat* dist=0 ) const
Finds the neighbors for input vectors. Finds the neighbors for input vectors.
@ -85,7 +85,9 @@ For a custom classification/regression prediction, the method can optionally ret
For each input vector, the neighbors are sorted by their distances to the vector. For each input vector, the neighbors are sorted by their distances to the vector.
If only a single input vector is passed, all output matrices are optional and the predicted value is returned by the method. :: If only a single input vector is passed, all output matrices are optional and the predicted value is returned by the method.
The sample below (currently using the obsolete ``CvMat`` structures) demonstrates the use of the k-nearest classifier for 2D point classification ::
#include "ml.h" #include "ml.h"
#include "highgui.h" #include "highgui.h"

View File

@ -142,23 +142,23 @@ MLP model ::
{ {
public: public:
CvANN_MLP(); CvANN_MLP();
CvANN_MLP( const CvMat* _layer_sizes, CvANN_MLP( const Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM, int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 ); double _f_param1=0, double _f_param2=0 );
virtual ~CvANN_MLP(); virtual ~CvANN_MLP();
virtual void create( const CvMat* _layer_sizes, virtual void create( const Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM, int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 ); double _f_param1=0, double _f_param2=0 );
virtual int train( const CvMat* _inputs, const CvMat* _outputs, virtual int train( const Mat& _inputs, const Mat& _outputs,
const CvMat* _sample_weights, const Mat& _sample_weights,
const CvMat* _sample_idx=0, const Mat& _sample_idx=Mat(),
CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(),
int flags=0 ); int flags=0 );
virtual float predict( const CvMat* _inputs, virtual float predict( const Mat& _inputs,
CvMat* _outputs ) const; Mat& _outputs ) const;
virtual void clear(); virtual void clear();
@ -172,12 +172,12 @@ MLP model ::
virtual void write( CvFileStorage* storage, const char* name ); virtual void write( CvFileStorage* storage, const char* name );
int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; } int get_layer_count() { return layer_sizes ? layer_sizes->cols : 0; }
const CvMat* get_layer_sizes() { return layer_sizes; } const Mat& get_layer_sizes() { return layer_sizes; }
protected: protected:
virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs, virtual bool prepare_to_train( const Mat& _inputs, const Mat& _outputs,
const CvMat* _sample_weights, const CvMat* _sample_idx, const Mat& _sample_weights, const Mat& _sample_idx,
CvANN_MLP_TrainParams _params, CvANN_MLP_TrainParams _params,
CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags ); CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags );
@ -189,23 +189,23 @@ MLP model ::
virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs, virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs,
const double* _sw ); const double* _sw );
virtual void calc_activ_func( CvMat* xf, const double* bias ) const; virtual void calc_activ_func( Mat& xf, const double* bias ) const;
virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv, virtual void calc_activ_func_deriv( Mat& xf, Mat& deriv,
const double* bias ) const; const double* bias ) const;
virtual void set_activ_func( int _activ_func=SIGMOID_SYM, virtual void set_activ_func( int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 ); double _f_param1=0, double _f_param2=0 );
virtual void init_weights(); virtual void init_weights();
virtual void scale_input( const CvMat* _src, CvMat* _dst ) const; virtual void scale_input( const Mat& _src, Mat& _dst ) const;
virtual void scale_output( const CvMat* _src, CvMat* _dst ) const; virtual void scale_output( const Mat& _src, Mat& _dst ) const;
virtual void calc_input_scale( const CvVectors* vecs, int flags ); virtual void calc_input_scale( const CvVectors* vecs, int flags );
virtual void calc_output_scale( const CvVectors* vecs, int flags ); virtual void calc_output_scale( const CvVectors* vecs, int flags );
virtual void write_params( CvFileStorage* fs ); virtual void write_params( CvFileStorage* fs );
virtual void read_params( CvFileStorage* fs, CvFileNode* node ); virtual void read_params( CvFileStorage* fs, CvFileNode* node );
CvMat* layer_sizes; Mat& layer_sizes;
CvMat* wbuf; Mat& wbuf;
CvMat* sample_weights; Mat& sample_weights;
double** weights; double** weights;
double f_param1, f_param2; double f_param1, f_param2;
double min_val, max_val, min_val1, max_val1; double min_val, max_val, min_val1, max_val1;
@ -225,7 +225,7 @@ Unlike many other models in ML that are constructed and trained at once, in the
CvANN_MLP::create CvANN_MLP::create
----------------- -----------------
.. cpp:function:: void CvANN_MLP::create( const CvMat* _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ) .. cpp:function:: void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 )
Constructs MLP with the specified topology. Constructs MLP with the specified topology.
@ -243,7 +243,7 @@ The method creates an MLP network with the specified topology and assigns the sa
CvANN_MLP::train CvANN_MLP::train
---------------- ----------------
.. cpp: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 ) .. cpp:function:: int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs, const Mat& _sample_weights, const Mat& _sample_idx=Mat(), CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 )
Trains/updates MLP. Trains/updates MLP.

View File

@ -21,13 +21,13 @@ Bayes classifier for normally distributed data ::
CvNormalBayesClassifier(); CvNormalBayesClassifier();
virtual ~CvNormalBayesClassifier(); virtual ~CvNormalBayesClassifier();
CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses, CvNormalBayesClassifier( const Mat& _train_data, const Mat& _responses,
const CvMat* _var_idx=0, const CvMat* _sample_idx=0 ); const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat() );
virtual bool train( const CvMat* _train_data, const CvMat* _responses, virtual bool train( const Mat& _train_data, const Mat& _responses,
const CvMat* _var_idx = 0, const CvMat* _sample_idx=0, bool update=false ); const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), bool update=false );
virtual float predict( const CvMat* _samples, CvMat* results=0 ) const; virtual float predict( const Mat& _samples, Mat* results=0 ) const;
virtual void clear(); virtual void clear();
virtual void save( const char* filename, const char* name=0 ); virtual void save( const char* filename, const char* name=0 );
@ -46,7 +46,7 @@ Bayes classifier for normally distributed data ::
CvNormalBayesClassifier::train CvNormalBayesClassifier::train
------------------------------ ------------------------------
.. cpp:function:: bool CvNormalBayesClassifier::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx =0, const CvMat* _sample_idx=0, bool update=false ) .. cpp:function:: bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx =Mat(), const Mat& _sample_idx=Mat(), bool update=false )
Trains the model. Trains the model.
@ -65,7 +65,7 @@ In addition, there is an ``update`` flag that identifies whether the model shoul
CvNormalBayesClassifier::predict CvNormalBayesClassifier::predict
-------------------------------- --------------------------------
.. cpp:function:: float CvNormalBayesClassifier::predict( const CvMat* samples, CvMat* results=0 ) const .. cpp:function:: float CvNormalBayesClassifier::predict( const Mat& samples, Mat* results=0 ) const
Predicts the response for sample(s). Predicts the response for sample(s).

View File

@ -95,23 +95,23 @@ Random trees ::
public: public:
CvRTrees(); CvRTrees();
virtual ~CvRTrees(); virtual ~CvRTrees();
virtual bool train( const CvMat* _train_data, int _tflag, virtual bool train( const Mat& _train_data, int _tflag,
const CvMat* _responses, const CvMat* _var_idx=0, const Mat& _responses, const Mat& _var_idx=Mat(),
const CvMat* _sample_idx=0, const CvMat* _var_type=0, const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(),
const CvMat* _missing_mask=0, const Mat& _missing_mask=Mat(),
CvRTParams params=CvRTParams() ); CvRTParams params=CvRTParams() );
virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) virtual float predict( const Mat& sample, const Mat& missing = 0 )
const; const;
virtual void clear(); virtual void clear();
virtual const CvMat* get_var_importance(); virtual const Mat& get_var_importance();
virtual float get_proximity( const CvMat* sample_1, const CvMat* sample_2 ) virtual float get_proximity( const Mat& sample_1, const Mat& sample_2 )
const; const;
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node );
virtual void write( CvFileStorage* fs, const char* name ); virtual void write( CvFileStorage* fs, const char* name );
CvMat* get_active_var_mask(); Mat& get_active_var_mask();
CvRNG* get_rng(); CvRNG* get_rng();
int get_tree_count() const; int get_tree_count() const;
@ -136,7 +136,7 @@ Random trees ::
CvRTrees::train CvRTrees::train
--------------- ---------------
.. cpp: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() ) .. cpp:function:: bool CvRTrees::train( const Mat& train_data, int tflag, const Mat& responses, const Mat& comp_idx=Mat(), const Mat& sample_idx=Mat(), const Mat& var_type=Mat(), const Mat& missing_mask=Mat(), CvRTParams params=CvRTParams() )
Trains the Random Tree model. Trains the Random Tree model.
@ -149,7 +149,7 @@ The method ``CvRTrees::train`` is very similar to the first form of ``CvDTree::t
CvRTrees::predict CvRTrees::predict
----------------- -----------------
.. cpp:function:: double CvRTrees::predict( const CvMat* sample, const CvMat* missing=0 ) const .. cpp:function:: double CvRTrees::predict( const Mat& sample, const Mat& missing=Mat() ) const
Predicts the output for an input sample. Predicts the output for an 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
---------------------------- ----------------------------
.. cpp:function:: const CvMat* CvRTrees::get_var_importance() const .. cpp:function:: const Mat& CvRTrees::get_var_importance() const
Retrieves the variable importance array. Retrieves the variable importance array.
@ -173,127 +173,10 @@ The method returns the variable importance vector, computed at the training stag
CvRTrees::get_proximity CvRTrees::get_proximity
----------------------- -----------------------
.. cpp:function:: float CvRTrees::get_proximity( const CvMat* sample_1, const CvMat* sample_2 ) const .. cpp:function:: float CvRTrees::get_proximity( const Mat& sample_1, const Mat& sample_2 ) const
Retrieves the proximity measure between two training samples. Retrieves the proximity measure between two training samples.
The method returns proximity measure between any two samples, which is the ratio of those trees in the ensemble, in which the samples fall into the same leaf node, to the total number of the trees. The method returns proximity measure between any two samples, which is the ratio of those trees in the ensemble, in which the samples fall into the same leaf node, to the total number of the trees.
Example: Prediction of mushroom goodness using the random-tree classifier :: For the random trees usage example, please, see letter_recog.cpp sample in OpenCV distribution.
#include <float.h>
#include <stdio.h>
#include <ctype.h>
#include "ml.h"
int main( void )
{
CvStatModel* cls = NULL;
CvFileStorage* storage = cvOpenFileStorage( "Mushroom.xml",
NULL,CV_STORAGE_READ );
CvMat* data = (CvMat*)cvReadByName(storage, NULL, "sample", 0 );
CvMat train_data, test_data;
CvMat response;
CvMat* missed = NULL;
CvMat* comp_idx = NULL;
CvMat* sample_idx = NULL;
CvMat* type_mask = NULL;
int resp_col = 0;
int i,j;
CvRTreesParams params;
CvTreeClassifierTrainParams cart_params;
const int ntrain_samples = 1000;
const int ntest_samples = 1000;
const int nvars = 23;
if(data == NULL || data->cols != nvars)
{
puts("Error in source data");
return -1;
}
cvGetSubRect( data, &train_data, cvRect(0, 0, nvars, ntrain_samples) );
cvGetSubRect( data, &test_data, cvRect(0, ntrain_samples, nvars,
ntrain_samples + ntest_samples) );
resp_col = 0;
cvGetCol( &train_data, &response, resp_col);
/* create missed variable matrix */
missed = cvCreateMat(train_data.rows, train_data.cols, CV_8UC1);
for( i = 0; i < train_data.rows; i++ )
for( j = 0; j < train_data.cols; j++ )
CV_MAT_ELEM(*missed,uchar,i,j)
= (uchar)(CV_MAT_ELEM(train_data,float,i,j) < 0);
/* create comp_idx vector */
comp_idx = cvCreateMat(1, train_data.cols-1, CV_32SC1);
for( i = 0; i < train_data.cols; i++ )
{
if(i<resp_col)CV_MAT_ELEM(*comp_idx,int,0,i) = i;
if(i>resp_col)CV_MAT_ELEM(*comp_idx,int,0,i-1) = i;
}
/* create sample_idx vector */
sample_idx = cvCreateMat(1, train_data.rows, CV_32SC1);
for( j = i = 0; i < train_data.rows; i++ )
{
if(CV_MAT_ELEM(response,float,i,0) < 0) continue;
CV_MAT_ELEM(*sample_idx,int,0,j) = i;
j++;
}
sample_idx->cols = j;
/* create type mask */
type_mask = cvCreateMat(1, train_data.cols+1, CV_8UC1);
cvSet( type_mask, cvRealScalar(CV_VAR_CATEGORICAL), 0);
// initialize training parameters
cvSetDefaultParamTreeClassifier((CvStatModelParams*)&cart_params);
cart_params.wrong_feature_as_unknown = 1;
params.tree_params = &cart_params;
params.term_crit.max_iter = 50;
params.term_crit.epsilon = 0.1;
params.term_crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS;
puts("Random forest results");
cls = cvCreateRTreesClassifier( &train_data,
CV_ROW_SAMPLE,
&response,
(CvStatModelParams*)&
params,
comp_idx,
sample_idx,
type_mask,
missed );
if( cls )
{
CvMat sample = cvMat( 1, nvars, CV_32FC1, test_data.data.fl );
CvMat test_resp;
int wrong = 0, total = 0;
cvGetCol( &test_data, &test_resp, resp_col);
for( i = 0; i < ntest_samples; i++, sample.data.fl += nvars )
{
if( CV_MAT_ELEM(test_resp,float,i,0) >= 0 )
{
float resp = cls->predict( cls, &sample, NULL );
wrong += (fabs(resp-response.data.fl[i]) > 1e-3 ) ? 1 : 0;
total++;
}
}
printf( "Test set error =
}
else
puts("Error forest creation");
cvReleaseMat(&missed);
cvReleaseMat(&sample_idx);
cvReleaseMat(&comp_idx);
cvReleaseMat(&type_mask);
cvReleaseMat(&data);
cvReleaseStatModel(&cls);
cvReleaseFileStorage(&storage);
return 0;
}

View File

@ -15,20 +15,20 @@ Base class for statistical models in ML ::
{ {
public: public:
/* CvStatModel(); */ /* CvStatModel(); */
/* CvStatModel( const CvMat* train_data ... ); */ /* CvStatModel( const Mat& train_data ... ); */
virtual ~CvStatModel(); virtual ~CvStatModel();
virtual void clear()=0; virtual void clear()=0;
/* virtual bool train( const CvMat* train_data, [int tflag,] ..., const /* virtual bool train( const Mat& train_data, [int tflag,] ..., const
CvMat* responses, ..., Mat& responses, ...,
[const CvMat* var_idx,] ..., [const CvMat* sample_idx,] ... [const Mat& var_idx,] ..., [const Mat& sample_idx,] ...
[const CvMat* var_type,] ..., [const CvMat* missing_mask,] [const Mat& var_type,] ..., [const Mat& missing_mask,]
<misc_training_alg_params> ... )=0; <misc_training_alg_params> ... )=0;
*/ */
/* virtual float predict( const CvMat* sample ... ) const=0; */ /* virtual float predict( const Mat& sample ... ) const=0; */
virtual void save( const char* filename, const char* name=0 )=0; virtual void save( const char* filename, const char* name=0 )=0;
virtual void load( const char* filename, const char* name=0 )=0; virtual void load( const char* filename, const char* name=0 )=0;
@ -58,7 +58,7 @@ Each statistical model class in ML has a default constructor without parameters.
CvStatModel::CvStatModel(...) CvStatModel::CvStatModel(...)
----------------------------- -----------------------------
.. cpp:function:: CvStatModel::CvStatModel( const CvMat* train_data ... ) .. cpp:function:: CvStatModel::CvStatModel( const Mat& train_data ... )
Serves as a training constructor. Serves as a training constructor.
@ -161,7 +161,7 @@ The previous model state is cleared by ``clear()`` .
CvStatModel::train CvStatModel::train
------------------ ------------------
.. cpp: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> ... ) .. cpp:function:: bool CvStatMode::train( const Mat& train_data, [int tflag,] ..., const Mat& responses, ..., [const Mat& var_idx,] ..., [const Mat& sample_idx,] ... [const Mat& var_type,] ..., [const Mat& missing_mask,] <misc_training_alg_params> ... )
Trains the model. Trains the model.
@ -193,7 +193,7 @@ Usually, the previous model state is cleared by ``clear()`` before running the t
CvStatModel::predict CvStatModel::predict
-------------------- --------------------
.. cpp:function:: float CvStatMode::predict( const CvMat* sample[, <prediction_params>] ) const .. cpp:function:: float CvStatMode::predict( const Mat& sample[, <prediction_params>] ) const
Predicts the response for a sample. Predicts the response for a sample.

View File

@ -46,16 +46,16 @@ Support Vector Machines ::
CvSVM(); CvSVM();
virtual ~CvSVM(); virtual ~CvSVM();
CvSVM( const CvMat* _train_data, const CvMat* _responses, CvSVM( const Mat& _train_data, const Mat& _responses,
const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(),
CvSVMParams _params=CvSVMParams() ); CvSVMParams _params=CvSVMParams() );
virtual bool train( const CvMat* _train_data, const CvMat* _responses, virtual bool train( const Mat& _train_data, const Mat& _responses,
const CvMat* _var_idx=0, const CvMat* _sample_idx=0, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(),
CvSVMParams _params=CvSVMParams() ); CvSVMParams _params=CvSVMParams() );
virtual bool train_auto( const CvMat* _train_data, const CvMat* _responses, virtual bool train_auto( const Mat& _train_data, const Mat& _responses,
const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params, const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams _params,
int k_fold = 10, int k_fold = 10,
CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid C_grid = get_default_grid(CvSVM::C),
CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA),
@ -64,7 +64,7 @@ Support Vector Machines ::
CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF),
CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) ); CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) );
virtual float predict( const CvMat* _sample ) const; virtual float predict( const Mat& _sample ) const;
virtual int get_support_vector_count() const; virtual int get_support_vector_count() const;
virtual const float* get_support_vector(int i) const; virtual const float* get_support_vector(int i) const;
virtual CvSVMParams get_params() const { return params; }; virtual CvSVMParams get_params() const { return params; };
@ -100,7 +100,7 @@ SVM training parameters ::
CvSVMParams( int _svm_type, int _kernel_type, CvSVMParams( int _svm_type, int _kernel_type,
double _degree, double _gamma, double _coef0, double _degree, double _gamma, double _coef0,
double _C, double _nu, double _p, double _C, double _nu, double _p,
CvMat* _class_weights, CvTermCriteria _term_crit ); const CvMat* _class_weights, CvTermCriteria _term_crit );
int svm_type; int svm_type;
int kernel_type; int kernel_type;
@ -125,7 +125,7 @@ The structure must be initialized and passed to the training method of
CvSVM::train CvSVM::train
------------ ------------
.. cpp:function:: bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses, const CvMat* _var_idx=0, const CvMat* _sample_idx=0, CvSVMParams _params=CvSVMParams() ) .. cpp:function:: bool CvSVM::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), CvSVMParams _params=CvSVMParams() )
Trains SVM. Trains SVM.
@ -145,7 +145,7 @@ All the other parameters are gathered in the
CvSVM::train_auto CvSVM::train_auto
----------------- -----------------
.. cpp: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) ) .. cpp:function:: train_auto( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx, const Mat& _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.

View File

@ -849,187 +849,13 @@ void CvEM::init_auto( const CvVectors& train_data )
void CvEM::kmeans( const CvVectors& train_data, int nclusters, CvMat* labels, void CvEM::kmeans( const CvVectors& train_data, int nclusters, CvMat* labels,
CvTermCriteria termcrit, const CvMat* centers0 ) CvTermCriteria termcrit, const CvMat* centers0 )
{ {
CvMat* centers = 0; int i, nsamples = train_data.count, dims = train_data.dims;
CvMat* old_centers = 0; cv::Ptr<CvMat> temp_mat = cvCreateMat(nsamples, dims, CV_32F);
CvMat* counters = 0;
CV_FUNCNAME( "CvEM::kmeans" );
__BEGIN__;
cv::RNG rng(0xFFFFFFFF);
int i, j, k, nsamples, dims;
int iter = 0;
double max_dist = DBL_MAX;
termcrit = cvCheckTermCriteria( termcrit, 1e-6, 100 );
termcrit.epsilon *= termcrit.epsilon;
nsamples = train_data.count;
dims = train_data.dims;
nclusters = MIN( nclusters, nsamples );
CV_CALL( centers = cvCreateMat( nclusters, dims, CV_64FC1 ));
CV_CALL( old_centers = cvCreateMat( nclusters, dims, CV_64FC1 ));
CV_CALL( counters = cvCreateMat( 1, nclusters, CV_32SC1 ));
cvZero( old_centers );
if( centers0 )
{
CV_CALL( cvConvert( centers0, centers ));
}
else
{
for( i = 0; i < nsamples; i++ )
labels->data.i[i] = i*nclusters/nsamples;
cvRandShuffle( labels, &rng.state );
}
for( ;; )
{
CvMat* temp;
if( iter > 0 || centers0 )
{
for( i = 0; i < nsamples; i++ )
{
const float* s = train_data.data.fl[i];
int k_best = 0;
double min_dist = DBL_MAX;
for( k = 0; k < nclusters; k++ )
{
const double* c = (double*)(centers->data.ptr + k*centers->step);
double dist = 0;
for( j = 0; j <= dims - 4; j += 4 )
{
double t0 = c[j] - s[j];
double t1 = c[j+1] - s[j+1];
dist += t0*t0 + t1*t1;
t0 = c[j+2] - s[j+2];
t1 = c[j+3] - s[j+3];
dist += t0*t0 + t1*t1;
}
for( ; j < dims; j++ )
{
double t = c[j] - s[j];
dist += t*t;
}
if( min_dist > dist )
{
min_dist = dist;
k_best = k;
}
}
labels->data.i[i] = k_best;
}
}
if( ++iter > termcrit.max_iter )
break;
CV_SWAP( centers, old_centers, temp );
cvZero( centers );
cvZero( counters );
// update centers
for( i = 0; i < nsamples; i++ )
{
const float* s = train_data.data.fl[i];
k = labels->data.i[i];
double* c = (double*)(centers->data.ptr + k*centers->step);
for( j = 0; j <= dims - 4; j += 4 )
{
double t0 = c[j] + s[j];
double t1 = c[j+1] + s[j+1];
c[j] = t0;
c[j+1] = t1;
t0 = c[j+2] + s[j+2];
t1 = c[j+3] + s[j+3];
c[j+2] = t0;
c[j+3] = t1;
}
for( ; j < dims; j++ )
c[j] += s[j];
counters->data.i[k]++;
}
if( iter > 1 )
max_dist = 0;
for( k = 0; k < nclusters; k++ )
{
double* c = (double*)(centers->data.ptr + k*centers->step);
if( counters->data.i[k] != 0 )
{
double scale = 1./counters->data.i[k];
for( j = 0; j < dims; j++ )
c[j] *= scale;
}
else
{
const float* s;
for( j = 0; j < 10; j++ )
{
i = rng(nsamples);
if( counters->data.i[labels->data.i[i]] > 1 )
break;
}
s = train_data.data.fl[i];
for( j = 0; j < dims; j++ )
c[j] = s[j];
}
if( iter > 1 )
{
double dist = 0;
const double* c_o = (double*)(old_centers->data.ptr + k*old_centers->step);
for( j = 0; j < dims; j++ )
{
double t = c[j] - c_o[j];
dist += t*t;
}
if( max_dist < dist )
max_dist = dist;
}
}
if( max_dist < termcrit.epsilon )
break;
}
cvZero( counters );
for( i = 0; i < nsamples; i++ ) for( i = 0; i < nsamples; i++ )
counters->data.i[labels->data.i[i]]++; memcpy( temp_mat->data.ptr + temp_mat->step*i, train_data.data.fl[i], dims*sizeof(float));
// ensure that we do not have empty clusters cvKMeans2(temp_mat, nclusters, labels, termcrit, 10);
for( k = 0; k < nclusters; k++ )
if( counters->data.i[k] == 0 )
for(;;)
{
i = rng(nsamples);
j = labels->data.i[i];
if( counters->data.i[j] > 1 )
{
labels->data.i[i] = k;
counters->data.i[j]--;
counters->data.i[k]++;
break;
}
}
__END__;
cvReleaseMat( &centers );
cvReleaseMat( &old_centers );
cvReleaseMat( &counters );
} }

View File

@ -34,7 +34,7 @@ Base class for computing feature values in cascade classifiers ::
FeatureEvaluator::read FeatureEvaluator::read
-------------------------- --------------------------
.. cpp:function:: bool FeatureEvaluator::read(const FileNode\& node) .. cpp:function:: bool FeatureEvaluator::read(const FileNode& node)
Reads parameters of features from the ``FileStorage`` node. Reads parameters of features from the ``FileStorage`` node.
@ -60,7 +60,7 @@ FeatureEvaluator::getFeatureType
FeatureEvaluator::setImage FeatureEvaluator::setImage
------------------------------ ------------------------------
.. cpp:function:: bool FeatureEvaluator::setImage(const Mat\& img, Size origWinSize) .. cpp:function:: bool FeatureEvaluator::setImage(const Mat& img, Size origWinSize)
Sets an image where the features are computed??. Sets an image where the features are computed??.
@ -193,7 +193,7 @@ The cascade classifier class for object detection ::
CascadeClassifier::CascadeClassifier CascadeClassifier::CascadeClassifier
---------------------------------------- ----------------------------------------
.. cpp:function:: CascadeClassifier::CascadeClassifier(const string\& filename) .. cpp:function:: CascadeClassifier::CascadeClassifier(const string& filename)
Loads a classifier from a file. Loads a classifier from a file.
@ -211,7 +211,7 @@ CascadeClassifier::empty
CascadeClassifier::load CascadeClassifier::load
--------------------------- ---------------------------
.. cpp:function:: bool CascadeClassifier::load(const string\& filename) .. cpp:function:: bool CascadeClassifier::load(const string& filename)
Loads a classifier from a file. The previous content is destroyed. Loads a classifier from a file. The previous content is destroyed.
@ -221,7 +221,7 @@ CascadeClassifier::load
CascadeClassifier::read CascadeClassifier::read
--------------------------- ---------------------------
.. cpp:function:: bool CascadeClassifier::read(const FileNode\& node) .. cpp:function:: bool CascadeClassifier::read(const FileNode& node)
Reads a classifier from a FileStorage node. The file may contain a new cascade classifier (trained traincascade application) only. Reads a classifier from a FileStorage node. The file may contain a new cascade classifier (trained traincascade application) only.
@ -229,7 +229,7 @@ CascadeClassifier::read
CascadeClassifier::detectMultiScale CascadeClassifier::detectMultiScale
--------------------------------------- ---------------------------------------
.. cpp:function:: void CascadeClassifier::detectMultiScale( const Mat\& image, vector<Rect>\& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size()) .. cpp: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.
@ -249,7 +249,7 @@ CascadeClassifier::detectMultiScale
CascadeClassifier::setImage CascadeClassifier::setImage
------------------------------- -------------------------------
.. cpp:function:: bool CascadeClassifier::setImage( Ptr<FeatureEvaluator>\& feval, const Mat\& image ) .. cpp:function:: bool CascadeClassifier::setImage( Ptr<FeatureEvaluator>& feval, const Mat& image )
Sets an image for detection, which is called by ``detectMultiScale`` at each image level. Sets an image for detection, which is called by ``detectMultiScale`` at each image level.
@ -261,7 +261,7 @@ CascadeClassifier::setImage
CascadeClassifier::runAt CascadeClassifier::runAt
---------------------------- ----------------------------
.. cpp:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>\& feval, Point pt ) .. cpp:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& feval, Point pt )
Runs the detector at the specified point. Use ``setImage`` to set the image that the detector is working with. Runs the detector at the specified point. Use ``setImage`` to set the image that the detector is working with.
@ -276,7 +276,7 @@ Otherwise, it returns ``si``, which is an index of the stage that first predicte
groupRectangles groupRectangles
------------------- -------------------
.. cpp:function:: void groupRectangles(vector<Rect>\& rectList, int groupThreshold, double eps=0.2) .. cpp:function:: void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2)
Groups the object candidate rectangles. Groups the object candidate rectangles.

View File

@ -270,30 +270,41 @@ class CppHeaderParser(object):
if fname.endswith("operator"): if fname.endswith("operator"):
fname += "()" fname += "()"
apos = fdecl.find("(", apos+1) apos = fdecl.find("(", apos+1)
args0 = fdecl[apos+1:fdecl.rfind(")")].strip().split(",")
args = []
narg = ""
for arg in args0:
narg += arg.strip()
balance_paren = narg.count("(") - narg.count(")")
balance_angle = narg.count("<") - narg.count(">")
if balance_paren == 0 and balance_angle == 0:
args.append(narg.strip())
narg = ""
fname = "cv." + fname.replace("::", ".") fname = "cv." + fname.replace("::", ".")
decl = [fname, rettype, [], []] decl = [fname, rettype, [], []]
args0str = fdecl[apos+1:fdecl.rfind(")")].strip()
for arg in args: if args0str != "":
dfpos = arg.find("=") args0 = args0str.split(",")
defval = ""
if dfpos >= 0: args = []
defval = arg[dfpos+1:].strip() narg = ""
arg = arg[:dfpos].strip() for arg in args0:
pos = arg.rfind(" ") narg += arg.strip()
aname = arg[pos+1:] balance_paren = narg.count("(") - narg.count(")")
atype = arg[:pos] balance_angle = narg.count("<") - narg.count(">")
decl[3].append([atype, aname, defval, []]) if balance_paren == 0 and balance_angle == 0:
args.append(narg.strip())
narg = ""
for arg in args:
dfpos = arg.find("=")
defval = ""
if dfpos >= 0:
defval = arg[dfpos+1:].strip()
arg = arg[:dfpos].strip()
pos = arg.rfind(" ")
if pos >= 0:
aname = arg[pos+1:].strip()
atype = arg[:pos].strip()
if aname.endswith("&") or aname.endswith("*") or (aname in ["int", "string", "Mat"]):
atype = (atype + " " + aname).strip()
aname = "param"
else:
atype = arg
aname = "param"
decl[3].append([atype, aname, defval, []])
return decl return decl

94
samples/cpp/em.cpp Normal file
View File

@ -0,0 +1,94 @@
#include "opencv2/ml/ml.hpp"
#include "opencv2/highgui/highgui.hpp"
using namespace cv;
int main( int argc, char** argv )
{
const int N = 4;
const int N1 = (int)sqrt((double)N);
const Scalar colors[] =
{
Scalar(0,0,255), Scalar(0,255,0),
Scalar(0,255,255),Scalar(255,255,0)
};
int i, j;
int nsamples = 100;
Mat samples( nsamples, 2, CV_32FC1 );
Mat labels;
Mat img = Mat::zeros( Size( 500, 500 ), CV_8UC3 );
Mat sample( 1, 2, CV_32FC1 );
CvEM em_model;
CvEMParams params;
samples = samples.reshape(2, 0);
for( i = 0; i < N; i++ )
{
// form the training samples
Mat samples_part = samples.rowRange(i*nsamples/N, (i+1)*nsamples/N );
Scalar mean(((i%N1)+1)*img.rows/(N1+1),
((i/N1)+1)*img.rows/(N1+1));
Scalar sigma(30,30);
randn( samples_part, mean, sigma );
}
samples = samples.reshape(1, 0);
// initialize model parameters
params.covs = NULL;
params.means = NULL;
params.weights = NULL;
params.probs = NULL;
params.nclusters = N;
params.cov_mat_type = CvEM::COV_MAT_SPHERICAL;
params.start_step = CvEM::START_AUTO_STEP;
params.term_crit.max_iter = 300;
params.term_crit.epsilon = 0.1;
params.term_crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS;
// cluster the data
em_model.train( samples, Mat(), params, &labels );
#if 0
// the piece of code shows how to repeatedly optimize the model
// with less-constrained parameters
//(COV_MAT_DIAGONAL instead of COV_MAT_SPHERICAL)
// when the output of the first stage is used as input for the second one.
CvEM em_model2;
params.cov_mat_type = CvEM::COV_MAT_DIAGONAL;
params.start_step = CvEM::START_E_STEP;
params.means = em_model.get_means();
params.covs = (const CvMat**)em_model.get_covs();
params.weights = em_model.get_weights();
em_model2.train( samples, Mat(), params, &labels );
// to use em_model2, replace em_model.predict()
// with em_model2.predict() below
#endif
// classify every image pixel
for( i = 0; i < img.rows; i++ )
{
for( j = 0; j < img.cols; j++ )
{
sample.at<float>(0) = (float)j;
sample.at<float>(1) = (float)i;
int response = cvRound(em_model.predict( sample ));
Scalar c = colors[response];
circle( img, Point(j, i), 1, c*0.75, CV_FILLED );
}
}
//draw the clustered samples
for( i = 0; i < nsamples; i++ )
{
Point pt(cvRound(samples.at<float>(i, 0)), cvRound(samples.at<float>(i, 1)));
circle( img, pt, 1, colors[labels.at<int>(i)], CV_FILLED );
}
imshow( "EM-clustering result", img );
waitKey(0);
return 0;
}