opencv_module_list = [
"core",
-#"imgproc",
-#"calib3d",
-#"features2d",
-#"video",
-#"objdetect",
-#"highgui",
-#"ml"
+"imgproc",
+"calib3d",
+"features2d",
+"video",
+"objdetect",
+"highgui",
+"ml"
]
class RSTParser(object):
continue
rst_decl = None
if "(" in l:
+ l = l.replace("cv::", "")
rst_decl = self.parser.parse_func_decl_no_wrap(l)
fname = rst_decl[0]
else:
fname = rst_decl[0]
hdr_decls = self.fmap.get(fname, [])
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)
continue
decl_idx = 0
continue
idx = 0
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
idx += 1
if idx == len(hd[3]):
for d in decls:
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:
misscount += 1
print "%s %s(%s)" % (d[1], d[0].replace(".", "::"), ", ".join([a[0] + " " + a[1] for a in d[3]]))
# full declaration into the file
#
+######################################### core #####################################
cv::Mat::MSize
cv::Mat::MStep
cv::MatConstIterator
cv::_InputArray
cv::_OutputArray
+######################################## 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
#latex_appendices = []
# If false, no module index is generated.
-#latex_domain_indices = True
+latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
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, OutputArray rotMatrixY, OutputArray rotMatrixZ, Vec3d& eulerAngles )
+.. cpp:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray() )
Decomposes a projection matrix into a rotation matrix and a camera matrix.
: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.
.. index:: findHomography
-.. _findHomography:
-
findHomography
------------------
.. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() )
:ref:`PerspectiveTransform`
-.. index:: getOptimalNewCameraMatrix
+.. 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.
-.. _getOptimalNewCameraMatrix:
+ :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
-----------------------------
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.
: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 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.
+ :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.
The function computes projections of 3D
points to the image plane given intrinsic and extrinsic camera
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.
: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:
.. math::
.. index:: 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.
: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
:ref:`DecomposeProjectionMatrix` to decompose the left 3x3 submatrix of a projection matrix into a camera and a rotation matrix.
-----------------
.. 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.
:param stream: Stream for the asynchronous version.
-See Also: :c:cpp:func:`reprojectImageTo3D` .
+See Also: :cpp:func:`reprojectImageTo3D` .
.. index:: gpu::solvePnPRansac
: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 inliers: Output vector of inlier indices.
-See Also :c:cpp:func:`solvePnPRansac`.
+See Also :cpp:func:`solvePnPRansac`.
\ No newline at end of file
Finds the best match for each descriptor from a query set with train descriptors.
See Also:
-:c:cpp:func:`DescriptorMatcher::match`
+:cpp:func:`DescriptorMatcher::match`
.. index:: gpu::BruteForceMatcher_GPU::matchSingle
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
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
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
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
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
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
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
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
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
: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:**
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
: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.
* 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.
: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.
* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
-See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :c:cpp:func:`createSeparableLinearFilter`
+See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`createSeparableLinearFilter`
.. index:: gpu::createSeparableLinearFilter_GPU
: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
: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
: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
: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
: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
: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 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
: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
:param criteria: Termination criteria. See :cpp:class:`TermCriteria`.
See Also:
-:c:cpp:func:`gpu::meanShiftFiltering`
+:cpp:func:`gpu::meanShiftFiltering`
.. index:: gpu::meanShiftSegmentation
:param sqsum: Squared integral image of the ``CV_32FC1`` type.
See Also:
-:c:cpp:func:`integral`
+:cpp:func:`integral`
.. index:: gpu::sqrIntegral
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
See Also:
-:c:cpp:func:`cornerHarris`
+:cpp:func:`cornerHarris`
.. index:: gpu::cornerMinEigenVal
: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
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also:
-:c:cpp:func:`mulSpectrums`
+:cpp:func:`mulSpectrums`
.. index:: gpu::mulAndScaleSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
See Also:
-:c:cpp:func:`mulSpectrums`
+:cpp:func:`mulSpectrums`
.. index:: 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.
See Also:
-:c:cpp:func:`dft`
+:cpp:func:`dft`
.. index:: gpu::convolve
.. cpp:class:: gpu::ConvolveBuf
This class provides a memory buffer for the
- :c:cpp:func:`gpu::convolve` function.
+ :cpp:func:`gpu::convolve` function.
::
struct CV_EXPORTS ConvolveBuf
.. cpp:function:: ConvolveBuf::ConvolveBuf()
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)
Constructs a buffer for the
- :c:cpp:func:`convolve` function with respective arguments.
+ :cpp:func:`convolve` function with respective arguments.
.. index:: gpu::matchTemplate
* ``CV_TM_CCORR``
See Also:
-:c:cpp:func:`matchTemplate`
+:cpp:func:`matchTemplate`
.. index:: gpu::remap
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
:param stddev: Standard deviation value.
-See Also: :c:cpp:func:`meanStdDev`
+See Also: :cpp:func:`meanStdDev`
.. index:: gpu::norm
: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
: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
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
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
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`
imshow("Faces", image_cpu);
-See Also: :c:cpp:func:`CascadeClassifier::detectMultiScale`
+See Also: :cpp:func:`CascadeClassifier::detectMultiScale`
:param dst: Destination matrix.
See Also:
-:c:cpp:func:`transpose`
+:cpp:func:`transpose`
.. index:: gpu::flip
See Also:
-:c:cpp:func:`flip`
+:cpp:func:`flip`
.. index:: gpu::LUT
: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
:param stream: Stream for the asynchronous version.
-See Also: :c:cpp:func:`merge`
+See Also: :cpp:func:`merge`
.. index:: gpu::split
:param stream: Stream for the asynchronous version.
-See Also: :c:cpp:func:`split`
+See Also: :cpp:func:`split`
.. index:: gpu::magnitude
:param stream: Stream for the asynchronous version.
See Also:
-:c:cpp:func:`magnitude`
+:cpp:func:`magnitude`
.. index:: gpu::magnitudeSqr
:param stream: Stream for the asynchronous version.
See Also:
-:c:cpp:func:`phase`
+:cpp:func:`phase`
.. index:: gpu::cartToPolar
:param stream: Stream for the asynchronous version.
See Also:
-:c:cpp:func:`cartToPolar`
+:cpp:func:`cartToPolar`
.. index:: gpu::polarToCart
:param stream: Stream for the asynchronous version.
See Also:
-:c:cpp:func:`polarToCart`
+:cpp:func:`polarToCart`
: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
:param dst: Destination matrix with the same size and type as ``src1``.
-See Also: :c:cpp:func:`subtract`
+See Also: :cpp:func:`subtract`
: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
: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`
:param dst: Destination matrix with the same size and type as ``src``.
-See Also: :c:cpp:func:`exp`
+See Also: :cpp:func:`exp`
:param dst: Destination matrix with the same size and type as ``src``.
-See Also: :c:cpp:func:`log`
+See Also: :cpp:func:`log`
: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
* **CMP_LE:** ``src1(.) <= src2(.)``
* **CMP_NE:** ``src1(.) != src2(.)``
-See Also: :c:cpp:func:`compare`
+See Also: :cpp:func:`compare`
.. index:: gpu::bitwise_not
:param stream: Stream for the asynchronous version.
-See Also: :c:cpp:func:`min`
+See Also: :cpp:func:`min`
:param stream: Stream for the asynchronous version.
-See Also: :c:cpp:func:`max`
+See Also: :cpp:func:`max`
.. 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.
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.
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
contourArea
---------------
-.. cpp:function:: double contourArea( InputArray contour )
+.. cpp:function:: double contourArea( InputArray contour, bool oriented=false )
Calculates a contour area.
: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
: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
//! computes back projection for the set of images
CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
const int* channels, const SparseMat& hist,
- Mat& backProject, const float** ranges,
+ OutputArray backProject, const float** ranges,
double scale=1, bool uniform=true );
//! compares two histograms stored in dense arrays
}
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 )
{
vector<uchar*> ptrs;
int dims = hist.dims();
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,
dims, hist.hdr->size, ranges,
uniform, ptrs, deltas, imsize, uniranges );
virtual ~CvBoostTree();
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 read( CvFileStorage* fs, CvFileNode* node,
CvBoost* ensemble, CvDTreeTrainData* _data );
CvBoost();
virtual ~CvBoost();
- CvBoost( 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,
+ CvBoost( const Mat& _train_data, int _tflag,
+ const Mat& _responses, const Mat& _var_idx=0,
+ const Mat& _sample_idx=0, const Mat& _var_type=0,
+ const Mat& _missing_mask=0,
CvBoostParams params=CvBoostParams() );
- virtual bool 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,
+ virtual bool train( const Mat& _train_data, int _tflag,
+ const Mat& _responses, const Mat& _var_idx=0,
+ const Mat& _sample_idx=0, const Mat& _var_type=0,
+ const Mat& _missing_mask=0,
CvBoostParams params=CvBoostParams(),
bool update=false );
- virtual float predict( const CvMat* _sample, const CvMat* _missing=0,
- CvMat* weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
+ virtual float predict( const Mat& _sample, const Mat& _missing=0,
+ Mat& weak_responses=0, CvSlice slice=CV_WHOLE_SEQ,
bool raw_mode=false ) const;
virtual void prune( CvSlice slice );
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.
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.
struct CvDTreeTrainData
{
CvDTreeTrainData();
- CvDTreeTrainData( 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,
+ CvDTreeTrainData( 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(),
const CvDTreeParams& _params=CvDTreeParams(),
bool _shared=false, bool _add_labels=false );
virtual ~CvDTreeTrainData();
- virtual void set_data( 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,
+ virtual void set_data( 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(),
const CvDTreeParams& _params=CvDTreeParams(),
bool _shared=false, bool _add_labels=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,
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 read_params( CvFileStorage* fs, CvFileNode* node );
int buf_count, buf_size;
bool shared;
- CvMat* cat_count;
- CvMat* cat_ofs;
- CvMat* cat_map;
+ Mat& cat_count;
+ Mat& cat_ofs;
+ Mat& cat_map;
- CvMat* counts;
- CvMat* buf;
- CvMat* direction;
- CvMat* split_buf;
+ Mat& counts;
+ Mat& buf;
+ Mat& direction;
+ Mat& split_buf;
- CvMat* var_idx;
- CvMat* var_type; // i-th element =
+ Mat& var_idx;
+ Mat& var_type; // i-th element =
// k<0 - ordered
// k>=0 - categorical, see k-th element of cat_* arrays
- CvMat* priors;
+ Mat& priors;
CvDTreeParams params;
CvDTree();
virtual ~CvDTree();
- virtual bool 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,
+ virtual bool 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() );
virtual bool train( CvDTreeTrainData* _train_data,
- const CvMat* _subsample_idx );
+ const Mat& _subsample_idx );
- virtual CvDTreeNode* predict( const CvMat* _sample,
- const CvMat* _missing_data_mask=0,
+ virtual CvDTreeNode* predict( const Mat& _sample,
+ const Mat& _missing_data_mask=Mat(),
bool raw_mode=false ) const;
- virtual const CvMat* get_var_importance();
+ virtual const Mat& get_var_importance();
virtual void clear();
virtual void read( CvFileStorage* fs, CvFileNode* node );
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 split_node_data( CvDTreeNode* n );
CvDTreeNode* root;
int pruned_tree_idx;
- CvMat* var_importance;
+ Mat& var_importance;
CvDTreeTrainData* data;
};
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.
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.
CvTermCriteria _term_crit=cvTermCriteria(
CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,
100, FLT_EPSILON),
- CvMat* _probs=0, CvMat* _weights=0,
- CvMat* _means=0, CvMat** _covs=0 ) :
+ const CvMat* _probs=0, const CvMat* _weights=0,
+ const CvMat* _means=0, const CvMat** _covs=0 ) :
nclusters(_nclusters), cov_mat_type(_cov_mat_type),
start_step(_start_step),
probs(_probs), weights(_weights), means(_means), covs(_covs),
enum { START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0 };
CvEM();
- CvEM( const CvMat* samples, const CvMat* sample_idx=0,
- CvEMParams params=CvEMParams(), CvMat* labels=0 );
+ CvEM( const Mat& samples, const Mat& sample_idx=Mat(),
+ CvEMParams params=CvEMParams(), Mat* labels=0 );
virtual ~CvEM();
- virtual bool train( const CvMat* samples, const CvMat* sample_idx=0,
- CvEMParams params=CvEMParams(), CvMat* labels=0 );
+ virtual bool train( const Mat& samples, const Mat& sample_idx=Mat(),
+ 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();
int get_nclusters() const { return params.nclusters; }
- const CvMat* get_means() const { return means; }
- const CvMat** get_covs() const { return covs; }
- const CvMat* get_weights() const { return weights; }
- const CvMat* get_probs() const { return probs; }
+ const Mat& get_means() const { return means; }
+ const Mat&* get_covs() const { return covs; }
+ const Mat& get_weights() const { return weights; }
+ const Mat& get_probs() const { return probs; }
protected:
virtual double run_em( const CvVectors& train_data );
virtual void init_auto( const CvVectors& samples );
virtual void kmeans( const CvVectors& train_data, int nclusters,
- CvMat* labels, CvTermCriteria criteria,
- const CvMat* means );
+ Mat& labels, CvTermCriteria criteria,
+ const Mat& means );
CvEMParams params;
double log_likelihood;
- CvMat* means;
- CvMat** covs;
- CvMat* weights;
- CvMat* probs;
+ Mat& means;
+ Mat&* covs;
+ Mat& weights;
+ Mat& probs;
- CvMat* log_weight_div_det;
- CvMat* inv_eigen_values;
- CvMat** cov_rotate_mats;
+ Mat& log_weight_div_det;
+ Mat& inv_eigen_values;
+ Mat&* cov_rotate_mats;
};
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.
The trained model can be used further for prediction, just like any other classifier. The trained model is similar to the
: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;
- }
CvKNearest();
virtual ~CvKNearest();
- CvKNearest( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _sample_idx=0, bool _is_regression=false, int max_k=32 );
+ CvKNearest( const Mat& _train_data, const Mat& _responses,
+ const Mat& _sample_idx=Mat(), bool _is_regression=false, int max_k=32 );
- virtual bool train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _sample_idx=0, bool is_regression=false,
+ virtual bool 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 );
- virtual float find_nearest( const CvMat* _samples, int k, CvMat* results,
- const float** neighbors=0, CvMat* neighbor_responses=0, CvMat* dist=0 ) const;
+ virtual float find_nearest( const Mat& _samples, int k, Mat* results=0,
+ const float** neighbors=0, Mat* neighbor_responses=0, Mat* dist=0 ) const;
virtual void clear();
int get_max_k() const;
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.
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.
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 "highgui.h"
{
public:
CvANN_MLP();
- CvANN_MLP( const CvMat* _layer_sizes,
+ CvANN_MLP( const Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
virtual ~CvANN_MLP();
- virtual void create( const CvMat* _layer_sizes,
+ virtual void create( const Mat& _layer_sizes,
int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
- virtual int train( const CvMat* _inputs, const CvMat* _outputs,
- const CvMat* _sample_weights,
- const CvMat* _sample_idx=0,
+ virtual int 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 );
- virtual float predict( const CvMat* _inputs,
- CvMat* _outputs ) const;
+ virtual float predict( const Mat& _inputs,
+ Mat& _outputs ) const;
virtual void clear();
virtual void write( CvFileStorage* storage, const char* name );
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:
- virtual bool prepare_to_train( const CvMat* _inputs, const CvMat* _outputs,
- const CvMat* _sample_weights, const CvMat* _sample_idx,
+ virtual bool prepare_to_train( const Mat& _inputs, const Mat& _outputs,
+ const Mat& _sample_weights, const Mat& _sample_idx,
CvANN_MLP_TrainParams _params,
CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags );
virtual int train_rprop( CvVectors _ivecs, CvVectors _ovecs,
const double* _sw );
- virtual void calc_activ_func( CvMat* xf, const double* bias ) const;
- virtual void calc_activ_func_deriv( CvMat* xf, CvMat* deriv,
+ virtual void calc_activ_func( Mat& xf, const double* bias ) const;
+ virtual void calc_activ_func_deriv( Mat& xf, Mat& deriv,
const double* bias ) const;
virtual void set_activ_func( int _activ_func=SIGMOID_SYM,
double _f_param1=0, double _f_param2=0 );
virtual void init_weights();
- virtual void scale_input( const CvMat* _src, CvMat* _dst ) const;
- virtual void scale_output( const CvMat* _src, CvMat* _dst ) const;
+ virtual void scale_input( const Mat& _src, Mat& _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_output_scale( const CvVectors* vecs, int flags );
virtual void write_params( CvFileStorage* fs );
virtual void read_params( CvFileStorage* fs, CvFileNode* node );
- CvMat* layer_sizes;
- CvMat* wbuf;
- CvMat* sample_weights;
+ Mat& layer_sizes;
+ Mat& wbuf;
+ Mat& sample_weights;
double** weights;
double f_param1, f_param2;
double min_val, max_val, min_val1, max_val1;
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.
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.
CvNormalBayesClassifier();
virtual ~CvNormalBayesClassifier();
- CvNormalBayesClassifier( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx=0, const CvMat* _sample_idx=0 );
+ CvNormalBayesClassifier( const Mat& _train_data, const Mat& _responses,
+ const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat() );
- virtual bool train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx = 0, const CvMat* _sample_idx=0, bool update=false );
+ virtual bool train( const Mat& _train_data, const Mat& _responses,
+ 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 save( const char* filename, const char* name=0 );
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.
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).
public:
CvRTrees();
virtual ~CvRTrees();
- virtual bool 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,
+ virtual bool 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(),
CvRTParams params=CvRTParams() );
- virtual float predict( const CvMat* sample, const CvMat* missing = 0 )
+ virtual float predict( const Mat& sample, const Mat& missing = 0 )
const;
virtual void clear();
- virtual const CvMat* get_var_importance();
- virtual float get_proximity( const CvMat* sample_1, const CvMat* sample_2 )
+ virtual const Mat& get_var_importance();
+ virtual float get_proximity( const Mat& sample_1, const Mat& sample_2 )
const;
virtual void read( CvFileStorage* fs, CvFileNode* node );
virtual void write( CvFileStorage* fs, const char* name );
- CvMat* get_active_var_mask();
+ Mat& get_active_var_mask();
CvRNG* get_rng();
int get_tree_count() const;
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.
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.
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.
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.
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 ::
-
- #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;
- }
-
-
+For the random trees usage example, please, see letter_recog.cpp sample in OpenCV distribution.
{
public:
/* CvStatModel(); */
- /* CvStatModel( const CvMat* train_data ... ); */
+ /* CvStatModel( const Mat& train_data ... ); */
virtual ~CvStatModel();
virtual void clear()=0;
- /* virtual bool 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,]
+ /* virtual bool 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> ... )=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 load( const char* filename, const char* name=0 )=0;
CvStatModel::CvStatModel(...)
-----------------------------
-.. cpp:function:: CvStatModel::CvStatModel( const CvMat* train_data ... )
+.. cpp:function:: CvStatModel::CvStatModel( const Mat& train_data ... )
Serves as a training constructor.
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.
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.
CvSVM();
virtual ~CvSVM();
- CvSVM( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx=0, const CvMat* _sample_idx=0,
+ CvSVM( const Mat& _train_data, const Mat& _responses,
+ const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(),
CvSVMParams _params=CvSVMParams() );
- virtual bool train( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx=0, const CvMat* _sample_idx=0,
+ virtual bool train( const Mat& _train_data, const Mat& _responses,
+ const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(),
CvSVMParams _params=CvSVMParams() );
- virtual bool train_auto( const CvMat* _train_data, const CvMat* _responses,
- const CvMat* _var_idx, const CvMat* _sample_idx, CvSVMParams _params,
+ virtual bool 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 coef_grid = get_default_grid(CvSVM::COEF),
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 const float* get_support_vector(int i) const;
virtual CvSVMParams get_params() const { return params; };
CvSVMParams( int _svm_type, int _kernel_type,
double _degree, double _gamma, double _coef0,
double _C, double _nu, double _p,
- CvMat* _class_weights, CvTermCriteria _term_crit );
+ const CvMat* _class_weights, CvTermCriteria _term_crit );
int svm_type;
int kernel_type;
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.
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.
void CvEM::kmeans( const CvVectors& train_data, int nclusters, CvMat* labels,
CvTermCriteria termcrit, const CvMat* centers0 )
{
- CvMat* centers = 0;
- CvMat* old_centers = 0;
- 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 );
+ int i, nsamples = train_data.count, dims = train_data.dims;
+ cv::Ptr<CvMat> temp_mat = cvCreateMat(nsamples, dims, CV_32F);
+
for( i = 0; i < nsamples; i++ )
- counters->data.i[labels->data.i[i]]++;
-
- // ensure that we do not have empty clusters
- 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( ¢ers );
- cvReleaseMat( &old_centers );
- cvReleaseMat( &counters );
+ memcpy( temp_mat->data.ptr + temp_mat->step*i, train_data.data.fl[i], dims*sizeof(float));
+
+ cvKMeans2(temp_mat, nclusters, labels, termcrit, 10);
}
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.
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??.
CascadeClassifier::CascadeClassifier
----------------------------------------
-.. cpp:function:: CascadeClassifier::CascadeClassifier(const string\& filename)
+.. cpp:function:: CascadeClassifier::CascadeClassifier(const string& filename)
Loads a classifier from a file.
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.
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.
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.
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.
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.
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.
if fname.endswith("operator"):
fname += "()"
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("::", ".")
decl = [fname, rettype, [], []]
+ args0str = fdecl[apos+1:fdecl.rfind(")")].strip()
- for arg in args:
- dfpos = arg.find("=")
- defval = ""
- if dfpos >= 0:
- defval = arg[dfpos+1:].strip()
- arg = arg[:dfpos].strip()
- pos = arg.rfind(" ")
- aname = arg[pos+1:]
- atype = arg[:pos]
- decl[3].append([atype, aname, defval, []])
+ if args0str != "":
+ args0 = args0str.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 = ""
+
+ 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
--- /dev/null
+#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;
+}
projects / platform / upstream / opencv.git / commitdiff