+++ /dev/null
-*******************************************************
-calib3d. Camera Calibration, Pose Estimation and Stereo
-*******************************************************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- calib3d_camera_calibration_and_3d_reconstruction
+++ /dev/null
-Camera Calibration and 3d Reconstruction
-========================================
-
-.. highlight:: python
-
-
-The functions in this section use the so-called pinhole camera model. That
-is, a scene view is formed by projecting 3D points into the image plane
-using a perspective transformation.
-
-
-
-.. math::
-
- s \; m' = A [R|t] M'
-
-
-or
-
-
-
-.. math::
-
- s \vecthree{u}{v}{1} = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_1 \\ r_{21} & r_{22} & r_{23} & t_2 \\ r_{31} & r_{32} & r_{33} & t_3 \end{bmatrix} \begin{bmatrix} X \\ Y \\ Z \\ 1 \end{bmatrix}
-
-
-Where
-:math:`(X, Y, Z)`
-are the coordinates of a 3D point in the world
-coordinate space,
-:math:`(u, v)`
-are the coordinates of the projection point
-in pixels.
-:math:`A`
-is called a camera matrix, or a matrix of
-intrinsic parameters.
-:math:`(cx, cy)`
-is a principal point (that is
-usually at the image center), and
-:math:`fx, fy`
-are the focal lengths
-expressed in pixel-related units. Thus, if an image from camera is
-scaled by some factor, all of these parameters should
-be scaled (multiplied/divided, respectively) by the same factor. The
-matrix of intrinsic parameters does not depend on the scene viewed and,
-once estimated, can be re-used (as long as the focal length is fixed (in
-case of zoom lens)). The joint rotation-translation matrix
-:math:`[R|t]`
-is called a matrix of extrinsic parameters. It is used to describe the
-camera motion around a static scene, or vice versa, rigid motion of an
-object in front of still camera. That is,
-:math:`[R|t]`
-translates
-coordinates of a point
-:math:`(X, Y, Z)`
-to some coordinate system,
-fixed with respect to the camera. The transformation above is equivalent
-to the following (when
-:math:`z \ne 0`
-):
-
-
-
-.. math::
-
- \begin{array}{l} \vecthree{x}{y}{z} = R \vecthree{X}{Y}{Z} + t \\ x' = x/z \\ y' = y/z \\ u = f_x*x' + c_x \\ v = f_y*y' + c_y \end{array}
-
-
-Real lenses usually have some distortion, mostly
-radial distortion and slight tangential distortion. So, the above model
-is extended as:
-
-
-
-.. math::
-
- \begin{array}{l} \vecthree{x}{y}{z} = R \vecthree{X}{Y}{Z} + t \\ x' = x/z \\ y' = y/z \\ x'' = x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2 p_1 x' y' + p_2(r^2 + 2 x'^2) \\ y'' = y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' \\ \text{where} \quad r^2 = x'^2 + y'^2 \\ u = f_x*x'' + c_x \\ v = f_y*y'' + c_y \end{array}
-
-
-:math:`k_1`
-,
-:math:`k_2`
-,
-:math:`k_3`
-,
-:math:`k_4`
-,
-:math:`k_5`
-,
-:math:`k_6`
-are radial distortion coefficients,
-:math:`p_1`
-,
-:math:`p_2`
-are tangential distortion coefficients.
-Higher-order coefficients are not considered in OpenCV. In the functions below the coefficients are passed or returned as
-
-
-.. math::
-
- (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])
-
-
-vector. That is, if the vector contains 4 elements, it means that
-:math:`k_3=0`
-.
-The distortion coefficients do not depend on the scene viewed, thus they also belong to the intrinsic camera parameters.
-*And they remain the same regardless of the captured image resolution.*
-That is, if, for example, a camera has been calibrated on images of
-:math:`320
-\times 240`
-resolution, absolutely the same distortion coefficients can
-be used for images of
-:math:`640 \times 480`
-resolution from the same camera (while
-:math:`f_x`
-,
-:math:`f_y`
-,
-:math:`c_x`
-and
-:math:`c_y`
-need to be scaled appropriately).
-
-The functions below use the above model to
-
-
-
-
-
-*
- Project 3D points to the image plane given intrinsic and extrinsic parameters
-
-
-
-*
- Compute extrinsic parameters given intrinsic parameters, a few 3D points and their projections.
-
-
-
-*
- Estimate intrinsic and extrinsic camera parameters from several views of a known calibration pattern (i.e. every view is described by several 3D-2D point correspondences).
-
-
-
-*
- Estimate the relative position and orientation of the stereo camera "heads" and compute the
- *rectification*
- transformation that makes the camera optical axes parallel.
-
-
-
-.. index:: CalibrateCamera2
-
-.. _CalibrateCamera2:
-
-CalibrateCamera2
-----------------
-
-`id=0.782194232075 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CalibrateCamera2>`__
-
-
-.. function:: CalibrateCamera2(objectPoints,imagePoints,pointCounts,imageSize,cameraMatrix,distCoeffs,rvecs,tvecs,flags=0)-> None
-
- Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
-
-
-
-
-
-
- :param objectPoints: The joint matrix of object points - calibration pattern features in the model coordinate space. It is floating-point 3xN or Nx3 1-channel, or 1xN or Nx1 3-channel array, where N is the total number of points in all views.
-
- :type objectPoints: :class:`CvMat`
-
-
- :param imagePoints: The joint matrix of object points projections in the camera views. It is floating-point 2xN or Nx2 1-channel, or 1xN or Nx1 2-channel array, where N is the total number of points in all views
-
- :type imagePoints: :class:`CvMat`
-
-
- :param pointCounts: Integer 1xM or Mx1 vector (where M is the number of calibration pattern views) containing the number of points in each particular view. The sum of vector elements must match the size of ``objectPoints`` and ``imagePoints`` (=N).
-
- :type pointCounts: :class:`CvMat`
-
-
- :param imageSize: Size of the image, used only to initialize the intrinsic camera matrix
-
- :type imageSize: :class:`CvSize`
-
-
- :param cameraMatrix: The output 3x3 floating-point camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}` . If ``CV_CALIB_USE_INTRINSIC_GUESS`` and/or ``CV_CALIB_FIX_ASPECT_RATIO`` are specified, some or all of ``fx, fy, cx, cy`` must be initialized before calling the function
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The output vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param rvecs: The output 3x *M* or *M* x3 1-channel, or 1x *M* or *M* x1 3-channel array of rotation vectors (see :ref:`Rodrigues2` ), estimated for each pattern view. That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the calibration pattern from the model coordinate space (in which object points are specified) to the world coordinate space, i.e. real position of the calibration pattern in the k-th pattern view (k=0.. *M* -1)
-
- :type rvecs: :class:`CvMat`
-
-
- :param tvecs: The output 3x *M* or *M* x3 1-channel, or 1x *M* or *M* x1 3-channel array of translation vectors, estimated for each pattern view.
-
- :type tvecs: :class:`CvMat`
-
-
- :param flags: Different flags, may be 0 or combination of the following values:
-
- * **CV_CALIB_USE_INTRINSIC_GUESS** ``cameraMatrix`` contains the valid initial values of ``fx, fy, cx, cy`` that are optimized further. Otherwise, ``(cx, cy)`` is initially set to the image center ( ``imageSize`` is used here), and focal distances are computed in some least-squares fashion. Note, that if intrinsic parameters are known, there is no need to use this function just to estimate the extrinsic parameters. Use :ref:`FindExtrinsicCameraParams2` instead.
-
- * **CV_CALIB_FIX_PRINCIPAL_POINT** The principal point is not changed during the global optimization, it stays at the center or at the other location specified when ``CV_CALIB_USE_INTRINSIC_GUESS`` is set too.
-
- * **CV_CALIB_FIX_ASPECT_RATIO** The functions considers only ``fy`` as a free parameter, the ratio ``fx/fy`` stays the same as in the input ``cameraMatrix`` . When ``CV_CALIB_USE_INTRINSIC_GUESS`` is not set, the actual input values of ``fx`` and ``fy`` are ignored, only their ratio is computed and used further.
-
- * **CV_CALIB_ZERO_TANGENT_DIST** Tangential distortion coefficients :math:`(p_1, p_2)` will be set to zeros and stay zero.
-
-
- :type flags: int
-
-
- * **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** Do not change the corresponding radial distortion coefficient during the optimization. If ``CV_CALIB_USE_INTRINSIC_GUESS`` is set, the coefficient from the supplied ``distCoeffs`` matrix is used, otherwise it is set to 0.
-
-
- * **CV_CALIB_RATIONAL_MODEL** Enable coefficients k4, k5 and k6. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the rational model and return 8 coefficients. If the flag is not set, the function will compute only 5 distortion coefficients.
-
-
-
-
-
-The function estimates the intrinsic camera
-parameters and extrinsic parameters for each of the views. The
-coordinates of 3D object points and their correspondent 2D projections
-in each view must be specified. That may be achieved by using an
-object with known geometry and easily detectable feature points.
-Such an object is called a calibration rig or calibration pattern,
-and OpenCV has built-in support for a chessboard as a calibration
-rig (see
-:ref:`FindChessboardCorners`
-). Currently, initialization
-of intrinsic parameters (when
-``CV_CALIB_USE_INTRINSIC_GUESS``
-is not set) is only implemented for planar calibration patterns
-(where z-coordinates of the object points must be all 0's). 3D
-calibration rigs can also be used as long as initial
-``cameraMatrix``
-is provided.
-
-The algorithm does the following:
-
-
-
-
-#.
- First, it computes the initial intrinsic parameters (the option only available for planar calibration patterns) or reads them from the input parameters. The distortion coefficients are all set to zeros initially (unless some of
- ``CV_CALIB_FIX_K?``
- are specified).
-
-
-
-#.
- The initial camera pose is estimated as if the intrinsic parameters have been already known. This is done using
- :ref:`FindExtrinsicCameraParams2`
-
-
-#.
- After that the global Levenberg-Marquardt optimization algorithm is run to minimize the reprojection error, i.e. the total sum of squared distances between the observed feature points
- ``imagePoints``
- and the projected (using the current estimates for camera parameters and the poses) object points
- ``objectPoints``
- ; see
- :ref:`ProjectPoints2`
- .
-
-
-Note: if you're using a non-square (=non-NxN) grid and
-:func:`findChessboardCorners`
-for calibration, and
-``calibrateCamera``
-returns
-bad values (i.e. zero distortion coefficients, an image center very far from
-:math:`(w/2-0.5,h/2-0.5)`
-, and / or large differences between
-:math:`f_x`
-and
-:math:`f_y`
-(ratios of
-10:1 or more)), then you've probably used
-``patternSize=cvSize(rows,cols)``
-,
-but should use
-``patternSize=cvSize(cols,rows)``
-in
-:ref:`FindChessboardCorners`
-.
-
-See also:
-:ref:`FindChessboardCorners`
-,
-:ref:`FindExtrinsicCameraParams2`
-,
-:func:`initCameraMatrix2D`
-,
-:ref:`StereoCalibrate`
-,
-:ref:`Undistort2`
-
-.. index:: ComputeCorrespondEpilines
-
-.. _ComputeCorrespondEpilines:
-
-ComputeCorrespondEpilines
--------------------------
-
-`id=0.812565376037 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/ComputeCorrespondEpilines>`__
-
-
-.. function:: ComputeCorrespondEpilines(points, whichImage, F, lines) -> None
-
- For points in one image of a stereo pair, computes the corresponding epilines in the other image.
-
-
-
-
-
-
- :param points: The input points. ``2xN, Nx2, 3xN`` or ``Nx3`` array (where ``N`` number of points). Multi-channel ``1xN`` or ``Nx1`` array is also acceptable
-
- :type points: :class:`CvMat`
-
-
- :param whichImage: Index of the image (1 or 2) that contains the ``points``
-
- :type whichImage: int
-
-
- :param F: The fundamental matrix that can be estimated using :ref:`FindFundamentalMat`
- or :ref:`StereoRectify` .
-
- :type F: :class:`CvMat`
-
-
- :param lines: The output epilines, a ``3xN`` or ``Nx3`` array. Each line :math:`ax + by + c=0` is encoded by 3 numbers :math:`(a, b, c)`
-
- :type lines: :class:`CvMat`
-
-
-
-For every point in one of the two images of a stereo-pair the function finds the equation of the
-corresponding epipolar line in the other image.
-
-From the fundamental matrix definition (see
-:ref:`FindFundamentalMat`
-),
-line
-:math:`l^{(2)}_i`
-in the second image for the point
-:math:`p^{(1)}_i`
-in the first image (i.e. when
-``whichImage=1``
-) is computed as:
-
-
-
-.. math::
-
- l^{(2)}_i = F p^{(1)}_i
-
-
-and, vice versa, when
-``whichImage=2``
-,
-:math:`l^{(1)}_i`
-is computed from
-:math:`p^{(2)}_i`
-as:
-
-
-
-.. math::
-
- l^{(1)}_i = F^T p^{(2)}_i
-
-
-Line coefficients are defined up to a scale. They are normalized, such that
-:math:`a_i^2+b_i^2=1`
-.
-
-
-.. index:: ConvertPointsHomogeneous
-
-.. _ConvertPointsHomogeneous:
-
-ConvertPointsHomogeneous
-------------------------
-
-`id=0.174046913553 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/ConvertPointsHomogeneous>`__
-
-
-.. function:: ConvertPointsHomogeneous( src, dst ) -> None
-
- Convert points to/from homogeneous coordinates.
-
-
-
-
-
-
- :param src: The input array or vector of 2D, 3D or 4D points
-
- :type src: :class:`CvMat`
-
-
- :param dst: The output vector of 2D or 2D points
-
- :type dst: :class:`CvMat`
-
-
-
-The
-2D or 3D points from/to homogeneous coordinates, or simply
-the array. If the input array dimensionality is larger than the output, each coordinate is divided by the last coordinate:
-
-
-
-.. math::
-
- \begin{array}{l} (x,y[,z],w) -> (x',y'[,z']) \\ \text{where} \\ x' = x/w \\ y' = y/w \\ z' = z/w \quad \text{(if output is 3D)} \end{array}
-
-
-If the output array dimensionality is larger, an extra 1 is appended to each point. Otherwise, the input array is simply copied (with optional transposition) to the output.
-
-
-.. index:: CreatePOSITObject
-
-.. _CreatePOSITObject:
-
-CreatePOSITObject
------------------
-
-`id=0.575884728475 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CreatePOSITObject>`__
-
-
-.. function:: CreatePOSITObject(points)-> POSITObject
-
- Initializes a structure containing object information.
-
-
-
-
-
-
- :param points: List of 3D points
-
- :type points: :class:`CvPoint3D32fs`
-
-
-
-The function allocates memory for the object structure and computes the object inverse matrix.
-
-The preprocessed object data is stored in the structure
-:ref:`CvPOSITObject`
-, internal for OpenCV, which means that the user cannot directly access the structure data. The user may only create this structure and pass its pointer to the function.
-
-An object is defined as a set of points given in a coordinate system. The function
-:ref:`POSIT`
-computes a vector that begins at a camera-related coordinate system center and ends at the
-``points[0]``
-of the object.
-
-Once the work with a given object is finished, the function
-:ref:`ReleasePOSITObject`
-must be called to free memory.
-
-
-.. index:: CreateStereoBMState
-
-.. _CreateStereoBMState:
-
-CreateStereoBMState
--------------------
-
-`id=0.181953212374 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CreateStereoBMState>`__
-
-
-.. function:: CreateStereoBMState(preset=CV_STEREO_BM_BASIC,numberOfDisparities=0)-> StereoBMState
-
- Creates block matching stereo correspondence structure.
-
-
-
-
-
-
- :param preset: ID of one of the pre-defined parameter sets. Any of the parameters can be overridden after creating the structure. Values are
-
- * **CV_STEREO_BM_BASIC** Parameters suitable for general cameras
-
- * **CV_STEREO_BM_FISH_EYE** Parameters suitable for wide-angle cameras
-
- * **CV_STEREO_BM_NARROW** Parameters suitable for narrow-angle cameras
-
-
-
- :type preset: int
-
-
- :param numberOfDisparities: The number of disparities. If the parameter is 0, it is taken from the preset, otherwise the supplied value overrides the one from preset.
-
- :type numberOfDisparities: int
-
-
-
-The function creates the stereo correspondence structure and initializes
-it. It is possible to override any of the parameters at any time between
-the calls to
-:ref:`FindStereoCorrespondenceBM`
-.
-
-
-.. index:: CreateStereoGCState
-
-.. _CreateStereoGCState:
-
-CreateStereoGCState
--------------------
-
-`id=0.718216892131 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CreateStereoGCState>`__
-
-
-.. function:: CreateStereoGCState(numberOfDisparities,maxIters)-> StereoGCState
-
- Creates the state of graph cut-based stereo correspondence algorithm.
-
-
-
-
-
-
- :param numberOfDisparities: The number of disparities. The disparity search range will be :math:`\texttt{state->minDisparity} \le disparity < \texttt{state->minDisparity} + \texttt{state->numberOfDisparities}`
-
- :type numberOfDisparities: int
-
-
- :param maxIters: Maximum number of iterations. On each iteration all possible (or reasonable) alpha-expansions are tried. The algorithm may terminate earlier if it could not find an alpha-expansion that decreases the overall cost function value. See Kolmogorov03 for details.
-
- :type maxIters: int
-
-
-
-The function creates the stereo correspondence structure and initializes it. It is possible to override any of the parameters at any time between the calls to
-:ref:`FindStereoCorrespondenceGC`
-.
-
-
-.. index:: CvStereoBMState
-
-.. _CvStereoBMState:
-
-CvStereoBMState
----------------
-
-`id=0.314911926499 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CvStereoBMState>`__
-
-.. class:: CvStereoBMState
-
-
-
-The structure for block matching stereo correspondence algorithm.
-
-
-
-
-
- .. attribute:: preFilterType
-
-
-
- type of the prefilter, ``CV_STEREO_BM_NORMALIZED_RESPONSE`` or the default and the recommended ``CV_STEREO_BM_XSOBEL`` , int
-
-
-
- .. attribute:: preFilterSize
-
-
-
- ~5x5..21x21, int
-
-
-
- .. attribute:: preFilterCap
-
-
-
- up to ~31, int
-
-
-
- .. attribute:: SADWindowSize
-
-
-
- Could be 5x5..21x21 or higher, but with 21x21 or smaller windows the processing speed is much higher, int
-
-
-
- .. attribute:: minDisparity
-
-
-
- minimum disparity (=0), int
-
-
-
- .. attribute:: numberOfDisparities
-
-
-
- maximum disparity - minimum disparity, int
-
-
-
- .. attribute:: textureThreshold
-
-
-
- the textureness threshold. That is, if the sum of absolute values of x-derivatives computed over ``SADWindowSize`` by ``SADWindowSize`` pixel neighborhood is smaller than the parameter, no disparity is computed at the pixel, int
-
-
-
- .. attribute:: uniquenessRatio
-
-
-
- the minimum margin in percents between the best (minimum) cost function value and the second best value to accept the computed disparity, int
-
-
-
- .. attribute:: speckleWindowSize
-
-
-
- the maximum area of speckles to remove (set to 0 to disable speckle filtering), int
-
-
-
- .. attribute:: speckleRange
-
-
-
- acceptable range of disparity variation in each connected component, int
-
-
-
- .. attribute:: trySmallerWindows
-
-
-
- not used currently (0), int
-
-
-
- .. attribute:: roi1, roi2
-
-
-
- These are the clipping ROIs for the left and the right images. The function :ref:`StereoRectify` returns the largest rectangles in the left and right images where after the rectification all the pixels are valid. If you copy those rectangles to the ``CvStereoBMState`` structure, the stereo correspondence function will automatically clear out the pixels outside of the "valid" disparity rectangle computed by :ref:`GetValidDisparityROI` . Thus you will get more "invalid disparity" pixels than usual, but the remaining pixels are more probable to be valid.
-
-
-
- .. attribute:: disp12MaxDiff
-
-
-
- The maximum allowed difference between the explicitly computed left-to-right disparity map and the implicitly (by :ref:`ValidateDisparity` ) computed right-to-left disparity. If for some pixel the difference is larger than the specified threshold, the disparity at the pixel is invalidated. By default this parameter is set to (-1), which means that the left-right check is not performed.
-
-
-
-The block matching stereo correspondence algorithm, by Kurt Konolige, is very fast single-pass stereo matching algorithm that uses sliding sums of absolute differences between pixels in the left image and the pixels in the right image, shifted by some varying amount of pixels (from
-``minDisparity``
-to
-``minDisparity+numberOfDisparities``
-). On a pair of images WxH the algorithm computes disparity in
-``O(W*H*numberOfDisparities)``
-time. In order to improve quality and readability of the disparity map, the algorithm includes pre-filtering and post-filtering procedures.
-
-Note that the algorithm searches for the corresponding blocks in x direction only. It means that the supplied stereo pair should be rectified. Vertical stereo layout is not directly supported, but in such a case the images could be transposed by user.
-
-
-.. index:: CvStereoGCState
-
-.. _CvStereoGCState:
-
-CvStereoGCState
----------------
-
-`id=0.396531770881 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/CvStereoGCState>`__
-
-.. class:: CvStereoGCState
-
-
-
-The structure for graph cuts-based stereo correspondence algorithm
-
-
-
-
-
- .. attribute:: Ithreshold
-
-
-
- threshold for piece-wise linear data cost function (5 by default)
-
-
-
- .. attribute:: interactionRadius
-
-
-
- radius for smoothness cost function (1 by default; means Potts model)
-
-
-
- .. attribute:: K, lambda, lambda1, lambda2
-
-
-
- parameters for the cost function (usually computed adaptively from the input data)
-
-
-
- .. attribute:: occlusionCost
-
-
-
- 10000 by default
-
-
-
- .. attribute:: minDisparity
-
-
-
- 0 by default; see :ref:`CvStereoBMState`
-
-
-
- .. attribute:: numberOfDisparities
-
-
-
- defined by user; see :ref:`CvStereoBMState`
-
-
-
- .. attribute:: maxIters
-
-
-
- number of iterations; defined by user.
-
-
-
-The graph cuts stereo correspondence algorithm, described in
-Kolmogorov03
-(as
-**KZ1**
-), is non-realtime stereo correspondence algorithm that usually gives very accurate depth map with well-defined object boundaries. The algorithm represents stereo problem as a sequence of binary optimization problems, each of those is solved using maximum graph flow algorithm. The state structure above should not be allocated and initialized manually; instead, use
-:ref:`CreateStereoGCState`
-and then override necessary parameters if needed.
-
-
-.. index:: DecomposeProjectionMatrix
-
-.. _DecomposeProjectionMatrix:
-
-DecomposeProjectionMatrix
--------------------------
-
-`id=0.997149293534 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/DecomposeProjectionMatrix>`__
-
-
-.. function:: DecomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrX = None, rotMatrY = None, rotMatrZ = None) -> eulerAngles
-
- Decomposes the projection matrix into a rotation matrix and a camera matrix.
-
-
-
-
-
-
- :param projMatrix: The 3x4 input projection matrix P
-
- :type projMatrix: :class:`CvMat`
-
-
- :param cameraMatrix: The output 3x3 camera matrix K
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param rotMatrix: The output 3x3 external rotation matrix R
-
- :type rotMatrix: :class:`CvMat`
-
-
- :param transVect: The output 4x1 translation vector T
-
- :type transVect: :class:`CvMat`
-
-
- :param rotMatrX: Optional 3x3 rotation matrix around x-axis
-
- :type rotMatrX: :class:`CvMat`
-
-
- :param rotMatrY: Optional 3x3 rotation matrix around y-axis
-
- :type rotMatrY: :class:`CvMat`
-
-
- :param rotMatrZ: Optional 3x3 rotation matrix around z-axis
-
- :type rotMatrZ: :class:`CvMat`
-
-
- :param eulerAngles: Optional 3 points containing the three Euler angles of rotation
-
- :type eulerAngles: :class:`CvPoint3D64f`
-
-
-
-The function computes a decomposition of a projection matrix into a calibration and a rotation matrix and the position of the camera.
-
-It optionally returns three rotation matrices, one for each axis, and the three Euler angles that could be used in OpenGL.
-
-The function is based on
-:ref:`RQDecomp3x3`
-.
-
-
-.. index:: DrawChessboardCorners
-
-.. _DrawChessboardCorners:
-
-DrawChessboardCorners
----------------------
-
-`id=0.657339526052 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/DrawChessboardCorners>`__
-
-
-.. function:: DrawChessboardCorners(image,patternSize,corners,patternWasFound)-> None
-
- Renders the detected chessboard corners.
-
-
-
-
-
-
- :param image: The destination image; it must be an 8-bit color image
-
- :type image: :class:`CvArr`
-
-
- :param patternSize: The number of inner corners per chessboard row and column. (patternSize = cv::Size(points _ per _ row,points _ per _ column) = cv::Size(rows,columns) )
-
- :type patternSize: :class:`CvSize`
-
-
- :param corners: The array of corners detected, this should be the output from findChessboardCorners wrapped in a cv::Mat().
-
- :type corners: sequence of (float, float)
-
-
- :param patternWasFound: Indicates whether the complete board was found :math:`(\ne 0)` or not :math:`(=0)` . One may just pass the return value :ref:`FindChessboardCorners` here
-
- :type patternWasFound: int
-
-
-
-The function draws the individual chessboard corners detected as red circles if the board was not found or as colored corners connected with lines if the board was found.
-
-
-.. index:: FindChessboardCorners
-
-.. _FindChessboardCorners:
-
-FindChessboardCorners
----------------------
-
-`id=0.629260035574 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindChessboardCorners>`__
-
-
-.. function:: FindChessboardCorners(image, patternSize, flags=CV_CALIB_CB_ADAPTIVE_THRESH) -> corners
-
- Finds the positions of the internal corners of the chessboard.
-
-
-
-
-
-
- :param image: Source chessboard view; it must be an 8-bit grayscale or color image
-
- :type image: :class:`CvArr`
-
-
- :param patternSize: The number of inner corners per chessboard row and column
- ( patternSize = cvSize(points _ per _ row,points _ per _ colum) = cvSize(columns,rows) )
-
- :type patternSize: :class:`CvSize`
-
-
- :param corners: The output array of corners detected
-
- :type corners: sequence of (float, float)
-
-
- :param flags: Various operation flags, can be 0 or a combination of the following values:
-
-
- * **CV_CALIB_CB_ADAPTIVE_THRESH** use adaptive thresholding to convert the image to black and white, rather than a fixed threshold level (computed from the average image brightness).
-
-
- * **CV_CALIB_CB_NORMALIZE_IMAGE** normalize the image gamma with :ref:`EqualizeHist` before applying fixed or adaptive thresholding.
-
-
- * **CV_CALIB_CB_FILTER_QUADS** use additional criteria (like contour area, perimeter, square-like shape) to filter out false quads that are extracted at the contour retrieval stage.
-
-
- * **CALIB_CB_FAST_CHECK** Runs a fast check on the image that looks for chessboard corners, and shortcuts the call if none are found. This can drastically speed up the call in the degenerate condition when
- no chessboard is observed.
-
-
-
- :type flags: int
-
-
-
-The function attempts to determine
-whether the input image is a view of the chessboard pattern and
-locate the internal chessboard corners. The function returns a non-zero
-value if all of the corners have been found and they have been placed
-in a certain order (row by row, left to right in every row),
-otherwise, if the function fails to find all the corners or reorder
-them, it returns 0. For example, a regular chessboard has 8 x 8
-squares and 7 x 7 internal corners, that is, points, where the black
-squares touch each other. The coordinates detected are approximate,
-and to determine their position more accurately, the user may use
-the function
-:ref:`FindCornerSubPix`
-.
-
-Sample usage of detecting and drawing chessboard corners:
-
-
-
-::
-
-
-
- Size patternsize(8,6); //interior number of corners
- Mat gray = ....; //source image
- vector<Point2f> corners; //this will be filled by the detected corners
-
- //CALIB_CB_FAST_CHECK saves a lot of time on images
- //that don't contain any chessboard corners
- bool patternfound = findChessboardCorners(gray, patternsize, corners,
- CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
- + CALIB_CB_FAST_CHECK);
-
- if(patternfound)
- cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
- TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
-
- drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
-
-
-..
-
-**Note:**
-the function requires some white space (like a square-thick border, the wider the better) around the board to make the detection more robust in various environment (otherwise if there is no border and the background is dark, the outer black squares could not be segmented properly and so the square grouping and ordering algorithm will fail).
-
-
-.. index:: FindExtrinsicCameraParams2
-
-.. _FindExtrinsicCameraParams2:
-
-FindExtrinsicCameraParams2
---------------------------
-
-`id=0.0389878424328 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindExtrinsicCameraParams2>`__
-
-
-.. function:: FindExtrinsicCameraParams2(objectPoints,imagePoints,cameraMatrix,distCoeffs,rvec,tvec,useExtrinsicGuess=0)-> None
-
- Finds the object pose from the 3D-2D point correspondences
-
-
-
-
-
-
- :param objectPoints: The array of object points in the object coordinate space, 3xN or Nx3 1-channel, or 1xN or Nx1 3-channel, where N is the number of points.
-
- :type objectPoints: :class:`CvMat`
-
-
- :param imagePoints: The array of corresponding image points, 2xN or Nx2 1-channel or 1xN or Nx1 2-channel, where N is the number of points.
-
- :type imagePoints: :class:`CvMat`
-
-
- :param cameraMatrix: The input camera matrix :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param rvec: The output rotation vector (see :ref:`Rodrigues2` ) that (together with ``tvec`` ) brings points from the model coordinate system to the camera coordinate system
-
- :type rvec: :class:`CvMat`
-
-
- :param tvec: The output translation vector
-
- :type tvec: :class:`CvMat`
-
-
- :param useExtrinsicGuess: If true (1), the function will use the provided ``rvec`` and ``tvec`` as the initial approximations of the rotation and translation vectors, respectively, and will further optimize them.
-
- :type useExtrinsicGuess: int
-
-
-
-The function estimates the object pose given a set of object points, their corresponding image projections, as well as the camera matrix and the distortion coefficients. This function finds such a pose that minimizes reprojection error, i.e. the sum of squared distances between the observed projections
-``imagePoints``
-and the projected (using
-:ref:`ProjectPoints2`
-)
-``objectPoints``
-.
-
-
-The function's counterpart in the C++ API is
-
-.. index:: FindFundamentalMat
-
-.. _FindFundamentalMat:
-
-FindFundamentalMat
-------------------
-
-`id=0.89177797951 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindFundamentalMat>`__
-
-
-.. function:: FindFundamentalMat(points1, points2, fundamentalMatrix, method=CV_FM_RANSAC, param1=1., param2=0.99, status = None) -> None
-
- Calculates the fundamental matrix from the corresponding points in two images.
-
-
-
-
-
-
- :param points1: Array of ``N`` points from the first image. It can be ``2xN, Nx2, 3xN`` or ``Nx3`` 1-channel array or ``1xN`` or ``Nx1`` 2- or 3-channel array . The point coordinates should be floating-point (single or double precision)
-
- :type points1: :class:`CvMat`
-
-
- :param points2: Array of the second image points of the same size and format as ``points1``
-
- :type points2: :class:`CvMat`
-
-
- :param fundamentalMatrix: The output fundamental matrix or matrices. The size should be 3x3 or 9x3 (7-point method may return up to 3 matrices)
-
- :type fundamentalMatrix: :class:`CvMat`
-
-
- :param method: Method for computing the fundamental matrix
-
-
- * **CV_FM_7POINT** for a 7-point algorithm. :math:`N = 7`
-
-
- * **CV_FM_8POINT** for an 8-point algorithm. :math:`N \ge 8`
-
-
- * **CV_FM_RANSAC** for the RANSAC algorithm. :math:`N \ge 8`
-
-
- * **CV_FM_LMEDS** for the LMedS algorithm. :math:`N \ge 8`
-
-
-
- :type method: int
-
-
- :param param1: The parameter is used for RANSAC. It is the maximum distance from point to epipolar line in pixels, beyond which the point is considered an outlier and is not used for computing the final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the point localization, image resolution and the image noise
-
- :type param1: float
-
-
- :param param2: The parameter is used for RANSAC or LMedS methods only. It specifies the desirable level of confidence (probability) that the estimated matrix is correct
-
- :type param2: float
-
-
- :param status: The optional output array of N elements, every element of which is set to 0 for outliers and to 1 for the other points. The array is computed only in RANSAC and LMedS methods. For other methods it is set to all 1's
-
- :type status: :class:`CvMat`
-
-
-
-The epipolar geometry is described by the following equation:
-
-
-
-.. math::
-
- [p_2; 1]^T F [p_1; 1] = 0
-
-
-where
-:math:`F`
-is fundamental matrix,
-:math:`p_1`
-and
-:math:`p_2`
-are corresponding points in the first and the second images, respectively.
-
-The function calculates the fundamental matrix using one of four methods listed above and returns
-the number of fundamental matrices found (1 or 3) and 0, if no matrix is found
-. Normally just 1 matrix is found, but in the case of 7-point algorithm the function may return up to 3 solutions (
-:math:`9 \times 3`
-matrix that stores all 3 matrices sequentially).
-
-The calculated fundamental matrix may be passed further to
-:ref:`ComputeCorrespondEpilines`
-that finds the epipolar lines
-corresponding to the specified points. It can also be passed to
-:ref:`StereoRectifyUncalibrated`
-to compute the rectification transformation.
-
-
-.. index:: FindHomography
-
-.. _FindHomography:
-
-FindHomography
---------------
-
-`id=0.964547232485 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindHomography>`__
-
-
-.. function:: FindHomography(srcPoints,dstPoints,H,method,ransacReprojThreshold=3.0, status=None)-> None
-
- Finds the perspective transformation between two planes.
-
-
-
-
-
-
- :param srcPoints: Coordinates of the points in the original plane, 2xN, Nx2, 3xN or Nx3 1-channel array (the latter two are for representation in homogeneous coordinates), where N is the number of points. 1xN or Nx1 2- or 3-channel array can also be passed.
-
- :type srcPoints: :class:`CvMat`
-
- :param dstPoints: Point coordinates in the destination plane, 2xN, Nx2, 3xN or Nx3 1-channel, or 1xN or Nx1 2- or 3-channel array.
-
- :type dstPoints: :class:`CvMat`
-
-
- :param H: The output 3x3 homography matrix
-
- :type H: :class:`CvMat`
-
-
- :param method: The method used to computed homography matrix; one of the following:
-
- * **0** a regular method using all the points
-
- * **CV_RANSAC** RANSAC-based robust method
-
- * **CV_LMEDS** Least-Median robust method
-
-
-
- :type method: int
-
-
- :param ransacReprojThreshold: The maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only). That is, if
-
- .. math::
-
- \| \texttt{dstPoints} _i - \texttt{convertPointsHomogeneous} ( \texttt{H} \texttt{srcPoints} _i) \| > \texttt{ransacReprojThreshold}
-
- then the point :math:`i` is considered an outlier. If ``srcPoints`` and ``dstPoints`` are measured in pixels, it usually makes sense to set this parameter somewhere in the range 1 to 10.
-
- :type ransacReprojThreshold: float
-
-
- :param status: The optional output mask set by a robust method ( ``CV_RANSAC`` or ``CV_LMEDS`` ). *Note that the input mask values are ignored.*
-
- :type status: :class:`CvMat`
-
-
-
-The
-function finds
-the perspective transformation
-:math:`H`
-between the source and the destination planes:
-
-
-
-.. math::
-
- s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}
-
-
-So that the back-projection error
-
-
-
-.. math::
-
- \sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2
-
-
-is minimized. If the parameter
-``method``
-is set to the default value 0, the function
-uses all the point pairs to compute the initial homography estimate with a simple least-squares scheme.
-
-However, if not all of the point pairs (
-:math:`srcPoints_i`
-,
-:math:`dstPoints_i`
-) fit the rigid perspective transformation (i.e. there
-are some outliers), this initial estimate will be poor.
-In this case one can use one of the 2 robust methods. Both methods,
-``RANSAC``
-and
-``LMeDS``
-, try many different random subsets
-of the corresponding point pairs (of 4 pairs each), estimate
-the homography matrix using this subset and a simple least-square
-algorithm and then compute the quality/goodness of the computed homography
-(which is the number of inliers for RANSAC or the median re-projection
-error for LMeDs). The best subset is then used to produce the initial
-estimate of the homography matrix and the mask of inliers/outliers.
-
-Regardless of the method, robust or not, the computed homography
-matrix is refined further (using inliers only in the case of a robust
-method) with the Levenberg-Marquardt method in order to reduce the
-re-projection error even more.
-
-The method
-``RANSAC``
-can handle practically any ratio of outliers,
-but it needs the threshold to distinguish inliers from outliers.
-The method
-``LMeDS``
-does not need any threshold, but it works
-correctly only when there are more than 50
-%
-of inliers. Finally,
-if you are sure in the computed features, where can be only some
-small noise present, but no outliers, the default method could be the best
-choice.
-
-The function is used to find initial intrinsic and extrinsic matrices.
-Homography matrix is determined up to a scale, thus it is normalized so that
-:math:`h_{33}=1`
-.
-
-See also:
-:ref:`GetAffineTransform`
-,
-:ref:`GetPerspectiveTransform`
-,
-:ref:`EstimateRigidMotion`
-,
-:ref:`WarpPerspective`
-,
-:ref:`PerspectiveTransform`
-
-.. index:: FindStereoCorrespondenceBM
-
-.. _FindStereoCorrespondenceBM:
-
-FindStereoCorrespondenceBM
---------------------------
-
-`id=0.6416249077 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindStereoCorrespondenceBM>`__
-
-
-.. function:: FindStereoCorrespondenceBM(left,right,disparity,state)-> None
-
- Computes the disparity map using block matching algorithm.
-
-
-
-
-
-
- :param left: The left single-channel, 8-bit image.
-
- :type left: :class:`CvArr`
-
-
- :param right: The right image of the same size and the same type.
-
- :type right: :class:`CvArr`
-
-
- :param disparity: The output single-channel 16-bit signed, or 32-bit floating-point disparity map of the same size as input images. In the first case the computed disparities are represented as fixed-point numbers with 4 fractional bits (i.e. the computed disparity values are multiplied by 16 and rounded to integers).
-
- :type disparity: :class:`CvArr`
-
-
- :param state: Stereo correspondence structure.
-
- :type state: :class:`CvStereoBMState`
-
-
-
-The function cvFindStereoCorrespondenceBM computes disparity map for the input rectified stereo pair. Invalid pixels (for which disparity can not be computed) are set to
-``state->minDisparity - 1``
-(or to
-``(state->minDisparity-1)*16``
-in the case of 16-bit fixed-point disparity map)
-
-
-.. index:: FindStereoCorrespondenceGC
-
-.. _FindStereoCorrespondenceGC:
-
-FindStereoCorrespondenceGC
---------------------------
-
-`id=0.511426409323 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/FindStereoCorrespondenceGC>`__
-
-
-.. function:: FindStereoCorrespondenceGC( left, right, dispLeft, dispRight, state, useDisparityGuess=(0))-> None
-
- Computes the disparity map using graph cut-based algorithm.
-
-
-
-
-
-
- :param left: The left single-channel, 8-bit image.
-
- :type left: :class:`CvArr`
-
-
- :param right: The right image of the same size and the same type.
-
- :type right: :class:`CvArr`
-
-
- :param dispLeft: The optional output single-channel 16-bit signed left disparity map of the same size as input images.
-
- :type dispLeft: :class:`CvArr`
-
-
- :param dispRight: The optional output single-channel 16-bit signed right disparity map of the same size as input images.
-
- :type dispRight: :class:`CvArr`
-
-
- :param state: Stereo correspondence structure.
-
- :type state: :class:`CvStereoGCState`
-
-
- :param useDisparityGuess: If the parameter is not zero, the algorithm will start with pre-defined disparity maps. Both dispLeft and dispRight should be valid disparity maps. Otherwise, the function starts with blank disparity maps (all pixels are marked as occlusions).
-
- :type useDisparityGuess: int
-
-
-
-The function computes disparity maps for the input rectified stereo pair. Note that the left disparity image will contain values in the following range:
-
-
-
-.. math::
-
- - \texttt{state->numberOfDisparities} - \texttt{state->minDisparity} < dispLeft(x,y) \le - \texttt{state->minDisparity} ,
-
-
-or
-
-
-.. math::
-
- dispLeft(x,y) == \texttt{CV\_STEREO\_GC\_OCCLUSION}
-
-
-and for the right disparity image the following will be true:
-
-
-
-.. math::
-
- \texttt{state->minDisparity} \le dispRight(x,y)
- < \texttt{state->minDisparity} + \texttt{state->numberOfDisparities}
-
-
-or
-
-
-
-.. math::
-
- dispRight(x,y) == \texttt{CV\_STEREO\_GC\_OCCLUSION}
-
-
-that is, the range for the left disparity image will be inversed,
-and the pixels for which no good match has been found, will be marked
-as occlusions.
-
-Here is how the function can be used:
-
-.. include:: /Users/vp/Projects/ocv/opencv/doc/python_fragments/findstereocorrespondence.py
- :literal:
-
-
-and this is the output left disparity image computed from the well-known
-Tsukuba stereo pair and multiplied by -16 (because the values in the
-left disparity images are usually negative):
-
-
-
-.. image:: ../pics/disparity.png
-
-
-
-
-.. index:: GetOptimalNewCameraMatrix
-
-.. _GetOptimalNewCameraMatrix:
-
-GetOptimalNewCameraMatrix
--------------------------
-
-`id=0.850139058889 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/GetOptimalNewCameraMatrix>`__
-
-
-.. function:: GetOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newCameraMatrix, newImageSize=(0,0), validPixROI=0) -> None
-
- Returns the new camera matrix based on the free scaling parameter
-
-
-
-
-
-
- :param cameraMatrix: The input camera matrix
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param imageSize: The original image size
-
- :type imageSize: :class:`CvSize`
-
-
- :param alpha: The free scaling parameter between 0 (when all the pixels in the undistorted image will be valid) and 1 (when all the source image pixels will be retained in the undistorted image); see :ref:`StereoRectify`
-
- :type alpha: float
-
-
- :param newCameraMatrix: The output new camera matrix.
-
- :type newCameraMatrix: :class:`CvMat`
-
-
- :param newImageSize: The image size after rectification. By default it will be set to ``imageSize`` .
-
- :type newImageSize: :class:`CvSize`
-
-
- :param validPixROI: The optional output rectangle that will outline all-good-pixels region in the undistorted image. See ``roi1, roi2`` description in :ref:`StereoRectify`
-
- :type validPixROI: :class:`CvRect`
-
-
-
-The function computes
-the optimal new camera matrix based on the free scaling parameter. By varying this parameter the user may retrieve only sensible pixels
-``alpha=0``
-, keep all the original image pixels if there is valuable information in the corners
-``alpha=1``
-, or get something in between. When
-``alpha>0``
-, the undistortion result will likely have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera matrix, distortion coefficients, the computed new camera matrix and the
-``newImageSize``
-should be passed to
-:ref:`InitUndistortRectifyMap`
-to produce the maps for
-:ref:`Remap`
-.
-
-
-.. index:: InitIntrinsicParams2D
-
-.. _InitIntrinsicParams2D:
-
-InitIntrinsicParams2D
----------------------
-
-`id=0.845508653607 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/InitIntrinsicParams2D>`__
-
-
-.. function:: InitIntrinsicParams2D(objectPoints, imagePoints, npoints, imageSize, cameraMatrix, aspectRatio=1.) -> None
-
- Finds the initial camera matrix from the 3D-2D point correspondences
-
-
-
-
-
-
- :param objectPoints: The joint array of object points; see :ref:`CalibrateCamera2`
-
- :type objectPoints: :class:`CvMat`
-
-
- :param imagePoints: The joint array of object point projections; see :ref:`CalibrateCamera2`
-
- :type imagePoints: :class:`CvMat`
-
-
- :param npoints: The array of point counts; see :ref:`CalibrateCamera2`
-
- :type npoints: :class:`CvMat`
-
-
- :param imageSize: The image size in pixels; used to initialize the principal point
-
- :type imageSize: :class:`CvSize`
-
-
- :param cameraMatrix: The output camera matrix :math:`\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param aspectRatio: If it is zero or negative, both :math:`f_x` and :math:`f_y` are estimated independently. Otherwise :math:`f_x = f_y * \texttt{aspectRatio}`
-
- :type aspectRatio: float
-
-
-
-The function estimates and returns the initial camera matrix for camera calibration process.
-Currently, the function only supports planar calibration patterns, i.e. patterns where each object point has z-coordinate =0.
-
-
-.. index:: InitUndistortMap
-
-.. _InitUndistortMap:
-
-InitUndistortMap
-----------------
-
-`id=0.720345336817 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/InitUndistortMap>`__
-
-
-.. function:: InitUndistortMap(cameraMatrix,distCoeffs,map1,map2)-> None
-
- Computes an undistortion map.
-
-
-
-
-
-
- :param cameraMatrix: The input camera matrix :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param map1: The first output map of type ``CV_32FC1`` or ``CV_16SC2`` - the second variant is more efficient
-
- :type map1: :class:`CvArr`
-
-
- :param map2: The second output map of type ``CV_32FC1`` or ``CV_16UC1`` - the second variant is more efficient
-
- :type map2: :class:`CvArr`
-
-
-
-The function is a simplified variant of
-:ref:`InitUndistortRectifyMap`
-where the rectification transformation
-``R``
-is identity matrix and
-``newCameraMatrix=cameraMatrix``
-.
-
-
-.. index:: InitUndistortRectifyMap
-
-.. _InitUndistortRectifyMap:
-
-InitUndistortRectifyMap
------------------------
-
-`id=0.00679135152837 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/InitUndistortRectifyMap>`__
-
-
-.. function:: InitUndistortRectifyMap(cameraMatrix,distCoeffs,R,newCameraMatrix,map1,map2)-> None
-
- Computes the undistortion and rectification transformation map.
-
-
-
-
-
-
- :param cameraMatrix: The input camera matrix :math:`A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param R: The optional rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :ref:`StereoRectify` can be passed here. If the matrix is NULL , the identity transformation is assumed
-
- :type R: :class:`CvMat`
-
-
- :param newCameraMatrix: The new camera matrix :math:`A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}`
-
- :type newCameraMatrix: :class:`CvMat`
-
-
- :param map1: The first output map of type ``CV_32FC1`` or ``CV_16SC2`` - the second variant is more efficient
-
- :type map1: :class:`CvArr`
-
-
- :param map2: The second output map of type ``CV_32FC1`` or ``CV_16UC1`` - the second variant is more efficient
-
- :type map2: :class:`CvArr`
-
-
-
-The function computes the joint undistortion+rectification transformation and represents the result in the form of maps for
-:ref:`Remap`
-. The undistorted image will look like the original, as if it was captured with a camera with camera matrix
-``=newCameraMatrix``
-and zero distortion. In the case of monocular camera
-``newCameraMatrix``
-is usually equal to
-``cameraMatrix``
-, or it can be computed by
-:ref:`GetOptimalNewCameraMatrix`
-for a better control over scaling. In the case of stereo camera
-``newCameraMatrix``
-is normally set to
-``P1``
-or
-``P2``
-computed by
-:ref:`StereoRectify`
-.
-
-Also, this new camera will be oriented differently in the coordinate space, according to
-``R``
-. That, for example, helps to align two heads of a stereo camera so that the epipolar lines on both images become horizontal and have the same y- coordinate (in the case of horizontally aligned stereo camera).
-
-The function actually builds the maps for the inverse mapping algorithm that is used by
-:ref:`Remap`
-. That is, for each pixel
-:math:`(u, v)`
-in the destination (corrected and rectified) image the function computes the corresponding coordinates in the source image (i.e. in the original image from camera). The process is the following:
-
-
-
-.. math::
-
- \begin{array}{l} x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\{[X\,Y\,W]} ^T \leftarrow R^{-1}*[x \, y \, 1]^T \\ x' \leftarrow X/W \\ y' \leftarrow Y/W \\ x" \leftarrow x' (1 + k_1 r^2 + k_2 r^4 + k_3 r^6) + 2p_1 x' y' + p_2(r^2 + 2 x'^2) \\ y" \leftarrow y' (1 + k_1 r^2 + k_2 r^4 + k_3 r^6) + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' \\ map_x(u,v) \leftarrow x" f_x + c_x \\ map_y(u,v) \leftarrow y" f_y + c_y \end{array}
-
-
-where
-:math:`(k_1, k_2, p_1, p_2[, k_3])`
-are the distortion coefficients.
-
-In the case of a stereo camera this function is called twice, once for each camera head, after
-:ref:`StereoRectify`
-, which in its turn is called after
-:ref:`StereoCalibrate`
-. But if the stereo camera was not calibrated, it is still possible to compute the rectification transformations directly from the fundamental matrix using
-:ref:`StereoRectifyUncalibrated`
-. For each camera the function computes homography
-``H``
-as the rectification transformation in pixel domain, not a rotation matrix
-``R``
-in 3D space. The
-``R``
-can be computed from
-``H``
-as
-
-
-
-.. math::
-
- \texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}
-
-
-where the
-``cameraMatrix``
-can be chosen arbitrarily.
-
-
-.. index:: POSIT
-
-.. _POSIT:
-
-POSIT
------
-
-`id=0.474051901242 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/POSIT>`__
-
-
-.. function:: POSIT(posit_object,imagePoints,focal_length,criteria)-> (rotationMatrix,translation_vector)
-
- Implements the POSIT algorithm.
-
-
-
-
-
-
- :param posit_object: Pointer to the object structure
-
- :type posit_object: :class:`CvPOSITObject`
-
-
- :param imagePoints: Pointer to the object points projections on the 2D image plane
-
- :type imagePoints: :class:`CvPoint2D32f`
-
-
- :param focal_length: Focal length of the camera used
-
- :type focal_length: float
-
-
- :param criteria: Termination criteria of the iterative POSIT algorithm
-
- :type criteria: :class:`CvTermCriteria`
-
-
- :param rotationMatrix: Matrix of rotations
-
- :type rotationMatrix: :class:`CvMatr32f_i`
-
-
- :param translation_vector: Translation vector
-
- :type translation_vector: :class:`CvVect32f_i`
-
-
-
-The function implements the POSIT algorithm. Image coordinates are given in a camera-related coordinate system. The focal length may be retrieved using the camera calibration functions. At every iteration of the algorithm a new perspective projection of the estimated pose is computed.
-
-Difference norm between two projections is the maximal distance between corresponding points. The parameter
-``criteria.epsilon``
-serves to stop the algorithm if the difference is small.
-
-
-.. index:: ProjectPoints2
-
-.. _ProjectPoints2:
-
-ProjectPoints2
---------------
-
-`id=0.754356933502 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/ProjectPoints2>`__
-
-
-.. function:: ProjectPoints2(objectPoints,rvec,tvec,cameraMatrix,distCoeffs, imagePoints,dpdrot=NULL,dpdt=NULL,dpdf=NULL,dpdc=NULL,dpddist=NULL)-> None
-
- Project 3D points on to an image plane.
-
-
-
-
-
-
- :param objectPoints: The array of object points, 3xN or Nx3 1-channel or 1xN or Nx1 3-channel , where N is the number of points in the view
-
- :type objectPoints: :class:`CvMat`
-
-
- :param rvec: The rotation vector, see :ref:`Rodrigues2`
-
- :type rvec: :class:`CvMat`
-
-
- :param tvec: The translation vector
-
- :type tvec: :class:`CvMat`
-
-
- :param cameraMatrix: The camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{_1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param imagePoints: The output array of image points, 2xN or Nx2 1-channel or 1xN or Nx1 2-channel
-
- :type imagePoints: :class:`CvMat`
-
-
- :param dpdrot: Optional 2Nx3 matrix of derivatives of image points with respect to components of the rotation vector
-
- :type dpdrot: :class:`CvMat`
-
-
- :param dpdt: Optional 2Nx3 matrix of derivatives of image points with respect to components of the translation vector
-
- :type dpdt: :class:`CvMat`
-
-
- :param dpdf: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`f_x` and :math:`f_y`
-
- :type dpdf: :class:`CvMat`
-
-
- :param dpdc: Optional 2Nx2 matrix of derivatives of image points with respect to :math:`c_x` and :math:`c_y`
-
- :type dpdc: :class:`CvMat`
-
-
- :param dpddist: Optional 2Nx4 matrix of derivatives of image points with respect to distortion coefficients
-
- :type dpddist: :class:`CvMat`
-
-
-
-The function computes projections of 3D
-points to the image plane given intrinsic and extrinsic camera
-parameters. Optionally, the function computes jacobians - matrices
-of partial derivatives of image points coordinates (as functions of all the
-input parameters) with respect to the particular parameters, intrinsic and/or
-extrinsic. The jacobians are used during the global optimization
-in
-:ref:`CalibrateCamera2`
-,
-:ref:`FindExtrinsicCameraParams2`
-and
-:ref:`StereoCalibrate`
-. The
-function itself can also used to compute re-projection error given the
-current intrinsic and extrinsic parameters.
-
-Note, that by setting
-``rvec=tvec=(0,0,0)``
-, or by setting
-``cameraMatrix``
-to 3x3 identity matrix, or by passing zero distortion coefficients, you can get various useful partial cases of the function, i.e. you can compute the distorted coordinates for a sparse set of points, or apply a perspective transformation (and also compute the derivatives) in the ideal zero-distortion setup etc.
-
-
-
-.. index:: ReprojectImageTo3D
-
-.. _ReprojectImageTo3D:
-
-ReprojectImageTo3D
-------------------
-
-`id=0.392860739717 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/ReprojectImageTo3D>`__
-
-
-.. function:: ReprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues=0) -> None
-
- Reprojects disparity image to 3D space.
-
-
-
-
-
-
- :param disparity: The input single-channel 16-bit signed or 32-bit floating-point disparity image
-
- :type disparity: :class:`CvArr`
-
-
- :param _3dImage: The output 3-channel floating-point image of the same size as ``disparity`` .
- Each element of ``_3dImage(x,y)`` will contain the 3D coordinates of the point ``(x,y)`` , computed from the disparity map.
-
- :type _3dImage: :class:`CvArr`
-
-
- :param Q: The :math:`4 \times 4` perspective transformation matrix that can be obtained with :ref:`StereoRectify`
-
- :type Q: :class:`CvMat`
-
-
- :param handleMissingValues: If true, when the pixels with the minimal disparity (that corresponds to the outliers; see :ref:`FindStereoCorrespondenceBM` ) will be transformed to 3D points with some very large Z value (currently set to 10000)
-
- :type handleMissingValues: int
-
-
-
-The function transforms 1-channel disparity map to 3-channel image representing a 3D surface. That is, for each pixel
-``(x,y)``
-and the corresponding disparity
-``d=disparity(x,y)``
-it computes:
-
-
-
-.. math::
-
- \begin{array}{l} [X \; Y \; Z \; W]^T = \texttt{Q} *[x \; y \; \texttt{disparity} (x,y) \; 1]^T \\ \texttt{\_3dImage} (x,y) = (X/W, \; Y/W, \; Z/W) \end{array}
-
-
-The matrix
-``Q``
-can be arbitrary
-:math:`4 \times 4`
-matrix, e.g. the one computed by
-:ref:`StereoRectify`
-. To reproject a sparse set of points {(x,y,d),...} to 3D space, use
-:ref:`PerspectiveTransform`
-.
-
-
-.. index:: RQDecomp3x3
-
-.. _RQDecomp3x3:
-
-RQDecomp3x3
------------
-
-`id=0.479738869484 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/RQDecomp3x3>`__
-
-
-.. function:: RQDecomp3x3(M, R, Q, Qx = None, Qy = None, Qz = None) -> eulerAngles
-
- Computes the 'RQ' decomposition of 3x3 matrices.
-
-
-
-
-
-
- :param M: The 3x3 input matrix
-
- :type M: :class:`CvMat`
-
-
- :param R: The output 3x3 upper-triangular matrix
-
- :type R: :class:`CvMat`
-
-
- :param Q: The output 3x3 orthogonal matrix
-
- :type Q: :class:`CvMat`
-
-
- :param Qx: Optional 3x3 rotation matrix around x-axis
-
- :type Qx: :class:`CvMat`
-
-
- :param Qy: Optional 3x3 rotation matrix around y-axis
-
- :type Qy: :class:`CvMat`
-
-
- :param Qz: Optional 3x3 rotation matrix around z-axis
-
- :type Qz: :class:`CvMat`
-
-
- :param eulerAngles: Optional three Euler angles of rotation
-
- :type eulerAngles: :class:`CvPoint3D64f`
-
-
-
-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.
-
-It optionally returns three rotation matrices, one for each axis, and the three Euler angles
-that could be used in OpenGL.
-
-
-.. index:: Rodrigues2
-
-.. _Rodrigues2:
-
-Rodrigues2
-----------
-
-`id=0.83168701891 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/Rodrigues2>`__
-
-
-.. function:: Rodrigues2(src,dst,jacobian=0)-> None
-
- Converts a rotation matrix to a rotation vector or vice versa.
-
-
-
-
-
-
- :param src: The input rotation vector (3x1 or 1x3) or rotation matrix (3x3)
-
- :type src: :class:`CvMat`
-
-
- :param dst: The output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively
-
- :type dst: :class:`CvMat`
-
-
- :param jacobian: Optional output Jacobian matrix, 3x9 or 9x3 - partial derivatives of the output array components with respect to the input array components
-
- :type jacobian: :class:`CvMat`
-
-
-
-
-
-.. math::
-
- \begin{array}{l} \theta \leftarrow norm(r) \\ r \leftarrow r/ \theta \\ R = \cos{\theta} I + (1- \cos{\theta} ) r r^T + \sin{\theta} \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}
-
-
-Inverse transformation can also be done easily, since
-
-
-
-.. math::
-
- \sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}
-
-
-A rotation vector is a convenient and most-compact representation of a rotation matrix
-(since any rotation matrix has just 3 degrees of freedom). The representation is
-used in the global 3D geometry optimization procedures like
-:ref:`CalibrateCamera2`
-,
-:ref:`StereoCalibrate`
-or
-:ref:`FindExtrinsicCameraParams2`
-.
-
-
-
-.. index:: StereoCalibrate
-
-.. _StereoCalibrate:
-
-StereoCalibrate
----------------
-
-`id=0.0963893421715 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/StereoCalibrate>`__
-
-
-.. function:: StereoCalibrate( objectPoints, imagePoints1, imagePoints2, pointCounts, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E=NULL, F=NULL, term_crit=(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6), flags=CV_CALIB_FIX_INTRINSIC)-> None
-
- Calibrates stereo camera.
-
-
-
-
-
-
- :param objectPoints: The joint matrix of object points - calibration pattern features in the model coordinate space. It is floating-point 3xN or Nx3 1-channel, or 1xN or Nx1 3-channel array, where N is the total number of points in all views.
-
- :type objectPoints: :class:`CvMat`
-
-
- :param imagePoints1: The joint matrix of object points projections in the first camera views. It is floating-point 2xN or Nx2 1-channel, or 1xN or Nx1 2-channel array, where N is the total number of points in all views
-
- :type imagePoints1: :class:`CvMat`
-
-
- :param imagePoints2: The joint matrix of object points projections in the second camera views. It is floating-point 2xN or Nx2 1-channel, or 1xN or Nx1 2-channel array, where N is the total number of points in all views
-
- :type imagePoints2: :class:`CvMat`
-
-
- :param pointCounts: Integer 1xM or Mx1 vector (where M is the number of calibration pattern views) containing the number of points in each particular view. The sum of vector elements must match the size of ``objectPoints`` and ``imagePoints*`` (=N).
-
- :type pointCounts: :class:`CvMat`
-
-
- :param cameraMatrix1: The input/output first camera matrix: :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` , :math:`j = 0,\, 1` . If any of ``CV_CALIB_USE_INTRINSIC_GUESS`` , ``CV_CALIB_FIX_ASPECT_RATIO`` , ``CV_CALIB_FIX_INTRINSIC`` or ``CV_CALIB_FIX_FOCAL_LENGTH`` are specified, some or all of the matrices' components must be initialized; see the flags description
-
- :type cameraMatrix1: :class:`CvMat`
-
-
- :param distCoeffs: The input/output vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements.
-
-
- :param cameraMatrix2: The input/output second camera matrix, as cameraMatrix1.
-
- :type cameraMatrix2: :class:`CvMat`
-
-
- :param distCoeffs2: The input/output lens distortion coefficients for the second camera, as ``distCoeffs1`` .
-
- :type distCoeffs2: :class:`CvMat`
-
-
- :param imageSize: Size of the image, used only to initialize intrinsic camera matrix.
-
- :type imageSize: :class:`CvSize`
-
-
- :param R: The output rotation matrix between the 1st and the 2nd cameras' coordinate systems.
-
- :type R: :class:`CvMat`
-
-
- :param T: The output translation vector between the cameras' coordinate systems.
-
- :type T: :class:`CvMat`
-
-
- :param E: The optional output essential matrix.
-
- :type E: :class:`CvMat`
-
-
- :param F: The optional output fundamental matrix.
-
- :type F: :class:`CvMat`
-
-
- :param term_crit: The termination criteria for the iterative optimization algorithm.
-
- :type term_crit: :class:`CvTermCriteria`
-
-
- :param flags: Different flags, may be 0 or combination of the following values:
-
- * **CV_CALIB_FIX_INTRINSIC** If it is set, ``cameraMatrix?`` , as well as ``distCoeffs?`` are fixed, so that only ``R, T, E`` and ``F`` are estimated.
-
- * **CV_CALIB_USE_INTRINSIC_GUESS** The flag allows the function to optimize some or all of the intrinsic parameters, depending on the other flags, but the initial values are provided by the user.
-
- * **CV_CALIB_FIX_PRINCIPAL_POINT** The principal points are fixed during the optimization.
-
- * **CV_CALIB_FIX_FOCAL_LENGTH** :math:`f^{(j)}_x` and :math:`f^{(j)}_y` are fixed.
-
- * **CV_CALIB_FIX_ASPECT_RATIO** :math:`f^{(j)}_y` is optimized, but the ratio :math:`f^{(j)}_x/f^{(j)}_y` is fixed.
-
- * **CV_CALIB_SAME_FOCAL_LENGTH** Enforces :math:`f^{(0)}_x=f^{(1)}_x` and :math:`f^{(0)}_y=f^{(1)}_y`
-
- * **CV_CALIB_ZERO_TANGENT_DIST** Tangential distortion coefficients for each camera are set to zeros and fixed there.
-
- * **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** Do not change the corresponding radial distortion coefficient during the optimization. If ``CV_CALIB_USE_INTRINSIC_GUESS`` is set, the coefficient from the supplied ``distCoeffs`` matrix is used, otherwise it is set to 0.
-
- * **CV_CALIB_RATIONAL_MODEL** Enable coefficients k4, k5 and k6. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the rational model and return 8 coefficients. If the flag is not set, the function will compute only 5 distortion coefficients.
-
-
-
- :type flags: int
-
-
-
-The function estimates transformation between the 2 cameras making a stereo pair. If we have a stereo camera, where the relative position and orientation of the 2 cameras is fixed, and if we computed poses of an object relative to the fist camera and to the second camera, (R1, T1) and (R2, T2), respectively (that can be done with
-:ref:`FindExtrinsicCameraParams2`
-), obviously, those poses will relate to each other, i.e. given (
-:math:`R_1`
-,
-:math:`T_1`
-) it should be possible to compute (
-:math:`R_2`
-,
-:math:`T_2`
-) - we only need to know the position and orientation of the 2nd camera relative to the 1st camera. That's what the described function does. It computes (
-:math:`R`
-,
-:math:`T`
-) such that:
-
-
-
-.. math::
-
- R_2=R*R_1
- T_2=R*T_1 + T,
-
-
-Optionally, it computes the essential matrix E:
-
-
-
-.. math::
-
- E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} *R
-
-
-where
-:math:`T_i`
-are components of the translation vector
-:math:`T`
-:
-:math:`T=[T_0, T_1, T_2]^T`
-. And also the function can compute the fundamental matrix F:
-
-
-
-.. math::
-
- F = cameraMatrix2^{-T} E cameraMatrix1^{-1}
-
-
-Besides the stereo-related information, the function can also perform full calibration of each of the 2 cameras. However, because of the high dimensionality of the parameter space and noise in the input data the function can diverge from the correct solution. Thus, if intrinsic parameters can be estimated with high accuracy for each of the cameras individually (e.g. using
-:ref:`CalibrateCamera2`
-), it is recommended to do so and then pass
-``CV_CALIB_FIX_INTRINSIC``
-flag to the function along with the computed intrinsic parameters. Otherwise, if all the parameters are estimated at once, it makes sense to restrict some parameters, e.g. pass
-``CV_CALIB_SAME_FOCAL_LENGTH``
-and
-``CV_CALIB_ZERO_TANGENT_DIST``
-flags, which are usually reasonable assumptions.
-
-Similarly to
-:ref:`CalibrateCamera2`
-, the function minimizes the total re-projection error for all the points in all the available views from both cameras.
-
-.. index:: StereoRectify
-
-.. _StereoRectify:
-
-StereoRectify
--------------
-
-`id=0.482375127425 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/StereoRectify>`__
-
-
-.. function:: StereoRectify( cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q=NULL, flags=CV_CALIB_ZERO_DISPARITY, alpha=-1, newImageSize=(0,0))-> (roi1, roi2)
-
- Computes rectification transforms for each head of a calibrated stereo camera.
-
-
-
-
-
-
- :param cameraMatrix1, cameraMatrix2: The camera matrices :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` .
-
-
- :param distCoeffs: The input vectors of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements each. If the vectors are NULL/empty, the zero distortion coefficients are assumed.
-
-
- :param imageSize: Size of the image used for stereo calibration.
-
- :type imageSize: :class:`CvSize`
-
-
- :param R: The rotation matrix between the 1st and the 2nd cameras' coordinate systems.
-
- :type R: :class:`CvMat`
-
-
- :param T: The translation vector between the cameras' coordinate systems.
-
- :type T: :class:`CvMat`
-
-
- :param R1, R2: The output :math:`3 \times 3` rectification transforms (rotation matrices) for the first and the second cameras, respectively.
-
-
- :param P1, P2: The output :math:`3 \times 4` projection matrices in the new (rectified) coordinate systems.
-
-
- :param Q: The output :math:`4 \times 4` disparity-to-depth mapping matrix, see :func:`reprojectImageTo3D` .
-
- :type Q: :class:`CvMat`
-
-
- :param flags: The operation flags; may be 0 or ``CV_CALIB_ZERO_DISPARITY`` . If the flag is set, the function makes the principal points of each camera have the same pixel coordinates in the rectified views. And if the flag is not set, the function may still shift the images in horizontal or vertical direction (depending on the orientation of epipolar lines) in order to maximize the useful image area.
-
- :type flags: int
-
-
- :param alpha: The free scaling parameter. If it is -1 , the functions performs some default scaling. Otherwise the parameter should be between 0 and 1. ``alpha=0`` means that the rectified images will be zoomed and shifted so that only valid pixels are visible (i.e. there will be no black areas after rectification). ``alpha=1`` means that the rectified image will be decimated and shifted so that all the pixels from the original images from the cameras are retained in the rectified images, i.e. no source image pixels are lost. Obviously, any intermediate value yields some intermediate result between those two extreme cases.
-
- :type alpha: float
-
-
- :param newImageSize: The new image resolution after rectification. The same size should be passed to :ref:`InitUndistortRectifyMap` , see the ``stereo_calib.cpp`` sample in OpenCV samples directory. By default, i.e. when (0,0) is passed, it is set to the original ``imageSize`` . Setting it to larger value can help you to preserve details in the original image, especially when there is big radial distortion.
-
- :type newImageSize: :class:`CvSize`
-
-
- :param roi1, roi2: The optional output rectangles inside the rectified images where all the pixels are valid. If ``alpha=0`` , the ROIs will cover the whole images, otherwise they likely be smaller, see the picture below
-
-
-
-The function computes the rotation matrices for each camera that (virtually) make both camera image planes the same plane. Consequently, that makes all the epipolar lines parallel and thus simplifies the dense stereo correspondence problem. On input the function takes the matrices computed by
-:func:`stereoCalibrate`
-and on output it gives 2 rotation matrices and also 2 projection matrices in the new coordinates. The 2 cases are distinguished by the function are:
-
-
-
-
-
-#.
- Horizontal stereo, when 1st and 2nd camera views are shifted relative to each other mainly along the x axis (with possible small vertical shift). Then in the rectified images the corresponding epipolar lines in left and right cameras will be horizontal and have the same y-coordinate. P1 and P2 will look as:
-
-
-
- .. math::
-
- \texttt{P1} = \begin{bmatrix} f & 0 & cx_1 & 0 \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}
-
-
-
-
- .. math::
-
- \texttt{P2} = \begin{bmatrix} f & 0 & cx_2 & T_x*f \\ 0 & f & cy & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} ,
-
-
- where
- :math:`T_x`
- is horizontal shift between the cameras and
- :math:`cx_1=cx_2`
- if
- ``CV_CALIB_ZERO_DISPARITY``
- is set.
-
-
-#.
- Vertical stereo, when 1st and 2nd camera views are shifted relative to each other mainly in vertical direction (and probably a bit in the horizontal direction too). Then the epipolar lines in the rectified images will be vertical and have the same x coordinate. P2 and P2 will look as:
-
-
-
- .. math::
-
- \texttt{P1} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_1 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix}
-
-
-
-
- .. math::
-
- \texttt{P2} = \begin{bmatrix} f & 0 & cx & 0 \\ 0 & f & cy_2 & T_y*f \\ 0 & 0 & 1 & 0 \end{bmatrix} ,
-
-
- where
- :math:`T_y`
- is vertical shift between the cameras and
- :math:`cy_1=cy_2`
- if
- ``CALIB_ZERO_DISPARITY``
- is set.
-
-
-As you can see, the first 3 columns of
-``P1``
-and
-``P2``
-will effectively be the new "rectified" camera matrices.
-The matrices, together with
-``R1``
-and
-``R2``
-, can then be passed to
-:ref:`InitUndistortRectifyMap`
-to initialize the rectification map for each camera.
-
-Below is the screenshot from
-``stereo_calib.cpp``
-sample. Some red horizontal lines, as you can see, pass through the corresponding image regions, i.e. the images are well rectified (which is what most stereo correspondence algorithms rely on). The green rectangles are
-``roi1``
-and
-``roi2``
-- indeed, their interior are all valid pixels.
-
-
-
-.. image:: ../pics/stereo_undistort.jpg
-
-
-
-
-.. index:: StereoRectifyUncalibrated
-
-.. _StereoRectifyUncalibrated:
-
-StereoRectifyUncalibrated
--------------------------
-
-`id=0.234617492311 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/StereoRectifyUncalibrated>`__
-
-
-.. function:: StereoRectifyUncalibrated(points1,points2,F,imageSize,H1,H2,threshold=5)-> None
-
- Computes rectification transform for uncalibrated stereo camera.
-
-
-
-
-
-
- :param points1, points2: The 2 arrays of corresponding 2D points. The same formats as in :ref:`FindFundamentalMat` are supported
-
-
- :param F: The input fundamental matrix. It can be computed from the same set of point pairs using :ref:`FindFundamentalMat` .
-
- :type F: :class:`CvMat`
-
-
- :param imageSize: Size of the image.
-
- :type imageSize: :class:`CvSize`
-
-
- :param H1, H2: The output rectification homography matrices for the first and for the second images.
-
-
- :param threshold: The optional threshold used to filter out the outliers. If the parameter is greater than zero, then all the point pairs that do not comply the epipolar geometry well enough (that is, the points for which :math:`|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}` ) are rejected prior to computing the homographies.
- Otherwise all the points are considered inliers.
-
- :type threshold: float
-
-
-
-The function computes the rectification transformations without knowing intrinsic parameters of the cameras and their relative position in space, hence the suffix "Uncalibrated". Another related difference from
-:ref:`StereoRectify`
-is that the function outputs not the rectification transformations in the object (3D) space, but the planar perspective transformations, encoded by the homography matrices
-``H1``
-and
-``H2``
-. The function implements the algorithm
-Hartley99
-.
-
-Note that while the algorithm does not need to know the intrinsic parameters of the cameras, it heavily depends on the epipolar geometry. Therefore, if the camera lenses have significant distortion, it would better be corrected before computing the fundamental matrix and calling this function. For example, distortion coefficients can be estimated for each head of stereo camera separately by using
-:ref:`CalibrateCamera2`
-and then the images can be corrected using
-:ref:`Undistort2`
-, or just the point coordinates can be corrected with
-:ref:`UndistortPoints`
-.
-
-
-
-.. index:: Undistort2
-
-.. _Undistort2:
-
-Undistort2
-----------
-
-`id=0.0228781107726 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/Undistort2>`__
-
-
-.. function:: Undistort2(src,dst,cameraMatrix,distCoeffs)-> None
-
- Transforms an image to compensate for lens distortion.
-
-
-
-
-
-
- :param src: The input (distorted) image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The output (corrected) image; will have the same size and the same type as ``src``
-
- :type dst: :class:`CvArr`
-
-
- :param cameraMatrix: The input camera matrix :math:`A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
-
-The function transforms the image to compensate radial and tangential lens distortion.
-
-The function is simply a combination of
-:ref:`InitUndistortRectifyMap`
-(with unity
-``R``
-) and
-:ref:`Remap`
-(with bilinear interpolation). See the former function for details of the transformation being performed.
-
-Those pixels in the destination image, for which there is no correspondent pixels in the source image, are filled with 0's (black color).
-
-The particular subset of the source image that will be visible in the corrected image can be regulated by
-``newCameraMatrix``
-. You can use
-:ref:`GetOptimalNewCameraMatrix`
-to compute the appropriate
-``newCameraMatrix``
-, depending on your requirements.
-
-The camera matrix and the distortion parameters can be determined using
-:ref:`CalibrateCamera2`
-. If the resolution of images is different from the used at the calibration stage,
-:math:`f_x, f_y, c_x`
-and
-:math:`c_y`
-need to be scaled accordingly, while the distortion coefficients remain the same.
-
-
-
-.. index:: UndistortPoints
-
-.. _UndistortPoints:
-
-UndistortPoints
----------------
-
-`id=0.00872451686413 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/calib3d/UndistortPoints>`__
-
-
-.. function:: UndistortPoints(src,dst,cameraMatrix,distCoeffs,R=NULL,P=NULL)-> None
-
- Computes the ideal point coordinates from the observed point coordinates.
-
-
-
-
-
-
- :param src: The observed point coordinates, 1xN or Nx1 2-channel (CV _ 32FC2 or CV _ 64FC2).
-
- :type src: :class:`CvMat`
-
-
- :param dst: The output ideal point coordinates, after undistortion and reverse perspective transformation , same format as ``src`` .
-
- :type dst: :class:`CvMat`
-
-
- :param cameraMatrix: The camera matrix :math:`\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}`
-
- :type cameraMatrix: :class:`CvMat`
-
-
- :param distCoeffs: The input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5 or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
-
- :type distCoeffs: :class:`CvMat`
-
-
- :param R: The rectification transformation in object space (3x3 matrix). ``R1`` or ``R2`` , computed by :func:`StereoRectify` can be passed here. If the matrix is empty, the identity transformation is used
-
- :type R: :class:`CvMat`
-
-
- :param P: The new camera matrix (3x3) or the new projection matrix (3x4). ``P1`` or ``P2`` , computed by :func:`StereoRectify` can be passed here. If the matrix is empty, the identity new camera matrix is used
-
- :type P: :class:`CvMat`
-
-
-
-The function is similar to
-:ref:`Undistort2`
-and
-:ref:`InitUndistortRectifyMap`
-, but it operates on a sparse set of points instead of a raster image. Also the function does some kind of reverse transformation to
-:ref:`ProjectPoints2`
-(in the case of 3D object it will not reconstruct its 3D coordinates, of course; but for a planar object it will, up to a translation vector, if the proper
-``R``
-is specified).
-
-
-
-
-::
-
-
-
- // (u,v) is the input point, (u', v') is the output point
- // camera_matrix=[fx 0 cx; 0 fy cy; 0 0 1]
- // P=[fx' 0 cx' tx; 0 fy' cy' ty; 0 0 1 tz]
- x" = (u - cx)/fx
- y" = (v - cy)/fy
- (x',y') = undistort(x",y",dist_coeffs)
- [X,Y,W]T = R*[x' y' 1]T
- x = X/W, y = Y/W
- u' = x*fx' + cx'
- v' = y*fy' + cy',
-
-
-..
-
-where undistort() is approximate iterative algorithm that estimates the normalized original point coordinates out of the normalized distorted point coordinates ("normalized" means that the coordinates do not depend on the camera matrix).
-
-The function can be used both for a stereo camera head or for monocular camera (when R is
-None
-).
+++ /dev/null
-# -*- coding: utf-8 -*-
-#
-# opencv documentation build configuration file, created by
-# sphinx-quickstart on Thu Jun 4 21:06:43 2009.
-#
-# This file is execfile()d with the current directory set to its containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import sys, os
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.append(os.path.abspath('.'))
-
-# -- General configuration -----------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be extensions
-# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.pngmath', 'sphinx.ext.doctest'] # , 'sphinx.ext.intersphinx']
-doctest_test_doctest_blocks = 'block'
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix of source filenames.
-source_suffix = '.rst'
-
-# The encoding of source files.
-#source_encoding = 'utf-8'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'opencv'
-copyright = u'2010, authors'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '2.2'
-# The full version, including alpha/beta/rc tags.
-release = '2.2.9'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of documents that shouldn't be included in the build.
-#unused_docs = []
-
-# List of directories, relative to source directory, that shouldn't be searched
-# for source files.
-exclude_trees = ['_build']
-
-# The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-
-# -- Options for HTML output ---------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages. Major themes that come with
-# Sphinx are currently 'default' and 'sphinxdoc'.
-html_theme = 'blue'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further. For a list of options available for each theme, see the
-# documentation.
-html_theme_options = {
- "lang" : "%LANG%" # buildall substitutes this for c, cpp, py
-}
-
-# Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ['../_themes']
-
-# The name for this set of Sphinx documents. If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar. Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-html_logo = '../opencv-logo2.png'
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['../_static']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_use_modindex = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it. The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = ''
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'opencvdoc'
-
-
-# -- Options for LaTeX output --------------------------------------------------
-
-# The paper size ('letter' or 'a4').
-#latex_paper_size = 'letter'
-
-# The font size ('10pt', '11pt' or '12pt').
-#latex_font_size = '10pt'
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, documentclass [howto/manual]).
-latex_documents = [
- ('index', 'opencv.tex', u'opencv Documentation',
- u'author', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_use_modindex = True
-
-pngmath_latex_preamble = '\usepackage{mymath}\usepackage{amsmath}\usepackage{bbm}\usepackage[usenames]{color}'
-
-# intersphinx_mapping = {
-# 'http://docs.python.org/': None,
-# }
-intersphinx_mapping = {}
-
-latex_elements = {'preamble': '\usepackage{mymath}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}'}
+++ /dev/null
-Cookbook
-========
-
-.. highlight:: python
-
-
-Here is a collection of code fragments demonstrating some features
-of the OpenCV Python bindings.
-
-
-Convert an image
-----------------
-
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> im = cv.LoadImageM("building.jpg")
- >>> print type(im)
- <type 'cv.cvmat'>
- >>> cv.SaveImage("foo.png", im)
-
-
-..
-
-
-Resize an image
----------------
-
-
-To resize an image in OpenCV, create a destination image of the appropriate size, then call
-:ref:`Resize`
-.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> original = cv.LoadImageM("building.jpg")
- >>> thumbnail = cv.CreateMat(original.rows / 10, original.cols / 10, cv.CV_8UC3)
- >>> cv.Resize(original, thumbnail)
-
-
-..
-
-
-Compute the Laplacian
----------------------
-
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> im = cv.LoadImageM("building.jpg", 1)
- >>> dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 3)
- >>> laplace = cv.Laplace(im, dst)
- >>> cv.SaveImage("foo-laplace.png", dst)
-
-
-..
-
-
-Using GoodFeaturesToTrack
--------------------------
-
-
-To find the 10 strongest corner features in an image, use
-:ref:`GoodFeaturesToTrack`
-like this:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> img = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
- >>> eig_image = cv.CreateMat(img.rows, img.cols, cv.CV_32FC1)
- >>> temp_image = cv.CreateMat(img.rows, img.cols, cv.CV_32FC1)
- >>> for (x,y) in cv.GoodFeaturesToTrack(img, eig_image, temp_image, 10, 0.04, 1.0, useHarris = True):
- ... print "good feature at", x,y
- good feature at 198.0 514.0
- good feature at 791.0 260.0
- good feature at 370.0 467.0
- good feature at 374.0 469.0
- good feature at 490.0 520.0
- good feature at 262.0 278.0
- good feature at 781.0 134.0
- good feature at 3.0 247.0
- good feature at 667.0 321.0
- good feature at 764.0 304.0
-
-
-..
-
-
-Using GetSubRect
-----------------
-
-
-GetSubRect returns a rectangular part of another image. It does this without copying any data.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> img = cv.LoadImageM("building.jpg")
- >>> sub = cv.GetSubRect(img, (60, 70, 32, 32)) # sub is 32x32 patch within img
- >>> cv.SetZero(sub) # clear sub to zero, which also clears 32x32 pixels in img
-
-
-..
-
-
-Using CreateMat, and accessing an element
------------------------------------------
-
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> mat = cv.CreateMat(5, 5, cv.CV_32FC1)
- >>> cv.Set(mat, 1.0)
- >>> mat[3,1] += 0.375
- >>> print mat[3,1]
- 1.375
- >>> print [mat[3,i] for i in range(5)]
- [1.0, 1.375, 1.0, 1.0, 1.0]
-
-
-..
-
-
-ROS image message to OpenCV
----------------------------
-
-
-See this tutorial:
-`Using CvBridge to convert between ROS images And OpenCV images <http://www.ros.org/wiki/cv_bridge/Tutorials/UsingCvBridgeToConvertBetweenROSImagesAndOpenCVImages>`_
-.
-
-
-PIL Image to OpenCV
--------------------
-
-
-(For details on PIL see the
-`PIL handbook <http://www.pythonware.com/library/pil/handbook/image.htm>`_
-.)
-
-
-
-
-.. doctest::
-
-
-
- >>> import Image, cv
- >>> pi = Image.open('building.jpg') # PIL image
- >>> cv_im = cv.CreateImageHeader(pi.size, cv.IPL_DEPTH_8U, 3)
- >>> cv.SetData(cv_im, pi.tostring())
- >>> print pi.size, cv.GetSize(cv_im)
- (868, 600) (868, 600)
- >>> print pi.tostring() == cv_im.tostring()
- True
-
-
-..
-
-
-OpenCV to PIL Image
--------------------
-
-
-
-
-
-.. doctest::
-
-
-
- >>> import Image, cv
- >>> cv_im = cv.CreateImage((320,200), cv.IPL_DEPTH_8U, 1)
- >>> pi = Image.fromstring("L", cv.GetSize(cv_im), cv_im.tostring())
- >>> print pi.size
- (320, 200)
-
-
-..
-
-
-NumPy and OpenCV
-----------------
-
-
-Using the
-`array interface <http://docs.scipy.org/doc/numpy/reference/arrays.interface.html>`_
-, to use an OpenCV CvMat in NumPy:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv, numpy
- >>> mat = cv.CreateMat(3, 5, cv.CV_32FC1)
- >>> cv.Set(mat, 7)
- >>> a = numpy.asarray(mat)
- >>> print a
- [[ 7. 7. 7. 7. 7.]
- [ 7. 7. 7. 7. 7.]
- [ 7. 7. 7. 7. 7.]]
-
-
-..
-
-and to use a NumPy array in OpenCV:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv, numpy
- >>> a = numpy.ones((480, 640))
- >>> mat = cv.fromarray(a)
- >>> print mat.rows
- 480
- >>> print mat.cols
- 640
-
-
-..
-
-also, most OpenCV functions can work on NumPy arrays directly, for example:
-
-
-
-
-.. doctest::
-
-
-
- >>> picture = numpy.ones((640, 480))
- >>> cv.Smooth(picture, picture, cv.CV_GAUSSIAN, 15, 15)
-
-
-..
-
-Given a 2D array,
-the
-:ref:`fromarray`
-function (or the implicit version shown above)
-returns a single-channel
-:ref:`CvMat`
-of the same size.
-For a 3D array of size
-:math:`j \times k \times l`
-, it returns a
-:ref:`CvMat`
-sized
-:math:`j \times k`
-with
-:math:`l`
-channels.
-
-Alternatively, use
-:ref:`fromarray`
-with the
-``allowND``
-option to always return a
-:ref:`cvMatND`
-.
-
-
-OpenCV to pygame
-----------------
-
-
-To convert an OpenCV image to a
-`pygame <http://www.pygame.org/>`_
-surface:
-
-
-
-
-.. doctest::
-
-
-
- >>> import pygame.image, cv
- >>> src = cv.LoadImage("lena.jpg")
- >>> src_rgb = cv.CreateMat(src.height, src.width, cv.CV_8UC3)
- >>> cv.CvtColor(src, src_rgb, cv.CV_BGR2RGB)
- >>> pg_img = pygame.image.frombuffer(src_rgb.tostring(), cv.GetSize(src_rgb), "RGB")
- >>> print pg_img
- <Surface(512x512x24 SW)>
-
-
-..
-
-
-OpenCV and OpenEXR
-------------------
-
-
-Using
-`OpenEXR's Python bindings <http://www.excamera.com/sphinx/articles-openexr.html>`_
-you can make a simple
-image viewer:
-
-
-
-
-::
-
-
-
- import OpenEXR, Imath, cv
- filename = "GoldenGate.exr"
- exrimage = OpenEXR.InputFile(filename)
-
- dw = exrimage.header()['dataWindow']
- (width, height) = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1)
-
- def fromstr(s):
- mat = cv.CreateMat(height, width, cv.CV_32FC1)
- cv.SetData(mat, s)
- return mat
-
- pt = Imath.PixelType(Imath.PixelType.FLOAT)
- (r, g, b) = [fromstr(s) for s in exrimage.channels("RGB", pt)]
-
- bgr = cv.CreateMat(height, width, cv.CV_32FC3)
- cv.Merge(b, g, r, None, bgr)
-
- cv.ShowImage(filename, bgr)
- cv.WaitKey()
-
-
-..
-
+++ /dev/null
-****************************
-core. The Core Functionality
-****************************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- core_basic_structures
- core_operations_on_arrays
- core_dynamic_structures
- core_drawing_functions
- core_xml_yaml_persistence
- core_clustering
- core_utility_and_system_functions_and_macros
+++ /dev/null
-Basic Structures
-================
-
-.. highlight:: python
-
-
-
-.. index:: CvPoint
-
-.. _CvPoint:
-
-CvPoint
--------
-
-`id=0.407060643954 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvPoint>`__
-
-.. class:: CvPoint
-
-
-
-2D point with integer coordinates (usually zero-based).
-
-2D point, represented as a tuple
-``(x, y)``
-, where x and y are integers.
-
-.. index:: CvPoint2D32f
-
-.. _CvPoint2D32f:
-
-CvPoint2D32f
-------------
-
-`id=0.638091190655 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvPoint2D32f>`__
-
-.. class:: CvPoint2D32f
-
-
-
-2D point with floating-point coordinates
-
-2D point, represented as a tuple
-``(x, y)``
-, where x and y are floats.
-
-.. index:: CvPoint3D32f
-
-.. _CvPoint3D32f:
-
-CvPoint3D32f
-------------
-
-`id=0.334583364495 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvPoint3D32f>`__
-
-.. class:: CvPoint3D32f
-
-
-
-3D point with floating-point coordinates
-
-3D point, represented as a tuple
-``(x, y, z)``
-, where x, y and z are floats.
-
-.. index:: CvPoint2D64f
-
-.. _CvPoint2D64f:
-
-CvPoint2D64f
-------------
-
-`id=0.352962148614 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvPoint2D64f>`__
-
-.. class:: CvPoint2D64f
-
-
-
-2D point with double precision floating-point coordinates
-
-2D point, represented as a tuple
-``(x, y)``
-, where x and y are floats.
-
-.. index:: CvPoint3D64f
-
-.. _CvPoint3D64f:
-
-CvPoint3D64f
-------------
-
-`id=0.00812295344272 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvPoint3D64f>`__
-
-.. class:: CvPoint3D64f
-
-
-
-3D point with double precision floating-point coordinates
-
-3D point, represented as a tuple
-``(x, y, z)``
-, where x, y and z are floats.
-
-.. index:: CvSize
-
-.. _CvSize:
-
-CvSize
-------
-
-`id=0.980418044509 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvSize>`__
-
-.. class:: CvSize
-
-
-
-Pixel-accurate size of a rectangle.
-
-Size of a rectangle, represented as a tuple
-``(width, height)``
-, where width and height are integers.
-
-.. index:: CvSize2D32f
-
-.. _CvSize2D32f:
-
-CvSize2D32f
------------
-
-`id=0.623013904609 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvSize2D32f>`__
-
-.. class:: CvSize2D32f
-
-
-
-Sub-pixel accurate size of a rectangle.
-
-Size of a rectangle, represented as a tuple
-``(width, height)``
-, where width and height are floats.
-
-.. index:: CvRect
-
-.. _CvRect:
-
-CvRect
-------
-
-`id=0.706717090055 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvRect>`__
-
-.. class:: CvRect
-
-
-
-Offset (usually the top-left corner) and size of a rectangle.
-
-Rectangle, represented as a tuple
-``(x, y, width, height)``
-, where all are integers.
-
-.. index:: CvScalar
-
-.. _CvScalar:
-
-CvScalar
---------
-
-`id=0.733448405451 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvScalar>`__
-
-.. class:: CvScalar
-
-
-
-A container for 1-,2-,3- or 4-tuples of doubles.
-
-CvScalar is always represented as a 4-tuple.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> cv.Scalar(1, 2, 3, 4)
- (1.0, 2.0, 3.0, 4.0)
- >>> cv.ScalarAll(7)
- (7.0, 7.0, 7.0, 7.0)
- >>> cv.RealScalar(7)
- (7.0, 0.0, 0.0, 0.0)
- >>> cv.RGB(17, 110, 255)
- (255.0, 110.0, 17.0, 0.0)
-
-
-..
-
-
-.. index:: CvTermCriteria
-
-.. _CvTermCriteria:
-
-CvTermCriteria
---------------
-
-`id=0.996691519996 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvTermCriteria>`__
-
-.. class:: CvTermCriteria
-
-
-
-Termination criteria for iterative algorithms.
-
-Represented by a tuple
-``(type, max_iter, epsilon)``
-.
-
-
-
-
-
- .. attribute:: type
-
-
-
- ``CV_TERMCRIT_ITER`` , ``CV_TERMCRIT_EPS`` or ``CV_TERMCRIT_ITER | CV_TERMCRIT_EPS``
-
-
-
- .. attribute:: max_iter
-
-
-
- Maximum number of iterations
-
-
-
- .. attribute:: epsilon
-
-
-
- Required accuracy
-
-
-
-
-
-
-::
-
-
-
- (cv.CV_TERMCRIT_ITER, 10, 0) # terminate after 10 iterations
- (cv.CV_TERMCRIT_EPS, 0, 0.01) # terminate when epsilon reaches 0.01
- (cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 10, 0.01) # terminate as soon as either condition is met
-
-
-..
-
-
-.. index:: CvMat
-
-.. _CvMat:
-
-CvMat
------
-
-`id=0.619633266675 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvMat>`__
-
-.. class:: CvMat
-
-
-
-A multi-channel 2D matrix. Created by
-:ref:`CreateMat`
-,
-:ref:`LoadImageM`
-,
-:ref:`CreateMatHeader`
-,
-:ref:`fromarray`
-.
-
-
-
-
-
- .. attribute:: type
-
-
-
- A CvMat signature containing the type of elements and flags, int
-
-
-
- .. attribute:: step
-
-
-
- Full row length in bytes, int
-
-
-
- .. attribute:: rows
-
-
-
- Number of rows, int
-
-
-
- .. attribute:: cols
-
-
-
- Number of columns, int
-
-
-
- .. method:: tostring() -> str
-
-
-
- Returns the contents of the CvMat as a single string.
-
-
-
-
-.. index:: CvMatND
-
-.. _CvMatND:
-
-CvMatND
--------
-
-`id=0.493284398358 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvMatND>`__
-
-.. class:: CvMatND
-
-
-
-Multi-dimensional dense multi-channel array.
-
-
-
-
-
- .. attribute:: type
-
-
-
- A CvMatND signature combining the type of elements and flags, int
-
-
-
- .. method:: tostring() -> str
-
-
-
- Returns the contents of the CvMatND as a single string.
-
-
-
-
-.. index:: IplImage
-
-.. _IplImage:
-
-IplImage
---------
-
-`id=0.479556472461 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/IplImage>`__
-
-.. class:: IplImage
-
-
-
-The
-:ref:`IplImage`
-object was inherited from the Intel Image Processing
-Library, in which the format is native. OpenCV only supports a subset
-of possible
-:ref:`IplImage`
-formats.
-
-
-
-
-
- .. attribute:: nChannels
-
-
-
- Number of channels, int.
-
-
-
- .. attribute:: width
-
-
-
- Image width in pixels
-
-
-
- .. attribute:: height
-
-
-
- Image height in pixels
-
-
-
- .. attribute:: depth
-
-
-
- Pixel depth in bits. The supported depths are:
-
-
- .. attribute:: IPL_DEPTH_8U
-
-
-
- Unsigned 8-bit integer
-
-
- .. attribute:: IPL_DEPTH_8S
-
-
-
- Signed 8-bit integer
-
-
- .. attribute:: IPL_DEPTH_16U
-
-
-
- Unsigned 16-bit integer
-
-
- .. attribute:: IPL_DEPTH_16S
-
-
-
- Signed 16-bit integer
-
-
- .. attribute:: IPL_DEPTH_32S
-
-
-
- Signed 32-bit integer
-
-
- .. attribute:: IPL_DEPTH_32F
-
-
-
- Single-precision floating point
-
-
- .. attribute:: IPL_DEPTH_64F
-
-
-
- Double-precision floating point
-
-
-
-
-
- .. attribute:: origin
-
-
-
- 0 - top-left origin, 1 - bottom-left origin (Windows bitmap style)
-
-
-
- .. method:: tostring() -> str
-
-
-
- Returns the contents of the CvMatND as a single string.
-
-
-
-
-.. index:: CvArr
-
-.. _CvArr:
-
-CvArr
------
-
-`id=0.249942454209 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvArr>`__
-
-.. class:: CvArr
-
-
-
-Arbitrary array
-
-``CvArr``
-is used
-*only*
-as a function parameter to specify that the parameter can be:
-
-
-
-
-* an :ref:`IplImage`
-
-
-* a :ref:`CvMat`
-
-
-* any other type that exports the `array interface <http://docs.scipy.org/doc/numpy/reference/arrays.interface.html>`_
-
-
+++ /dev/null
-Clustering
-==========
-
-.. highlight:: python
-
-
-
-.. index:: KMeans2
-
-.. _KMeans2:
-
-KMeans2
--------
-
-`id=0.682106387651 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/KMeans2>`__
-
-
-.. function:: KMeans2(samples,nclusters,labels,termcrit)-> None
-
- Splits set of vectors by a given number of clusters.
-
-
-
-
-
-
- :param samples: Floating-point matrix of input samples, one row per sample
-
- :type samples: :class:`CvArr`
-
-
- :param nclusters: Number of clusters to split the set by
-
- :type nclusters: int
-
-
- :param labels: Output integer vector storing cluster indices for every sample
-
- :type labels: :class:`CvArr`
-
-
- :param termcrit: Specifies maximum number of iterations and/or accuracy (distance the centers can move by between subsequent iterations)
-
- :type termcrit: :class:`CvTermCriteria`
-
-
-
-The function
-``cvKMeans2``
-implements a k-means algorithm that finds the
-centers of
-``nclusters``
-clusters and groups the input samples
-around the clusters. On output,
-:math:`\texttt{labels}_i`
-contains a cluster index for
-samples stored in the i-th row of the
-``samples``
-matrix.
-
+++ /dev/null
-Drawing Functions
-=================
-
-.. highlight:: python
-
-
-Drawing functions work with matrices/images of arbitrary depth.
-The boundaries of the shapes can be rendered with antialiasing (implemented only for 8-bit images for now).
-All the functions include the parameter color that uses a rgb value (that may be constructed
-with
-``CV_RGB``
-) for color
-images and brightness for grayscale images. For color images the order channel
-is normally
-*Blue, Green, Red*
-, this is what
-:func:`imshow`
-,
-:func:`imread`
-and
-:func:`imwrite`
-expect
-If you are using your own image rendering and I/O functions, you can use any channel ordering, the drawing functions process each channel independently and do not depend on the channel order or even on the color space used. The whole image can be converted from BGR to RGB or to a different color space using
-:func:`cvtColor`
-.
-
-If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also, many drawing functions can handle pixel coordinates specified with sub-pixel accuracy, that is, the coordinates can be passed as fixed-point numbers, encoded as integers. The number of fractional bits is specified by the
-``shift``
-parameter and the real point coordinates are calculated as
-:math:`\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})`
-. This feature is especially effective wehn rendering antialiased shapes.
-
-Also, note that the functions do not support alpha-transparency - when the target image is 4-channnel, then the
-``color[3]``
-is simply copied to the repainted pixels. Thus, if you want to paint semi-transparent shapes, you can paint them in a separate buffer and then blend it with the main image.
-
-
-.. index:: Circle
-
-.. _Circle:
-
-Circle
-------
-
-`id=0.300689351141 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Circle>`__
-
-
-.. function:: Circle(img,center,radius,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws a circle.
-
-
-
-
-
-
- :param img: Image where the circle is drawn
-
- :type img: :class:`CvArr`
-
-
- :param center: Center of the circle
-
- :type center: :class:`CvPoint`
-
-
- :param radius: Radius of the circle
-
- :type radius: int
-
-
- :param color: Circle color
-
- :type color: :class:`CvScalar`
-
-
- :param thickness: Thickness of the circle outline if positive, otherwise this indicates that a filled circle is to be drawn
-
- :type thickness: int
-
-
- :param lineType: Type of the circle boundary, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the center coordinates and radius value
-
- :type shift: int
-
-
-
-The function draws a simple or filled circle with a
-given center and radius.
-
-
-.. index:: ClipLine
-
-.. _ClipLine:
-
-ClipLine
---------
-
-`id=0.251101842576 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ClipLine>`__
-
-
-.. function:: ClipLine(imgSize, pt1, pt2) -> (clipped_pt1, clipped_pt2)
-
- Clips the line against the image rectangle.
-
-
-
-
-
-
- :param imgSize: Size of the image
-
- :type imgSize: :class:`CvSize`
-
-
- :param pt1: First ending point of the line segment.
-
- :type pt1: :class:`CvPoint`
-
-
- :param pt2: Second ending point of the line segment.
-
- :type pt2: :class:`CvPoint`
-
-
-
-The function calculates a part of the line segment which is entirely within the image.
-If the line segment is outside the image, it returns None. If the line segment is inside the image it returns a new pair of points.
-
-.. index:: DrawContours
-
-.. _DrawContours:
-
-DrawContours
-------------
-
-`id=0.919530584794 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/DrawContours>`__
-
-
-.. function:: DrawContours(img,contour,external_color,hole_color,max_level,thickness=1,lineType=8,offset=(0,0))-> None
-
- Draws contour outlines or interiors in an image.
-
-
-
-
-
-
- :param img: Image where the contours are to be drawn. As with any other drawing function, the contours are clipped with the ROI.
-
- :type img: :class:`CvArr`
-
-
- :param contour: Pointer to the first contour
-
- :type contour: :class:`CvSeq`
-
-
- :param external_color: Color of the external contours
-
- :type external_color: :class:`CvScalar`
-
-
- :param hole_color: Color of internal contours (holes)
-
- :type hole_color: :class:`CvScalar`
-
-
- :param max_level: Maximal level for drawn contours. If 0, only ``contour`` is drawn. If 1, the contour and all contours following
- it on the same level are drawn. If 2, all contours following and all
- contours one level below the contours are drawn, and so forth. If the value
- is negative, the function does not draw the contours following after ``contour`` but draws the child contours of ``contour`` up
- to the :math:`|\texttt{max\_level}|-1` level.
-
- :type max_level: int
-
-
- :param thickness: Thickness of lines the contours are drawn with.
- If it is negative (For example, =CV _ FILLED), the contour interiors are
- drawn.
-
- :type thickness: int
-
-
- :param lineType: Type of the contour segments, see :ref:`Line` description
-
- :type lineType: int
-
-
-
-The function draws contour outlines in the image if
-:math:`\texttt{thickness} \ge 0`
-or fills the area bounded by the contours if
-:math:`\texttt{thickness}<0`
-.
-
-
-.. index:: Ellipse
-
-.. _Ellipse:
-
-Ellipse
--------
-
-`id=0.149495013833 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Ellipse>`__
-
-
-.. function:: Ellipse(img,center,axes,angle,start_angle,end_angle,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws a simple or thick elliptic arc or an fills ellipse sector.
-
-
-
-
-
-
- :param img: The image
-
- :type img: :class:`CvArr`
-
-
- :param center: Center of the ellipse
-
- :type center: :class:`CvPoint`
-
-
- :param axes: Length of the ellipse axes
-
- :type axes: :class:`CvSize`
-
-
- :param angle: Rotation angle
-
- :type angle: float
-
-
- :param start_angle: Starting angle of the elliptic arc
-
- :type start_angle: float
-
-
- :param end_angle: Ending angle of the elliptic arc.
-
- :type end_angle: float
-
-
- :param color: Ellipse color
-
- :type color: :class:`CvScalar`
-
-
- :param thickness: Thickness of the ellipse arc outline if positive, otherwise this indicates that a filled ellipse sector is to be drawn
-
- :type thickness: int
-
-
- :param lineType: Type of the ellipse boundary, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the center coordinates and axes' values
-
- :type shift: int
-
-
-
-The function draws a simple or thick elliptic
-arc or fills an ellipse sector. The arc is clipped by the ROI rectangle.
-A piecewise-linear approximation is used for antialiased arcs and
-thick arcs. All the angles are given in degrees. The picture below
-explains the meaning of the parameters.
-
-Parameters of Elliptic Arc
-
-
-
-.. image:: ../pics/ellipse.png
-
-
-
-
-.. index:: EllipseBox
-
-.. _EllipseBox:
-
-EllipseBox
-----------
-
-`id=0.217567751917 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/EllipseBox>`__
-
-
-.. function:: EllipseBox(img,box,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws a simple or thick elliptic arc or fills an ellipse sector.
-
-
-
-
-
-
- :param img: Image
-
- :type img: :class:`CvArr`
-
-
- :param box: The enclosing box of the ellipse drawn
-
- :type box: :class:`CvBox2D`
-
-
- :param thickness: Thickness of the ellipse boundary
-
- :type thickness: int
-
-
- :param lineType: Type of the ellipse boundary, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the box vertex coordinates
-
- :type shift: int
-
-
-
-The function draws a simple or thick ellipse outline, or fills an ellipse. The functions provides a convenient way to draw an ellipse approximating some shape; that is what
-:ref:`CamShift`
-and
-:ref:`FitEllipse`
-do. The ellipse drawn is clipped by ROI rectangle. A piecewise-linear approximation is used for antialiased arcs and thick arcs.
-
-
-.. index:: FillConvexPoly
-
-.. _FillConvexPoly:
-
-FillConvexPoly
---------------
-
-`id=0.27807950676 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/FillConvexPoly>`__
-
-
-.. function:: FillConvexPoly(img,pn,color,lineType=8,shift=0)-> None
-
- Fills a convex polygon.
-
-
-
-
-
-
- :param img: Image
-
- :type img: :class:`CvArr`
-
-
- :param pn: List of coordinate pairs
-
- :type pn: :class:`CvPoints`
-
-
- :param color: Polygon color
-
- :type color: :class:`CvScalar`
-
-
- :param lineType: Type of the polygon boundaries, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the vertex coordinates
-
- :type shift: int
-
-
-
-The function fills a convex polygon's interior.
-This function is much faster than the function
-``cvFillPoly``
-and can fill not only convex polygons but any monotonic polygon,
-i.e., a polygon whose contour intersects every horizontal line (scan
-line) twice at the most.
-
-
-
-.. index:: FillPoly
-
-.. _FillPoly:
-
-FillPoly
---------
-
-`id=0.470054743188 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/FillPoly>`__
-
-
-.. function:: FillPoly(img,polys,color,lineType=8,shift=0)-> None
-
- Fills a polygon's interior.
-
-
-
-
-
-
- :param img: Image
-
- :type img: :class:`CvArr`
-
-
- :param polys: List of lists of (x,y) pairs. Each list of points is a polygon.
-
- :type polys: list of lists of (x,y) pairs
-
-
- :param color: Polygon color
-
- :type color: :class:`CvScalar`
-
-
- :param lineType: Type of the polygon boundaries, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the vertex coordinates
-
- :type shift: int
-
-
-
-The function fills an area bounded by several
-polygonal contours. The function fills complex areas, for example,
-areas with holes, contour self-intersection, and so forth.
-
-
-.. index:: GetTextSize
-
-.. _GetTextSize:
-
-GetTextSize
------------
-
-`id=0.723985190989 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetTextSize>`__
-
-
-.. function:: GetTextSize(textString,font)-> (textSize,baseline)
-
- Retrieves the width and height of a text string.
-
-
-
-
-
-
- :param font: Pointer to the font structure
-
- :type font: :class:`CvFont`
-
-
- :param textString: Input string
-
- :type textString: str
-
-
- :param textSize: Resultant size of the text string. Height of the text does not include the height of character parts that are below the baseline.
-
- :type textSize: :class:`CvSize`
-
-
- :param baseline: y-coordinate of the baseline relative to the bottom-most text point
-
- :type baseline: int
-
-
-
-The function calculates the dimensions of a rectangle to enclose a text string when a specified font is used.
-
-
-.. index:: InitFont
-
-.. _InitFont:
-
-InitFont
---------
-
-`id=0.526488936836 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/InitFont>`__
-
-
-.. function:: InitFont(fontFace,hscale,vscale,shear=0,thickness=1,lineType=8)-> font
-
- Initializes font structure.
-
-
-
-
-
-
- :param font: Pointer to the font structure initialized by the function
-
- :type font: :class:`CvFont`
-
-
- :param fontFace: Font name identifier. Only a subset of Hershey fonts http://sources.isc.org/utils/misc/hershey-font.txt are supported now:
-
-
-
- * **CV_FONT_HERSHEY_SIMPLEX** normal size sans-serif font
-
-
- * **CV_FONT_HERSHEY_PLAIN** small size sans-serif font
-
-
- * **CV_FONT_HERSHEY_DUPLEX** normal size sans-serif font (more complex than ``CV_FONT_HERSHEY_SIMPLEX`` )
-
-
- * **CV_FONT_HERSHEY_COMPLEX** normal size serif font
-
-
- * **CV_FONT_HERSHEY_TRIPLEX** normal size serif font (more complex than ``CV_FONT_HERSHEY_COMPLEX`` )
-
-
- * **CV_FONT_HERSHEY_COMPLEX_SMALL** smaller version of ``CV_FONT_HERSHEY_COMPLEX``
-
-
- * **CV_FONT_HERSHEY_SCRIPT_SIMPLEX** hand-writing style font
-
-
- * **CV_FONT_HERSHEY_SCRIPT_COMPLEX** more complex variant of ``CV_FONT_HERSHEY_SCRIPT_SIMPLEX``
-
-
-
- The parameter can be composited from one of the values above and an optional ``CV_FONT_ITALIC`` flag, which indicates italic or oblique font.
-
- :type fontFace: int
-
-
- :param hscale: Horizontal scale. If equal to ``1.0f`` , the characters have the original width depending on the font type. If equal to ``0.5f`` , the characters are of half the original width.
-
- :type hscale: float
-
-
- :param vscale: Vertical scale. If equal to ``1.0f`` , the characters have the original height depending on the font type. If equal to ``0.5f`` , the characters are of half the original height.
-
- :type vscale: float
-
-
- :param shear: Approximate tangent of the character slope relative to the vertical line. A zero value means a non-italic font, ``1.0f`` means about a 45 degree slope, etc.
-
- :type shear: float
-
-
- :param thickness: Thickness of the text strokes
-
- :type thickness: int
-
-
- :param lineType: Type of the strokes, see :ref:`Line` description
-
- :type lineType: int
-
-
-
-The function initializes the font structure that can be passed to text rendering functions.
-
-
-
-.. index:: InitLineIterator
-
-.. _InitLineIterator:
-
-InitLineIterator
-----------------
-
-`id=0.352578115956 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/InitLineIterator>`__
-
-
-.. function:: InitLineIterator(image, pt1, pt2, connectivity=8, left_to_right=0) -> line_iterator
-
- Initializes the line iterator.
-
-
-
-
-
-
- :param image: Image to sample the line from
-
- :type image: :class:`CvArr`
-
-
- :param pt1: First ending point of the line segment
-
- :type pt1: :class:`CvPoint`
-
-
- :param pt2: Second ending point of the line segment
-
- :type pt2: :class:`CvPoint`
-
-
- :param connectivity: The scanned line connectivity, 4 or 8.
-
- :type connectivity: int
-
-
- :param left_to_right:
- If ( :math:`\texttt{left\_to\_right} = 0` ) then the line is scanned in the specified order, from ``pt1`` to ``pt2`` .
- If ( :math:`\texttt{left\_to\_right} \ne 0` ) the line is scanned from left-most point to right-most.
-
- :type left_to_right: int
-
-
- :param line_iterator: Iterator over the pixels of the line
-
- :type line_iterator: :class:`iter`
-
-
-
-The function returns an iterator over the pixels connecting the two points.
-The points on the line are
-calculated one by one using a 4-connected or 8-connected Bresenham
-algorithm.
-
-Example: Using line iterator to calculate the sum of pixel values along a color line
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> img = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_COLOR)
- >>> li = cv.InitLineIterator(img, (100, 100), (125, 150))
- >>> red_sum = 0
- >>> green_sum = 0
- >>> blue_sum = 0
- >>> for (r, g, b) in li:
- ... red_sum += r
- ... green_sum += g
- ... blue_sum += b
- >>> print red_sum, green_sum, blue_sum
- 10935.0 9496.0 7946.0
-
-
-..
-
-or more concisely using
-`zip <http://docs.python.org/library/functions.html#zip>`_
-:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> img = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_COLOR)
- >>> li = cv.InitLineIterator(img, (100, 100), (125, 150))
- >>> print [sum(c) for c in zip(*li)]
- [10935.0, 9496.0, 7946.0]
-
-
-..
-
-
-.. index:: Line
-
-.. _Line:
-
-Line
-----
-
-`id=0.32347581651 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Line>`__
-
-
-.. function:: Line(img,pt1,pt2,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws a line segment connecting two points.
-
-
-
-
-
-
- :param img: The image
-
- :type img: :class:`CvArr`
-
-
- :param pt1: First point of the line segment
-
- :type pt1: :class:`CvPoint`
-
-
- :param pt2: Second point of the line segment
-
- :type pt2: :class:`CvPoint`
-
-
- :param color: Line color
-
- :type color: :class:`CvScalar`
-
-
- :param thickness: Line thickness
-
- :type thickness: int
-
-
- :param lineType: Type of the line:
-
-
-
- * **8** (or omitted) 8-connected line.
-
-
- * **4** 4-connected line.
-
-
- * **CV_AA** antialiased line.
-
-
-
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the point coordinates
-
- :type shift: int
-
-
-
-The function draws the line segment between
-``pt1``
-and
-``pt2``
-points in the image. The line is
-clipped by the image or ROI rectangle. For non-antialiased lines
-with integer coordinates the 8-connected or 4-connected Bresenham
-algorithm is used. Thick lines are drawn with rounding endings.
-Antialiased lines are drawn using Gaussian filtering. To specify
-the line color, the user may use the macro
-``CV_RGB( r, g, b )``
-.
-
-
-.. index:: PolyLine
-
-.. _PolyLine:
-
-PolyLine
---------
-
-`id=0.899614274707 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/PolyLine>`__
-
-
-.. function:: PolyLine(img,polys,is_closed,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws simple or thick polygons.
-
-
-
-
-
-
- :param polys: List of lists of (x,y) pairs. Each list of points is a polygon.
-
- :type polys: list of lists of (x,y) pairs
-
-
- :param img: Image
-
- :type img: :class:`CvArr`
-
-
- :param is_closed: Indicates whether the polylines must be drawn
- closed. If closed, the function draws the line from the last vertex
- of every contour to the first vertex.
-
- :type is_closed: int
-
-
- :param color: Polyline color
-
- :type color: :class:`CvScalar`
-
-
- :param thickness: Thickness of the polyline edges
-
- :type thickness: int
-
-
- :param lineType: Type of the line segments, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the vertex coordinates
-
- :type shift: int
-
-
-
-The function draws single or multiple polygonal curves.
-
-
-.. index:: PutText
-
-.. _PutText:
-
-PutText
--------
-
-`id=0.414755160642 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/PutText>`__
-
-
-.. function:: PutText(img,text,org,font,color)-> None
-
- Draws a text string.
-
-
-
-
-
-
- :param img: Input image
-
- :type img: :class:`CvArr`
-
-
- :param text: String to print
-
- :type text: str
-
-
- :param org: Coordinates of the bottom-left corner of the first letter
-
- :type org: :class:`CvPoint`
-
-
- :param font: Pointer to the font structure
-
- :type font: :class:`CvFont`
-
-
- :param color: Text color
-
- :type color: :class:`CvScalar`
-
-
-
-The function renders the text in the image with
-the specified font and color. The printed text is clipped by the ROI
-rectangle. Symbols that do not belong to the specified font are
-replaced with the symbol for a rectangle.
-
-
-.. index:: Rectangle
-
-.. _Rectangle:
-
-Rectangle
----------
-
-`id=0.243634323886 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Rectangle>`__
-
-
-.. function:: Rectangle(img,pt1,pt2,color,thickness=1,lineType=8,shift=0)-> None
-
- Draws a simple, thick, or filled rectangle.
-
-
-
-
-
-
- :param img: Image
-
- :type img: :class:`CvArr`
-
-
- :param pt1: One of the rectangle's vertices
-
- :type pt1: :class:`CvPoint`
-
-
- :param pt2: Opposite rectangle vertex
-
- :type pt2: :class:`CvPoint`
-
-
- :param color: Line color (RGB) or brightness (grayscale image)
-
- :type color: :class:`CvScalar`
-
-
- :param thickness: Thickness of lines that make up the rectangle. Negative values, e.g., CV _ FILLED, cause the function to draw a filled rectangle.
-
- :type thickness: int
-
-
- :param lineType: Type of the line, see :ref:`Line` description
-
- :type lineType: int
-
-
- :param shift: Number of fractional bits in the point coordinates
-
- :type shift: int
-
-
-
-The function draws a rectangle with two opposite corners
-``pt1``
-and
-``pt2``
-.
-
-
-.. index:: CV_RGB
-
-.. _CV_RGB:
-
-CV_RGB
-------
-
-`id=0.224041402111 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CV_RGB>`__
-
-
-.. function:: CV_RGB(red,grn,blu)->CvScalar
-
- Constructs a color value.
-
-
-
-
-
-
- :param red: Red component
-
- :type red: float
-
-
- :param grn: Green component
-
- :type grn: float
-
-
- :param blu: Blue component
-
- :type blu: float
-
-
-
+++ /dev/null
-Dynamic Structures
-==================
-
-.. highlight:: python
-
-
-
-.. index:: CvMemStorage
-
-.. _CvMemStorage:
-
-CvMemStorage
-------------
-
-`id=0.11586833925 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvMemStorage>`__
-
-.. class:: CvMemStorage
-
-
-
-Growing memory storage.
-
-Many OpenCV functions use a given storage area for their results
-and working storage. These storage areas can be created using
-:ref:`CreateMemStorage`
-. OpenCV Python tracks the objects occupying a
-CvMemStorage, and automatically releases the CvMemStorage when there are
-no objects referring to it. For this reason, there is explicit function
-to release a CvMemStorage.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> image = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
- >>> seq = cv.FindContours(image, cv.CreateMemStorage(), cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
- >>> del seq # associated storage is also released
-
-
-..
-
-
-.. index:: CvSeq
-
-.. _CvSeq:
-
-CvSeq
------
-
-`id=0.0938210237552 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvSeq>`__
-
-.. class:: CvSeq
-
-
-
-Growable sequence of elements.
-
-Many OpenCV functions return a CvSeq object. The CvSeq obect is a sequence, so these are all legal:
-
-
-
-::
-
-
-
- seq = cv.FindContours(scribble, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
- # seq is a sequence of point pairs
- print len(seq)
- # FindContours returns a sequence of (x,y) points, so to print them out:
- for (x,y) in seq:
- print (x,y)
- print seq[10] # tenth entry in the seqeuence
- print seq[::-1] # reversed sequence
- print sorted(list(seq)) # sorted sequence
-
-
-..
-
-Also, a CvSeq object has methods
-``h_next()``
-,
-``h_prev()``
-,
-``v_next()``
-and
-``v_prev()``
-.
-Some OpenCV functions (for example
-:ref:`FindContours`
-) can return multiple CvSeq objects, connected by these relations.
-In this case the methods return the other sequences. If no relation between sequences exists, then the methods return
-``None``
-.
-
-
-.. index:: CvSet
-
-.. _CvSet:
-
-CvSet
------
-
-`id=0.165386903844 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvSet>`__
-
-.. class:: CvSet
-
-
-
-Collection of nodes.
-
-Some OpenCV functions return a CvSet object. The CvSet obect is iterable, for example:
-
-
-
-
-::
-
-
-
- for i in s:
- print i
- print set(s)
- print list(s)
-
-
-..
-
-
-.. index:: CloneSeq
-
-.. _CloneSeq:
-
-CloneSeq
---------
-
-`id=0.893022984961 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CloneSeq>`__
-
-
-.. function:: CloneSeq(seq,storage)-> None
-
- Creates a copy of a sequence.
-
-
-
-
-
-
- :param seq: Sequence
-
- :type seq: :class:`CvSeq`
-
-
- :param storage: The destination storage block to hold the new sequence header and the copied data, if any. If it is NULL, the function uses the storage block containing the input sequence.
-
- :type storage: :class:`CvMemStorage`
-
-
-
-The function makes a complete copy of the input sequence and returns it.
-
-
-.. index:: CreateMemStorage
-
-.. _CreateMemStorage:
-
-CreateMemStorage
-----------------
-
-`id=0.141261875659 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateMemStorage>`__
-
-
-.. function:: CreateMemStorage(blockSize = 0) -> memstorage
-
- Creates memory storage.
-
-
-
-
-
-
- :param blockSize: Size of the storage blocks in bytes. If it is 0, the block size is set to a default value - currently it is about 64K.
-
- :type blockSize: int
-
-
-
-The function creates an empty memory storage. See
-:ref:`CvMemStorage`
-description.
-
-
-.. index:: SeqInvert
-
-.. _SeqInvert:
-
-SeqInvert
----------
-
-`id=0.420185773758 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SeqInvert>`__
-
-
-.. function:: SeqInvert(seq)-> None
-
- Reverses the order of sequence elements.
-
-
-
-
-
-
- :param seq: Sequence
-
- :type seq: :class:`CvSeq`
-
-
-
-The function reverses the sequence in-place - makes the first element go last, the last element go first and so forth.
-
-
-.. index:: SeqRemove
-
-.. _SeqRemove:
-
-SeqRemove
----------
-
-`id=0.405976799419 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SeqRemove>`__
-
-
-.. function:: SeqRemove(seq,index)-> None
-
- Removes an element from the middle of a sequence.
-
-
-
-
-
-
- :param seq: Sequence
-
- :type seq: :class:`CvSeq`
-
-
- :param index: Index of removed element
-
- :type index: int
-
-
-
-The function removes elements with the given
-index. If the index is out of range the function reports an error. An
-attempt to remove an element from an empty sequence is a special
-case of this situation. The function removes an element by shifting
-the sequence elements between the nearest end of the sequence and the
-``index``
--th position, not counting the latter.
-
-
-
-.. index:: SeqRemoveSlice
-
-.. _SeqRemoveSlice:
-
-SeqRemoveSlice
---------------
-
-`id=0.589674828285 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SeqRemoveSlice>`__
-
-
-.. function:: SeqRemoveSlice(seq,slice)-> None
-
- Removes a sequence slice.
-
-
-
-
-
-
- :param seq: Sequence
-
- :type seq: :class:`CvSeq`
-
-
- :param slice: The part of the sequence to remove
-
- :type slice: :class:`CvSlice`
-
-
-
-The function removes a slice from the sequence.
-
+++ /dev/null
-Operations on Arrays
-====================
-
-.. highlight:: python
-
-
-
-.. index:: AbsDiff
-
-.. _AbsDiff:
-
-AbsDiff
--------
-
-`id=0.842617662689 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AbsDiff>`__
-
-
-.. function:: AbsDiff(src1,src2,dst)-> None
-
- Calculates absolute difference between two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates absolute difference between two arrays.
-
-
-
-.. math::
-
- \texttt{dst} (i)_c = | \texttt{src1} (I)_c - \texttt{src2} (I)_c|
-
-
-All the arrays must have the same data type and the same size (or ROI size).
-
-
-.. index:: AbsDiffS
-
-.. _AbsDiffS:
-
-AbsDiffS
---------
-
-`id=0.459009306478 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AbsDiffS>`__
-
-
-.. function:: AbsDiffS(src,value,dst)-> None
-
- Calculates absolute difference between an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param value: The scalar
-
- :type value: :class:`CvScalar`
-
-
-
-The function calculates absolute difference between an array and a scalar.
-
-
-
-.. math::
-
- \texttt{dst} (i)_c = | \texttt{src} (I)_c - \texttt{value} _c|
-
-
-All the arrays must have the same data type and the same size (or ROI size).
-
-
-
-.. index:: Add
-
-.. _Add:
-
-Add
----
-
-`id=0.00692531918124 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Add>`__
-
-
-.. function:: Add(src1,src2,dst,mask=NULL)-> None
-
- Computes the per-element sum of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function adds one array to another:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)+src2(I) if mask(I)!=0
-
-
-..
-
-All the arrays must have the same type, except the mask, and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-.. index:: AddS
-
-.. _AddS:
-
-AddS
-----
-
-`id=0.243025426724 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AddS>`__
-
-
-.. function:: AddS(src,value,dst,mask=NULL)-> None
-
- Computes the sum of an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Added scalar
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function adds a scalar
-``value``
-to every element in the source array
-``src1``
-and stores the result in
-``dst``
-.
-For types that have limited range this operation is saturating.
-
-
-
-
-::
-
-
-
- dst(I)=src(I)+value if mask(I)!=0
-
-
-..
-
-All the arrays must have the same type, except the mask, and the same size (or ROI size).
-
-
-
-.. index:: AddWeighted
-
-.. _AddWeighted:
-
-AddWeighted
------------
-
-`id=0.0785921846437 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AddWeighted>`__
-
-
-.. function:: AddWeighted(src1,alpha,src2,beta,gamma,dst)-> None
-
- Computes the weighted sum of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param alpha: Weight for the first array elements
-
- :type alpha: float
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param beta: Weight for the second array elements
-
- :type beta: float
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param gamma: Scalar, added to each sum
-
- :type gamma: float
-
-
-
-The function calculates the weighted sum of two arrays as follows:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)*alpha+src2(I)*beta+gamma
-
-
-..
-
-All the arrays must have the same type and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-
-.. index:: And
-
-.. _And:
-
-And
----
-
-`id=0.824628298877 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/And>`__
-
-
-.. function:: And(src1,src2,dst,mask=NULL)-> None
-
- Calculates per-element bit-wise conjunction of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates per-element bit-wise logical conjunction of two arrays:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)&src2(I) if mask(I)!=0
-
-
-..
-
-In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size.
-
-
-.. index:: AndS
-
-.. _AndS:
-
-AndS
-----
-
-`id=0.176650125779 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AndS>`__
-
-
-.. function:: AndS(src,value,dst,mask=NULL)-> None
-
- Calculates per-element bit-wise conjunction of an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Scalar to use in the operation
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates per-element bit-wise conjunction of an array and a scalar:
-
-
-
-
-::
-
-
-
- dst(I)=src(I)&value if mask(I)!=0
-
-
-..
-
-Prior to the actual operation, the scalar is converted to the same type as that of the array(s). In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size.
-
-
-.. index:: Avg
-
-.. _Avg:
-
-Avg
----
-
-`id=0.189296163871 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Avg>`__
-
-
-.. function:: Avg(arr,mask=NULL)-> CvScalar
-
- Calculates average (mean) of array elements.
-
-
-
-
-
-
- :param arr: The array
-
- :type arr: :class:`CvArr`
-
-
- :param mask: The optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates the average value
-``M``
-of array elements, independently for each channel:
-
-
-
-.. math::
-
- \begin{array}{l} N = \sum _I ( \texttt{mask} (I) \ne 0) \\ M_c = \frac{\sum_{I, \, \texttt{mask}(I) \ne 0} \texttt{arr} (I)_c}{N} \end{array}
-
-
-If the array is
-``IplImage``
-and COI is set, the function processes the selected channel only and stores the average to the first scalar component
-:math:`S_0`
-.
-
-
-.. index:: AvgSdv
-
-.. _AvgSdv:
-
-AvgSdv
-------
-
-`id=0.913261855565 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/AvgSdv>`__
-
-
-.. function:: AvgSdv(arr,mask=NULL)-> (mean, stdDev)
-
- Calculates average (mean) of array elements.
-
-
-
-
-
-
- :param arr: The array
-
- :type arr: :class:`CvArr`
-
-
- :param mask: The optional operation mask
-
- :type mask: :class:`CvArr`
-
-
- :param mean: Mean value, a CvScalar
-
- :type mean: :class:`CvScalar`
-
-
- :param stdDev: Standard deviation, a CvScalar
-
- :type stdDev: :class:`CvScalar`
-
-
-
-The function calculates the average value and standard deviation of array elements, independently for each channel:
-
-
-
-.. math::
-
- \begin{array}{l} N = \sum _I ( \texttt{mask} (I) \ne 0) \\ mean_c = \frac{1}{N} \, \sum _{ I, \, \texttt{mask} (I) \ne 0} \texttt{arr} (I)_c \\ stdDev_c = \sqrt{\frac{1}{N} \, \sum_{ I, \, \texttt{mask}(I) \ne 0} ( \texttt{arr} (I)_c - mean_c)^2} \end{array}
-
-
-If the array is
-``IplImage``
-and COI is set, the function processes the selected channel only and stores the average and standard deviation to the first components of the output scalars (
-:math:`mean_0`
-and
-:math:`stdDev_0`
-).
-
-
-.. index:: CalcCovarMatrix
-
-.. _CalcCovarMatrix:
-
-CalcCovarMatrix
----------------
-
-`id=0.200918462968 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CalcCovarMatrix>`__
-
-
-.. function:: CalcCovarMatrix(vects,covMat,avg,flags)-> None
-
- Calculates covariance matrix of a set of vectors.
-
-
-
-
-
-
- :param vects: The input vectors, all of which must have the same type and the same size. The vectors do not have to be 1D, they can be 2D (e.g., images) and so forth
-
- :type vects: :class:`cvarr_count`
-
-
- :param covMat: The output covariance matrix that should be floating-point and square
-
- :type covMat: :class:`CvArr`
-
-
- :param avg: The input or output (depending on the flags) array - the mean (average) vector of the input vectors
-
- :type avg: :class:`CvArr`
-
-
- :param flags: The operation flags, a combination of the following values
-
- * **CV_COVAR_SCRAMBLED** The output covariance matrix is calculated as:
-
- .. math::
-
- \texttt{scale} * [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]
-
- ,
- that is, the covariance matrix is :math:`\texttt{count} \times \texttt{count}` .
- Such an unusual covariance matrix is used for fast PCA
- of a set of very large vectors (see, for example, the EigenFaces technique
- for face recognition). Eigenvalues of this "scrambled" matrix will
- match the eigenvalues of the true covariance matrix and the "true"
- eigenvectors can be easily calculated from the eigenvectors of the
- "scrambled" covariance matrix.
-
- * **CV_COVAR_NORMAL** The output covariance matrix is calculated as:
-
- .. math::
-
- \texttt{scale} * [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...] \cdot [ \texttt{vects} [0]- \texttt{avg} , \texttt{vects} [1]- \texttt{avg} ,...]^T
-
- ,
- that is, ``covMat`` will be a covariance matrix
- with the same linear size as the total number of elements in each
- input vector. One and only one of ``CV_COVAR_SCRAMBLED`` and ``CV_COVAR_NORMAL`` must be specified
-
- * **CV_COVAR_USE_AVG** If the flag is specified, the function does not calculate ``avg`` from the input vectors, but, instead, uses the passed ``avg`` vector. This is useful if ``avg`` has been already calculated somehow, or if the covariance matrix is calculated by parts - in this case, ``avg`` is not a mean vector of the input sub-set of vectors, but rather the mean vector of the whole set.
-
- * **CV_COVAR_SCALE** If the flag is specified, the covariance matrix is scaled. In the "normal" mode ``scale`` is '1./count'; in the "scrambled" mode ``scale`` is the reciprocal of the total number of elements in each input vector. By default (if the flag is not specified) the covariance matrix is not scaled ('scale=1').
-
-
- * **CV_COVAR_ROWS** Means that all the input vectors are stored as rows of a single matrix, ``vects[0]`` . ``count`` is ignored in this case, and ``avg`` should be a single-row vector of an appropriate size.
-
- * **CV_COVAR_COLS** Means that all the input vectors are stored as columns of a single matrix, ``vects[0]`` . ``count`` is ignored in this case, and ``avg`` should be a single-column vector of an appropriate size.
-
-
-
-
- :type flags: int
-
-
-
-The function calculates the covariance matrix
-and, optionally, the mean vector of the set of input vectors. The function
-can be used for PCA, for comparing vectors using Mahalanobis distance and so forth.
-
-
-.. index:: CartToPolar
-
-.. _CartToPolar:
-
-CartToPolar
------------
-
-`id=0.60451777375 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CartToPolar>`__
-
-
-.. function:: CartToPolar(x,y,magnitude,angle=NULL,angleInDegrees=0)-> None
-
- Calculates the magnitude and/or angle of 2d vectors.
-
-
-
-
-
-
- :param x: The array of x-coordinates
-
- :type x: :class:`CvArr`
-
-
- :param y: The array of y-coordinates
-
- :type y: :class:`CvArr`
-
-
- :param magnitude: The destination array of magnitudes, may be set to NULL if it is not needed
-
- :type magnitude: :class:`CvArr`
-
-
- :param angle: The destination array of angles, may be set to NULL if it is not needed. The angles are measured in radians :math:`(0` to :math:`2 \pi )` or in degrees (0 to 360 degrees).
-
- :type angle: :class:`CvArr`
-
-
- :param angleInDegrees: The flag indicating whether the angles are measured in radians, which is default mode, or in degrees
-
- :type angleInDegrees: int
-
-
-
-The function calculates either the magnitude, angle, or both of every 2d vector (x(I),y(I)):
-
-
-
-
-::
-
-
-
-
- magnitude(I)=sqrt(x(I)^2^+y(I)^2^ ),
- angle(I)=atan(y(I)/x(I) )
-
-
-
-..
-
-The angles are calculated with 0.1 degree accuracy. For the (0,0) point, the angle is set to 0.
-
-
-.. index:: Cbrt
-
-.. _Cbrt:
-
-Cbrt
-----
-
-`id=0.789355763623 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Cbrt>`__
-
-
-.. function:: Cbrt(value)-> float
-
- Calculates the cubic root
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-The function calculates the cubic root of the argument, and normally it is faster than
-``pow(value,1./3)``
-. In addition, negative arguments are handled properly. Special values (
-:math:`\pm \infty`
-, NaN) are not handled.
-
-
-.. index:: ClearND
-
-.. _ClearND:
-
-ClearND
--------
-
-`id=0.949651070488 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ClearND>`__
-
-
-.. function:: ClearND(arr,idx)-> None
-
- Clears a specific array element.
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx: Array of the element indices
-
- :type idx: sequence of int
-
-
-
-The function
-:ref:`ClearND`
-clears (sets to zero) a specific element of a dense array or deletes the element of a sparse array. If the sparse array element does not exists, the function does nothing.
-
-
-.. index:: CloneImage
-
-.. _CloneImage:
-
-CloneImage
-----------
-
-`id=0.83896698035 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CloneImage>`__
-
-
-.. function:: CloneImage(image)-> copy
-
- Makes a full copy of an image, including the header, data, and ROI.
-
-
-
-
-
-
- :param image: The original image
-
- :type image: :class:`IplImage`
-
-
-
-The returned
-``IplImage*``
-points to the image copy.
-
-
-.. index:: CloneMat
-
-.. _CloneMat:
-
-CloneMat
---------
-
-`id=0.884969658256 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CloneMat>`__
-
-
-.. function:: CloneMat(mat)-> copy
-
- Creates a full matrix copy.
-
-
-
-
-
-
- :param mat: Matrix to be copied
-
- :type mat: :class:`CvMat`
-
-
-
-Creates a full copy of a matrix and returns a pointer to the copy.
-
-
-.. index:: CloneMatND
-
-.. _CloneMatND:
-
-CloneMatND
-----------
-
-`id=0.861258596068 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CloneMatND>`__
-
-
-.. function:: CloneMatND(mat)-> copy
-
- Creates full copy of a multi-dimensional array and returns a pointer to the copy.
-
-
-
-
-
-
- :param mat: Input array
-
- :type mat: :class:`CvMatND`
-
-
-
-
-.. index:: Cmp
-
-.. _Cmp:
-
-Cmp
----
-
-`id=0.337716948694 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Cmp>`__
-
-
-.. function:: Cmp(src1,src2,dst,cmpOp)-> None
-
- Performs per-element comparison of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array. Both source arrays must have a single channel.
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array, must have 8u or 8s type
-
- :type dst: :class:`CvArr`
-
-
- :param cmpOp: The flag specifying the relation between the elements to be checked
-
-
- * **CV_CMP_EQ** src1(I) "equal to" value
-
-
- * **CV_CMP_GT** src1(I) "greater than" value
-
-
- * **CV_CMP_GE** src1(I) "greater or equal" value
-
-
- * **CV_CMP_LT** src1(I) "less than" value
-
-
- * **CV_CMP_LE** src1(I) "less or equal" value
-
-
- * **CV_CMP_NE** src1(I) "not equal" value
-
-
-
- :type cmpOp: int
-
-
-
-The function compares the corresponding elements of two arrays and fills the destination mask array:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I) op src2(I),
-
-
-..
-
-``dst(I)``
-is set to 0xff (all
-``1``
--bits) if the specific relation between the elements is true and 0 otherwise. All the arrays must have the same type, except the destination, and the same size (or ROI size)
-
-
-.. index:: CmpS
-
-.. _CmpS:
-
-CmpS
-----
-
-`id=0.875900023936 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CmpS>`__
-
-
-.. function:: CmpS(src,value,dst,cmpOp)-> None
-
- Performs per-element comparison of an array and a scalar.
-
-
-
-
-
-
- :param src: The source array, must have a single channel
-
- :type src: :class:`CvArr`
-
-
- :param value: The scalar value to compare each array element with
-
- :type value: float
-
-
- :param dst: The destination array, must have 8u or 8s type
-
- :type dst: :class:`CvArr`
-
-
- :param cmpOp: The flag specifying the relation between the elements to be checked
-
-
- * **CV_CMP_EQ** src1(I) "equal to" value
-
-
- * **CV_CMP_GT** src1(I) "greater than" value
-
-
- * **CV_CMP_GE** src1(I) "greater or equal" value
-
-
- * **CV_CMP_LT** src1(I) "less than" value
-
-
- * **CV_CMP_LE** src1(I) "less or equal" value
-
-
- * **CV_CMP_NE** src1(I) "not equal" value
-
-
-
- :type cmpOp: int
-
-
-
-The function compares the corresponding elements of an array and a scalar and fills the destination mask array:
-
-
-
-
-::
-
-
-
- dst(I)=src(I) op scalar
-
-
-..
-
-where
-``op``
-is
-:math:`=,\; >,\; \ge,\; <,\; \le\; or\; \ne`
-.
-
-``dst(I)``
-is set to 0xff (all
-``1``
--bits) if the specific relation between the elements is true and 0 otherwise. All the arrays must have the same size (or ROI size).
-
-
-.. index:: Convert
-
-.. _Convert:
-
-Convert
--------
-
-`id=0.524270158253 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Convert>`__
-
-
-.. function:: Convert(src,dst)-> None
-
- Converts one array to another.
-
-
-
-
-
-
- :param src: Source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The type of conversion is done with rounding and saturation, that is if the
-result of scaling + conversion can not be represented exactly by a value
-of the destination array element type, it is set to the nearest representable
-value on the real axis.
-
-All the channels of multi-channel arrays are processed independently.
-
-
-.. index:: ConvertScale
-
-.. _ConvertScale:
-
-ConvertScale
-------------
-
-`id=0.857019498758 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ConvertScale>`__
-
-
-.. function:: ConvertScale(src,dst,scale=1.0,shift=0.0)-> None
-
- Converts one array to another with optional linear transformation.
-
-
-
-
-
-
- :param src: Source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array
-
- :type dst: :class:`CvArr`
-
-
- :param scale: Scale factor
-
- :type scale: float
-
-
- :param shift: Value added to the scaled source array elements
-
- :type shift: float
-
-
-
-The function has several different purposes, and thus has several different names. It copies one array to another with optional scaling, which is performed first, and/or optional type conversion, performed after:
-
-
-
-.. math::
-
- \texttt{dst} (I) = \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)
-
-
-All the channels of multi-channel arrays are processed independently.
-
-The type of conversion is done with rounding and saturation, that is if the
-result of scaling + conversion can not be represented exactly by a value
-of the destination array element type, it is set to the nearest representable
-value on the real axis.
-
-In the case of
-``scale=1, shift=0``
-no prescaling is done. This is a specially
-optimized case and it has the appropriate
-:ref:`Convert`
-name. If
-source and destination array types have equal types, this is also a
-special case that can be used to scale and shift a matrix or an image
-and that is caled
-:ref:`Scale`
-.
-
-
-
-.. index:: ConvertScaleAbs
-
-.. _ConvertScaleAbs:
-
-ConvertScaleAbs
----------------
-
-`id=0.64930952806 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ConvertScaleAbs>`__
-
-
-.. function:: ConvertScaleAbs(src,dst,scale=1.0,shift=0.0)-> None
-
- Converts input array elements to another 8-bit unsigned integer with optional linear transformation.
-
-
-
-
-
-
- :param src: Source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array (should have 8u depth)
-
- :type dst: :class:`CvArr`
-
-
- :param scale: ScaleAbs factor
-
- :type scale: float
-
-
- :param shift: Value added to the scaled source array elements
-
- :type shift: float
-
-
-
-The function is similar to
-:ref:`ConvertScale`
-, but it stores absolute values of the conversion results:
-
-
-
-.. math::
-
- \texttt{dst} (I) = | \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)|
-
-
-The function supports only destination arrays of 8u (8-bit unsigned integers) type; for other types the function can be emulated by a combination of
-:ref:`ConvertScale`
-and
-:ref:`Abs`
-functions.
-
-
-.. index:: CvtScaleAbs
-
-.. _CvtScaleAbs:
-
-CvtScaleAbs
------------
-
-`id=0.286104947471 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CvtScaleAbs>`__
-
-
-.. function:: CvtScaleAbs(src,dst,scale=1.0,shift=0.0)-> None
-
- Converts input array elements to another 8-bit unsigned integer with optional linear transformation.
-
-
-
-
-
-
- :param src: Source array
-
-
- :param dst: Destination array (should have 8u depth)
-
-
- :param scale: ScaleAbs factor
-
-
- :param shift: Value added to the scaled source array elements
-
-
-
-The function is similar to
-:ref:`ConvertScale`
-, but it stores absolute values of the conversion results:
-
-
-
-.. math::
-
- \texttt{dst} (I) = | \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)|
-
-
-The function supports only destination arrays of 8u (8-bit unsigned integers) type; for other types the function can be emulated by a combination of
-:ref:`ConvertScale`
-and
-:ref:`Abs`
-functions.
-
-
-.. index:: Copy
-
-.. _Copy:
-
-Copy
-----
-
-`id=0.66694684788 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Copy>`__
-
-
-.. function:: Copy(src,dst,mask=NULL)-> None
-
- Copies one array to another.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function copies selected elements from an input array to an output array:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{src} (I) \quad \text{if} \quad \texttt{mask} (I) \ne 0.
-
-
-If any of the passed arrays is of
-``IplImage``
-type, then its ROI
-and COI fields are used. Both arrays must have the same type, the same
-number of dimensions, and the same size. The function can also copy sparse
-arrays (mask is not supported in this case).
-
-
-.. index:: CountNonZero
-
-.. _CountNonZero:
-
-CountNonZero
-------------
-
-`id=0.620672385302 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CountNonZero>`__
-
-
-.. function:: CountNonZero(arr)-> int
-
- Counts non-zero array elements.
-
-
-
-
-
-
- :param arr: The array must be a single-channel array or a multi-channel image with COI set
-
- :type arr: :class:`CvArr`
-
-
-
-The function returns the number of non-zero elements in arr:
-
-
-
-.. math::
-
- \sum _I ( \texttt{arr} (I) \ne 0)
-
-
-In the case of
-``IplImage``
-both ROI and COI are supported.
-
-
-
-.. index:: CreateData
-
-.. _CreateData:
-
-CreateData
-----------
-
-`id=0.792006117205 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateData>`__
-
-
-.. function:: CreateData(arr) -> None
-
- Allocates array data
-
-
-
-
-
-
- :param arr: Array header
-
- :type arr: :class:`CvArr`
-
-
-
-The function allocates image, matrix or
-multi-dimensional array data. Note that in the case of matrix types OpenCV
-allocation functions are used and in the case of IplImage they are used
-unless
-``CV_TURN_ON_IPL_COMPATIBILITY``
-was called. In the
-latter case IPL functions are used to allocate the data.
-
-
-.. index:: CreateImage
-
-.. _CreateImage:
-
-CreateImage
------------
-
-`id=0.451032830099 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateImage>`__
-
-
-.. function:: CreateImage(size, depth, channels)->image
-
- Creates an image header and allocates the image data.
-
-
-
-
-
-
- :param size: Image width and height
-
- :type size: :class:`CvSize`
-
-
- :param depth: Bit depth of image elements. See :ref:`IplImage` for valid depths.
-
- :type depth: int
-
-
- :param channels: Number of channels per pixel. See :ref:`IplImage` for details. This function only creates images with interleaved channels.
-
- :type channels: int
-
-
-
-
-.. index:: CreateImageHeader
-
-.. _CreateImageHeader:
-
-CreateImageHeader
------------------
-
-`id=0.150457388362 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateImageHeader>`__
-
-
-.. function:: CreateImageHeader(size, depth, channels) -> image
-
- Creates an image header but does not allocate the image data.
-
-
-
-
-
-
- :param size: Image width and height
-
- :type size: :class:`CvSize`
-
-
- :param depth: Image depth (see :ref:`CreateImage` )
-
- :type depth: int
-
-
- :param channels: Number of channels (see :ref:`CreateImage` )
-
- :type channels: int
-
-
-
-
-.. index:: CreateMat
-
-.. _CreateMat:
-
-CreateMat
----------
-
-`id=0.0354643580877 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateMat>`__
-
-
-.. function:: CreateMat(rows, cols, type) -> mat
-
- Creates a matrix header and allocates the matrix data.
-
-
-
-
-
-
- :param rows: Number of rows in the matrix
-
- :type rows: int
-
-
- :param cols: Number of columns in the matrix
-
- :type cols: int
-
-
- :param type: The type of the matrix elements in the form ``CV_<bit depth><S|U|F>C<number of channels>`` , where S=signed, U=unsigned, F=float. For example, CV _ 8UC1 means the elements are 8-bit unsigned and the there is 1 channel, and CV _ 32SC2 means the elements are 32-bit signed and there are 2 channels.
-
- :type type: int
-
-
-
-
-.. index:: CreateMatHeader
-
-.. _CreateMatHeader:
-
-CreateMatHeader
----------------
-
-`id=0.824129461737 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateMatHeader>`__
-
-
-.. function:: CreateMatHeader(rows, cols, type) -> mat
-
- Creates a matrix header but does not allocate the matrix data.
-
-
-
-
-
-
- :param rows: Number of rows in the matrix
-
- :type rows: int
-
-
- :param cols: Number of columns in the matrix
-
- :type cols: int
-
-
- :param type: Type of the matrix elements, see :ref:`CreateMat`
-
- :type type: int
-
-
-
-The function allocates a new matrix header and returns a pointer to it. The matrix data can then be allocated using
-:ref:`CreateData`
-or set explicitly to user-allocated data via
-:ref:`SetData`
-.
-
-
-.. index:: CreateMatND
-
-.. _CreateMatND:
-
-CreateMatND
------------
-
-`id=0.922219816915 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateMatND>`__
-
-
-.. function:: CreateMatND(dims, type) -> None
-
- Creates the header and allocates the data for a multi-dimensional dense array.
-
-
-
-
-
-
- :param dims: List or tuple of array dimensions, up to 32 in length.
-
- :type dims: sequence of int
-
-
- :param type: Type of array elements, see :ref:`CreateMat` .
-
- :type type: int
-
-
-
-This is a short form for:
-
-
-.. index:: CreateMatNDHeader
-
-.. _CreateMatNDHeader:
-
-CreateMatNDHeader
------------------
-
-`id=0.014766828695 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CreateMatNDHeader>`__
-
-
-.. function:: CreateMatNDHeader(dims, type) -> None
-
- Creates a new matrix header but does not allocate the matrix data.
-
-
-
-
-
-
- :param dims: List or tuple of array dimensions, up to 32 in length.
-
- :type dims: sequence of int
-
-
- :param type: Type of array elements, see :ref:`CreateMat`
-
- :type type: int
-
-
-
-The function allocates a header for a multi-dimensional dense array. The array data can further be allocated using
-:ref:`CreateData`
-or set explicitly to user-allocated data via
-:ref:`SetData`
-.
-
-
-.. index:: CrossProduct
-
-.. _CrossProduct:
-
-CrossProduct
-------------
-
-`id=0.684733911918 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/CrossProduct>`__
-
-
-.. function:: CrossProduct(src1,src2,dst)-> None
-
- Calculates the cross product of two 3D vectors.
-
-
-
-
-
-
- :param src1: The first source vector
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source vector
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination vector
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates the cross product of two 3D vectors:
-
-
-
-.. math::
-
- \texttt{dst} = \texttt{src1} \times \texttt{src2}
-
-
-or:
-
-
-.. math::
-
- \begin{array}{l} \texttt{dst} _1 = \texttt{src1} _2 \texttt{src2} _3 - \texttt{src1} _3 \texttt{src2} _2 \\ \texttt{dst} _2 = \texttt{src1} _3 \texttt{src2} _1 - \texttt{src1} _1 \texttt{src2} _3 \\ \texttt{dst} _3 = \texttt{src1} _1 \texttt{src2} _2 - \texttt{src1} _2 \texttt{src2} _1 \end{array}
-
-
-
-CvtPixToPlane
--------------
-
-
-Synonym for
-:ref:`Split`
-.
-
-
-.. index:: DCT
-
-.. _DCT:
-
-DCT
----
-
-`id=0.0898469549395 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/DCT>`__
-
-
-.. function:: DCT(src,dst,flags)-> None
-
- Performs a forward or inverse Discrete Cosine transform of a 1D or 2D floating-point array.
-
-
-
-
-
-
- :param src: Source array, real 1D or 2D array
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array of the same size and same type as the source
-
- :type dst: :class:`CvArr`
-
-
- :param flags: Transformation flags, a combination of the following values
-
- * **CV_DXT_FORWARD** do a forward 1D or 2D transform.
-
- * **CV_DXT_INVERSE** do an inverse 1D or 2D transform.
-
- * **CV_DXT_ROWS** do a forward or inverse transform of every individual row of the input matrix. This flag allows user to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself), to do 3D and higher-dimensional transforms and so forth.
-
-
-
- :type flags: int
-
-
-
-The function performs a forward or inverse transform of a 1D or 2D floating-point array:
-
-Forward Cosine transform of 1D vector of
-:math:`N`
-elements:
-
-
-.. math::
-
- Y = C^{(N)} \cdot X
-
-
-where
-
-
-.. math::
-
- C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )
-
-
-and
-:math:`\alpha_0=1`
-,
-:math:`\alpha_j=2`
-for
-:math:`j > 0`
-.
-
-Inverse Cosine transform of 1D vector of N elements:
-
-
-.. math::
-
- X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y
-
-
-(since
-:math:`C^{(N)}`
-is orthogonal matrix,
-:math:`C^{(N)} \cdot \left(C^{(N)}\right)^T = I`
-)
-
-Forward Cosine transform of 2D
-:math:`M \times N`
-matrix:
-
-
-.. math::
-
- Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T
-
-
-Inverse Cosine transform of 2D vector of
-:math:`M \times N`
-elements:
-
-
-.. math::
-
- X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}
-
-
-
-.. index:: DFT
-
-.. _DFT:
-
-DFT
----
-
-`id=0.704021096664 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/DFT>`__
-
-
-.. function:: DFT(src,dst,flags,nonzeroRows=0)-> None
-
- Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
-
-
-
-
-
-
- :param src: Source array, real or complex
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array of the same size and same type as the source
-
- :type dst: :class:`CvArr`
-
-
- :param flags: Transformation flags, a combination of the following values
-
- * **CV_DXT_FORWARD** do a forward 1D or 2D transform. The result is not scaled.
-
- * **CV_DXT_INVERSE** do an inverse 1D or 2D transform. The result is not scaled. ``CV_DXT_FORWARD`` and ``CV_DXT_INVERSE`` are mutually exclusive, of course.
-
- * **CV_DXT_SCALE** scale the result: divide it by the number of array elements. Usually, it is combined with ``CV_DXT_INVERSE`` , and one may use a shortcut ``CV_DXT_INV_SCALE`` .
-
- * **CV_DXT_ROWS** do a forward or inverse transform of every individual row of the input matrix. This flag allows the user to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself), to do 3D and higher-dimensional transforms and so forth.
-
- * **CV_DXT_INVERSE_SCALE** same as ``CV_DXT_INVERSE + CV_DXT_SCALE``
-
-
-
- :type flags: int
-
-
- :param nonzeroRows: Number of nonzero rows in the source array
- (in the case of a forward 2d transform), or a number of rows of interest in
- the destination array (in the case of an inverse 2d transform). If the value
- is negative, zero, or greater than the total number of rows, it is
- ignored. The parameter can be used to speed up 2d convolution/correlation
- when computing via DFT. See the example below.
-
- :type nonzeroRows: int
-
-
-
-The function performs a forward or inverse transform of a 1D or 2D floating-point array:
-
-
-Forward Fourier transform of 1D vector of N elements:
-
-
-.. math::
-
- y = F^{(N)} \cdot x, where F^{(N)}_{jk}=exp(-i \cdot 2 \pi \cdot j \cdot k/N)
-
-
-,
-
-
-.. math::
-
- i=sqrt(-1)
-
-
-Inverse Fourier transform of 1D vector of N elements:
-
-
-.. math::
-
- x'= (F^{(N)})^{-1} \cdot y = conj(F^(N)) \cdot y
- x = (1/N) \cdot x
-
-
-Forward Fourier transform of 2D vector of M
-:math:`\times`
-N elements:
-
-
-.. math::
-
- Y = F^{(M)} \cdot X \cdot F^{(N)}
-
-
-Inverse Fourier transform of 2D vector of M
-:math:`\times`
-N elements:
-
-
-.. math::
-
- X'= conj(F^{(M)}) \cdot Y \cdot conj(F^{(N)})
- X = (1/(M \cdot N)) \cdot X'
-
-
-In the case of real (single-channel) data, the packed format, borrowed from IPL, is used to represent the result of a forward Fourier transform or input for an inverse Fourier transform:
-
-
-
-.. math::
-
- \begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}
-
-
-Note: the last column is present if
-``N``
-is even, the last row is present if
-``M``
-is even.
-In the case of 1D real transform the result looks like the first row of the above matrix.
-
-Here is the example of how to compute 2D convolution using DFT.
-
-
-.. index:: Det
-
-.. _Det:
-
-Det
----
-
-`id=0.840983924406 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Det>`__
-
-
-.. function:: Det(mat)-> double
-
- Returns the determinant of a matrix.
-
-
-
-
-
-
- :param mat: The source matrix
-
- :type mat: :class:`CvArr`
-
-
-
-The function returns the determinant of the square matrix
-``mat``
-. The direct method is used for small matrices and Gaussian elimination is used for larger matrices. For symmetric positive-determined matrices, it is also possible to run
-:ref:`SVD`
-with
-:math:`U = V = 0`
-and then calculate the determinant as a product of the diagonal elements of
-:math:`W`
-.
-
-
-.. index:: Div
-
-.. _Div:
-
-Div
----
-
-`id=0.468578114221 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Div>`__
-
-
-.. function:: Div(src1,src2,dst,scale)-> None
-
- Performs per-element division of two arrays.
-
-
-
-
-
-
- :param src1: The first source array. If the pointer is NULL, the array is assumed to be all 1's.
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param scale: Optional scale factor
-
- :type scale: float
-
-
-
-The function divides one array by another:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \fork{\texttt{scale} \cdot \texttt{src1}(I)/\texttt{src2}(I)}{if \texttt{src1} is not \texttt{NULL}}{\texttt{scale}/\texttt{src2}(I)}{otherwise}
-
-
-All the arrays must have the same type and the same size (or ROI size).
-
-
-
-.. index:: DotProduct
-
-.. _DotProduct:
-
-DotProduct
-----------
-
-`id=0.530706893973 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/DotProduct>`__
-
-
-.. function:: DotProduct(src1,src2)-> double
-
- Calculates the dot product of two arrays in Euclidian metrics.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
-
-The function calculates and returns the Euclidean dot product of two arrays.
-
-
-
-.. math::
-
- src1 \bullet src2 = \sum _I ( \texttt{src1} (I) \texttt{src2} (I))
-
-
-In the case of multiple channel arrays, the results for all channels are accumulated. In particular,
-``cvDotProduct(a,a)``
-where
-``a``
-is a complex vector, will return
-:math:`||\texttt{a}||^2`
-.
-The function can process multi-dimensional arrays, row by row, layer by layer, and so on.
-
-
-.. index:: EigenVV
-
-.. _EigenVV:
-
-EigenVV
--------
-
-`id=0.633830383615 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/EigenVV>`__
-
-
-.. function:: EigenVV(mat,evects,evals,eps,lowindex,highindex)-> None
-
- Computes eigenvalues and eigenvectors of a symmetric matrix.
-
-
-
-
-
-
- :param mat: The input symmetric square matrix, modified during the processing
-
- :type mat: :class:`CvArr`
-
-
- :param evects: The output matrix of eigenvectors, stored as subsequent rows
-
- :type evects: :class:`CvArr`
-
-
- :param evals: The output vector of eigenvalues, stored in the descending order (order of eigenvalues and eigenvectors is syncronized, of course)
-
- :type evals: :class:`CvArr`
-
-
- :param eps: Accuracy of diagonalization. Typically, ``DBL_EPSILON`` (about :math:`10^{-15}` ) works well.
- THIS PARAMETER IS CURRENTLY IGNORED.
-
- :type eps: float
-
-
- :param lowindex: Optional index of largest eigenvalue/-vector to calculate.
- (See below.)
-
- :type lowindex: int
-
-
- :param highindex: Optional index of smallest eigenvalue/-vector to calculate.
- (See below.)
-
- :type highindex: int
-
-
-
-The function computes the eigenvalues and eigenvectors of matrix
-``A``
-:
-
-
-
-
-::
-
-
-
- mat*evects(i,:)' = evals(i)*evects(i,:)' (in MATLAB notation)
-
-
-..
-
-If either low- or highindex is supplied the other is required, too.
-Indexing is 0-based. Example: To calculate the largest eigenvector/-value set
-``lowindex=highindex=0``
-. To calculate all the eigenvalues, leave
-``lowindex=highindex=-1``
-.
-For legacy reasons this function always returns a square matrix the same size
-as the source matrix with eigenvectors and a vector the length of the source
-matrix with eigenvalues. The selected eigenvectors/-values are always in the
-first highindex - lowindex + 1 rows.
-
-The contents of matrix
-``A``
-is destroyed by the function.
-
-Currently the function is slower than
-:ref:`SVD`
-yet less accurate,
-so if
-``A``
-is known to be positively-defined (for example, it
-is a covariance matrix)it is recommended to use
-:ref:`SVD`
-to find
-eigenvalues and eigenvectors of
-``A``
-, especially if eigenvectors
-are not required.
-
-
-.. index:: Exp
-
-.. _Exp:
-
-Exp
----
-
-`id=0.838615388235 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Exp>`__
-
-
-.. function:: Exp(src,dst)-> None
-
- Calculates the exponent of every array element.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array, it should have ``double`` type or the same type as the source
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates the exponent of every element of the input array:
-
-
-
-.. math::
-
- \texttt{dst} [I] = e^{ \texttt{src} (I)}
-
-
-The maximum relative error is about
-:math:`7 \times 10^{-6}`
-. Currently, the function converts denormalized values to zeros on output.
-
-
-.. index:: FastArctan
-
-.. _FastArctan:
-
-FastArctan
-----------
-
-`id=0.0156850486125 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/FastArctan>`__
-
-
-.. function:: FastArctan(y,x)-> float
-
- Calculates the angle of a 2D vector.
-
-
-
-
-
-
- :param x: x-coordinate of 2D vector
-
- :type x: float
-
-
- :param y: y-coordinate of 2D vector
-
- :type y: float
-
-
-
-The function calculates the full-range angle of an input 2D vector. The angle is
-measured in degrees and varies from 0 degrees to 360 degrees. The accuracy is about 0.1 degrees.
-
-
-.. index:: Flip
-
-.. _Flip:
-
-Flip
-----
-
-`id=0.76537990772 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Flip>`__
-
-
-.. function:: Flip(src,dst=NULL,flipMode=0)-> None
-
- Flip a 2D array around vertical, horizontal or both axes.
-
-
-
-
-
-
- :param src: Source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array.
- If :math:`\texttt{dst} = \texttt{NULL}` the flipping is done in place.
-
- :type dst: :class:`CvArr`
-
-
- :param flipMode: Specifies how to flip the array:
- 0 means flipping around the x-axis, positive (e.g., 1) means flipping around y-axis, and negative (e.g., -1) means flipping around both axes. See also the discussion below for the formulas:
-
- :type flipMode: int
-
-
-
-The function flips the array in one of three different ways (row and column indices are 0-based):
-
-
-
-.. math::
-
- dst(i,j) = \forkthree{\texttt{src}(rows(\texttt{src})-i-1,j)}{if $\texttt{flipMode} = 0$}{\texttt{src}(i,cols(\texttt{src})-j-1)}{if $\texttt{flipMode} > 0$}{\texttt{src}(rows(\texttt{src})-i-1,cols(\texttt{src})-j-1)}{if $\texttt{flipMode} < 0$}
-
-
-The example scenarios of function use are:
-
-
-
-
-*
- vertical flipping of the image (flipMode = 0) to switch between top-left and bottom-left image origin, which is a typical operation in video processing under Win32 systems.
-
-
-
-*
- horizontal flipping of the image with subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipMode
- :math:`>`
- 0)
-
-
-
-*
- simultaneous horizontal and vertical flipping of the image with subsequent shift and absolute difference calculation to check for a central symmetry (flipMode
- :math:`<`
- 0)
-
-
-
-*
- reversing the order of 1d point arrays (flipMode > 0)
-
-
-
-.. index:: fromarray
-
-.. _fromarray:
-
-fromarray
----------
-
-`id=0.461891381743 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/fromarray>`__
-
-
-.. function:: fromarray(object, allowND = False) -> CvMat
-
- Create a CvMat from an object that supports the array interface.
-
-
-
-
-
-
- :param object: Any object that supports the array interface
-
-
- :param allowND: If true, will return a CvMatND
-
-
-
-If the object supports the
-`array interface <http://docs.scipy.org/doc/numpy/reference/arrays.interface.html>`_
-,
-return a
-:ref:`CvMat`
-(
-``allowND = False``
-) or
-:ref:`CvMatND`
-(
-``allowND = True``
-).
-
-If
-``allowND = False``
-, then the object's array must be either 2D or 3D. If it is 2D, then the returned CvMat has a single channel. If it is 3D, then the returned CvMat will have N channels, where N is the last dimension of the array. In this case, N cannot be greater than OpenCV's channel limit,
-``CV_CN_MAX``
-.
-
-If
-``allowND = True``
-, then
-``fromarray``
-returns a single-channel
-:ref:`CvMatND`
-with the same shape as the original array.
-
-For example,
-`NumPy <http://numpy.scipy.org/>`_
-arrays support the array interface, so can be converted to OpenCV objects:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv, numpy
- >>> a = numpy.ones((480, 640))
- >>> mat = cv.fromarray(a)
- >>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
- (480, 640) 1
- >>> a = numpy.ones((480, 640, 3))
- >>> mat = cv.fromarray(a)
- >>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
- (480, 640) 3
- >>> a = numpy.ones((480, 640, 3))
- >>> mat = cv.fromarray(a, allowND = True)
- >>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
- (480, 640, 3) 1
-
-
-..
-
-
-.. index:: GEMM
-
-.. _GEMM:
-
-GEMM
-----
-
-`id=0.226896262418 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GEMM>`__
-
-
-.. function:: GEMM(src1,src2,alphs,src3,beta,dst,tABC=0)-> None
-
- Performs generalized matrix multiplication.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param src3: The third source array (shift). Can be NULL, if there is no shift.
-
- :type src3: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param tABC: The operation flags that can be 0 or a combination of the following values
-
- * **CV_GEMM_A_T** transpose src1
-
- * **CV_GEMM_B_T** transpose src2
-
- * **CV_GEMM_C_T** transpose src3
-
-
-
- For example, ``CV_GEMM_A_T+CV_GEMM_C_T`` corresponds to
-
- .. math::
-
- \texttt{alpha} \, \texttt{src1} ^T \, \texttt{src2} + \texttt{beta} \, \texttt{src3} ^T
-
-
-
- :type tABC: int
-
-
-
-The function performs generalized matrix multiplication:
-
-
-
-.. math::
-
- \texttt{dst} = \texttt{alpha} \, op( \texttt{src1} ) \, op( \texttt{src2} ) + \texttt{beta} \, op( \texttt{src3} ) \quad \text{where $op(X)$ is $X$ or $X^T$}
-
-
-All the matrices should have the same data type and coordinated sizes. Real or complex floating-point matrices are supported.
-
-
-.. index:: Get1D
-
-.. _Get1D:
-
-Get1D
------
-
-`id=0.16092985512 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Get1D>`__
-
-
-.. function:: Get1D(arr, idx) -> scalar
-
- Return a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx: Zero-based element index
-
- :type idx: int
-
-
-
-Return a specific array element. Array must have dimension 3.
-
-
-.. index:: Get2D
-
-.. _Get2D:
-
-Get2D
------
-
-`id=0.178216782696 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Get2D>`__
-
-
-.. function:: Get2D(arr, idx0, idx1) -> scalar
-
- Return a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element row index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element column index
-
- :type idx1: int
-
-
-
-Return a specific array element. Array must have dimension 2.
-
-
-.. index:: Get3D
-
-.. _Get3D:
-
-Get3D
------
-
-`id=0.467419402955 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Get3D>`__
-
-
-.. function:: Get3D(arr, idx0, idx1, idx2) -> scalar
-
- Return a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element index
-
- :type idx1: int
-
-
- :param idx2: Zero-based element index
-
- :type idx2: int
-
-
-
-Return a specific array element. Array must have dimension 3.
-
-
-.. index:: GetND
-
-.. _GetND:
-
-GetND
------
-
-`id=0.388189389578 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetND>`__
-
-
-.. function:: GetND(arr, indices) -> scalar
-
- Return a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param indices: List of zero-based element indices
-
- :type indices: sequence of int
-
-
-
-Return a specific array element. The length of array indices must be the same as the dimension of the array.
-
-
-.. index:: GetCol
-
-.. _GetCol:
-
-GetCol
-------
-
-`id=0.0086857000273 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetCol>`__
-
-
-.. function:: GetCol(arr,col)-> submat
-
- Returns array column.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param col: Zero-based index of the selected column
-
- :type col: int
-
-
- :param submat: resulting single-column array
-
- :type submat: :class:`CvMat`
-
-
-
-The function
-``GetCol``
-returns a single column from the input array.
-
-
-.. index:: GetCols
-
-.. _GetCols:
-
-GetCols
--------
-
-`id=0.531422054838 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetCols>`__
-
-
-.. function:: GetCols(arr,startCol,endCol)-> submat
-
- Returns array column span.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param startCol: Zero-based index of the starting column (inclusive) of the span
-
- :type startCol: int
-
-
- :param endCol: Zero-based index of the ending column (exclusive) of the span
-
- :type endCol: int
-
-
- :param submat: resulting multi-column array
-
- :type submat: :class:`CvMat`
-
-
-
-The function
-``GetCols``
-returns a column span from the input array.
-
-
-.. index:: GetDiag
-
-.. _GetDiag:
-
-GetDiag
--------
-
-`id=0.618051467399 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetDiag>`__
-
-
-.. function:: GetDiag(arr,diag=0)-> submat
-
- Returns one of array diagonals.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param submat: Pointer to the resulting sub-array header
-
- :type submat: :class:`CvMat`
-
-
- :param diag: Array diagonal. Zero corresponds to the main diagonal, -1 corresponds to the diagonal above the main , 1 corresponds to the diagonal below the main, and so forth.
-
- :type diag: int
-
-
-
-The function returns the header, corresponding to a specified diagonal of the input array.
-
-
-.. index:: GetDims
-
-.. _GetDims:
-
-GetDims
--------
-
-`id=0.525358080649 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetDims>`__
-
-
-.. function:: GetDims(arr)-> list
-
- Returns list of array dimensions
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
-
-The function returns a list of array dimensions.
-In the case of
-``IplImage``
-or
-:ref:`CvMat`
-it always
-returns a list of length 2.
-
-.. index:: GetElemType
-
-.. _GetElemType:
-
-GetElemType
------------
-
-`id=0.768019000289 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetElemType>`__
-
-
-.. function:: GetElemType(arr)-> int
-
- Returns type of array elements.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
-
-The function returns type of the array elements
-as described in
-:ref:`CreateMat`
-discussion:
-``CV_8UC1``
-...
-``CV_64FC4``
-.
-
-
-
-.. index:: GetImage
-
-.. _GetImage:
-
-GetImage
---------
-
-`id=0.47993624702 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetImage>`__
-
-
-.. function:: GetImage(arr) -> iplimage
-
- Returns image header for arbitrary array.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvMat`
-
-
-
-The function returns the image header for the input array
-that can be a matrix -
-:ref:`CvMat`
-, or an image -
-``IplImage*``
-. In
-the case of an image the function simply returns the input pointer. In the
-case of
-:ref:`CvMat`
-it initializes an
-``imageHeader``
-structure
-with the parameters of the input matrix. Note that if we transform
-``IplImage``
-to
-:ref:`CvMat`
-and then transform CvMat back to
-IplImage, we can get different headers if the ROI is set, and thus some
-IPL functions that calculate image stride from its width and align may
-fail on the resultant image.
-
-
-.. index:: GetImageCOI
-
-.. _GetImageCOI:
-
-GetImageCOI
------------
-
-`id=0.607250682733 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetImageCOI>`__
-
-
-.. function:: GetImageCOI(image)-> channel
-
- Returns the index of the channel of interest.
-
-
-
-
-
-
- :param image: A pointer to the image header
-
- :type image: :class:`IplImage`
-
-
-
-Returns the channel of interest of in an IplImage. Returned values correspond to the
-``coi``
-in
-:ref:`SetImageCOI`
-.
-
-
-.. index:: GetImageROI
-
-.. _GetImageROI:
-
-GetImageROI
------------
-
-`id=0.250295311742 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetImageROI>`__
-
-
-.. function:: GetImageROI(image)-> CvRect
-
- Returns the image ROI.
-
-
-
-
-
-
- :param image: A pointer to the image header
-
- :type image: :class:`IplImage`
-
-
-
-If there is no ROI set,
-``cvRect(0,0,image->width,image->height)``
-is returned.
-
-
-.. index:: GetMat
-
-.. _GetMat:
-
-GetMat
-------
-
-`id=0.598385813702 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetMat>`__
-
-
-.. function:: GetMat(arr, allowND=0) -> cvmat
-
- Returns matrix header for arbitrary array.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`IplImage`
-
-
- :param allowND: If non-zero, the function accepts multi-dimensional dense arrays (CvMatND*) and returns 2D (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or more than 2 dimensions). The array must be continuous.
-
- :type allowND: int
-
-
-
-The function returns a matrix header for the input array that can be a matrix -
-
-:ref:`CvMat`
-, an image -
-``IplImage``
-or a multi-dimensional dense array -
-:ref:`CvMatND`
-(latter case is allowed only if
-``allowND != 0``
-) . In the case of matrix the function simply returns the input pointer. In the case of
-``IplImage*``
-or
-:ref:`CvMatND`
-it initializes the
-``header``
-structure with parameters of the current image ROI and returns the pointer to this temporary structure. Because COI is not supported by
-:ref:`CvMat`
-, it is returned separately.
-
-The function provides an easy way to handle both types of arrays -
-``IplImage``
-and
-:ref:`CvMat`
-- using the same code. Reverse transform from
-:ref:`CvMat`
-to
-``IplImage``
-can be done using the
-:ref:`GetImage`
-function.
-
-Input array must have underlying data allocated or attached, otherwise the function fails.
-
-If the input array is
-``IplImage``
-with planar data layout and COI set, the function returns the pointer to the selected plane and COI = 0. It enables per-plane processing of multi-channel images with planar data layout using OpenCV functions.
-
-
-.. index:: GetOptimalDFTSize
-
-.. _GetOptimalDFTSize:
-
-GetOptimalDFTSize
------------------
-
-`id=0.579270276542 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetOptimalDFTSize>`__
-
-
-.. function:: GetOptimalDFTSize(size0)-> int
-
- Returns optimal DFT size for a given vector size.
-
-
-
-
-
-
- :param size0: Vector size
-
- :type size0: int
-
-
-
-The function returns the minimum number
-``N``
-that is greater than or equal to
-``size0``
-, such that the DFT
-of a vector of size
-``N``
-can be computed fast. In the current
-implementation
-:math:`N=2^p \times 3^q \times 5^r`
-, for some
-:math:`p`
-,
-:math:`q`
-,
-:math:`r`
-.
-
-The function returns a negative number if
-``size0``
-is too large
-(very close to
-``INT_MAX``
-)
-
-
-
-.. index:: GetReal1D
-
-.. _GetReal1D:
-
-GetReal1D
----------
-
-`id=0.0635428042823 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetReal1D>`__
-
-
-.. function:: GetReal1D(arr, idx0)->float
-
- Return a specific element of single-channel 1D array.
-
-
-
-
-
-
- :param arr: Input array. Must have a single channel.
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: The first zero-based component of the element index
-
- :type idx0: int
-
-
-
-Returns a specific element of a single-channel array. If the array has
-multiple channels, a runtime error is raised. Note that
-:ref:`Get`
-function can be used safely for both single-channel and multiple-channel
-arrays though they are a bit slower.
-
-In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).
-
-
-.. index:: GetReal2D
-
-.. _GetReal2D:
-
-GetReal2D
----------
-
-`id=0.703344141971 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetReal2D>`__
-
-
-.. function:: GetReal2D(arr, idx0, idx1)->float
-
- Return a specific element of single-channel 2D array.
-
-
-
-
-
-
- :param arr: Input array. Must have a single channel.
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: The first zero-based component of the element index
-
- :type idx0: int
-
-
- :param idx1: The second zero-based component of the element index
-
- :type idx1: int
-
-
-
-Returns a specific element of a single-channel array. If the array has
-multiple channels, a runtime error is raised. Note that
-:ref:`Get`
-function can be used safely for both single-channel and multiple-channel
-arrays though they are a bit slower.
-
-In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).
-
-
-.. index:: GetReal3D
-
-.. _GetReal3D:
-
-GetReal3D
----------
-
-`id=0.0745073340033 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetReal3D>`__
-
-
-.. function:: GetReal3D(arr, idx0, idx1, idx2)->float
-
- Return a specific element of single-channel array.
-
-
-
-
-
-
- :param arr: Input array. Must have a single channel.
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: The first zero-based component of the element index
-
- :type idx0: int
-
-
- :param idx1: The second zero-based component of the element index
-
- :type idx1: int
-
-
- :param idx2: The third zero-based component of the element index
-
- :type idx2: int
-
-
-
-Returns a specific element of a single-channel array. If the array has
-multiple channels, a runtime error is raised. Note that
-:ref:`Get`
-function can be used safely for both single-channel and multiple-channel
-arrays though they are a bit slower.
-
-In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).
-
-
-.. index:: GetRealND
-
-.. _GetRealND:
-
-GetRealND
----------
-
-`id=0.78364524074 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetRealND>`__
-
-
-.. function:: GetRealND(arr, idx)->float
-
- Return a specific element of single-channel array.
-
-
-
-
-
-
- :param arr: Input array. Must have a single channel.
-
- :type arr: :class:`CvArr`
-
-
- :param idx: Array of the element indices
-
- :type idx: sequence of int
-
-
-
-Returns a specific element of a single-channel array. If the array has
-multiple channels, a runtime error is raised. Note that
-:ref:`Get`
-function can be used safely for both single-channel and multiple-channel
-arrays though they are a bit slower.
-
-In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).
-
-
-
-.. index:: GetRow
-
-.. _GetRow:
-
-GetRow
-------
-
-`id=0.620110164228 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetRow>`__
-
-
-.. function:: GetRow(arr,row)-> submat
-
- Returns array row.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param row: Zero-based index of the selected row
-
- :type row: int
-
-
- :param submat: resulting single-row array
-
- :type submat: :class:`CvMat`
-
-
-
-The function
-``GetRow``
-returns a single row from the input array.
-
-
-.. index:: GetRows
-
-.. _GetRows:
-
-GetRows
--------
-
-`id=0.517309680249 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetRows>`__
-
-
-.. function:: GetRows(arr,startRow,endRow,deltaRow=1)-> submat
-
- Returns array row span.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param startRow: Zero-based index of the starting row (inclusive) of the span
-
- :type startRow: int
-
-
- :param endRow: Zero-based index of the ending row (exclusive) of the span
-
- :type endRow: int
-
-
- :param deltaRow: Index step in the row span.
-
- :type deltaRow: int
-
-
- :param submat: resulting multi-row array
-
- :type submat: :class:`CvMat`
-
-
-
-The function
-``GetRows``
-returns a row span from the input array.
-
-
-.. index:: GetSize
-
-.. _GetSize:
-
-GetSize
--------
-
-`id=0.506280741239 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetSize>`__
-
-
-.. function:: GetSize(arr)-> CvSize
-
- Returns size of matrix or image ROI.
-
-
-
-
-
-
- :param arr: array header
-
- :type arr: :class:`CvArr`
-
-
-
-The function returns number of rows (CvSize::height) and number of columns (CvSize::width) of the input matrix or image. In the case of image the size of ROI is returned.
-
-
-
-.. index:: GetSubRect
-
-.. _GetSubRect:
-
-GetSubRect
-----------
-
-`id=0.408880599874 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetSubRect>`__
-
-
-.. function:: GetSubRect(arr, rect) -> cvmat
-
- Returns matrix header corresponding to the rectangular sub-array of input image or matrix.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param rect: Zero-based coordinates of the rectangle of interest
-
- :type rect: :class:`CvRect`
-
-
-
-The function returns header, corresponding to
-a specified rectangle of the input array. In other words, it allows
-the user to treat a rectangular part of input array as a stand-alone
-array. ROI is taken into account by the function so the sub-array of
-ROI is actually extracted.
-
-
-.. index:: InRange
-
-.. _InRange:
-
-InRange
--------
-
-`id=0.258662288796 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/InRange>`__
-
-
-.. function:: InRange(src,lower,upper,dst)-> None
-
- Checks that array elements lie between the elements of two other arrays.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param lower: The inclusive lower boundary array
-
- :type lower: :class:`CvArr`
-
-
- :param upper: The exclusive upper boundary array
-
- :type upper: :class:`CvArr`
-
-
- :param dst: The destination array, must have 8u or 8s type
-
- :type dst: :class:`CvArr`
-
-
-
-The function does the range check for every element of the input array:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{lower} (I)_0 <= \texttt{src} (I)_0 < \texttt{upper} (I)_0
-
-
-For single-channel arrays,
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{lower} (I)_0 <= \texttt{src} (I)_0 < \texttt{upper} (I)_0 \land \texttt{lower} (I)_1 <= \texttt{src} (I)_1 < \texttt{upper} (I)_1
-
-
-For two-channel arrays and so forth,
-
-dst(I) is set to 0xff (all
-``1``
--bits) if src(I) is within the range and 0 otherwise. All the arrays must have the same type, except the destination, and the same size (or ROI size).
-
-
-
-.. index:: InRangeS
-
-.. _InRangeS:
-
-InRangeS
---------
-
-`id=0.79237633038 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/InRangeS>`__
-
-
-.. function:: InRangeS(src,lower,upper,dst)-> None
-
- Checks that array elements lie between two scalars.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param lower: The inclusive lower boundary
-
- :type lower: :class:`CvScalar`
-
-
- :param upper: The exclusive upper boundary
-
- :type upper: :class:`CvScalar`
-
-
- :param dst: The destination array, must have 8u or 8s type
-
- :type dst: :class:`CvArr`
-
-
-
-The function does the range check for every element of the input array:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{lower} _0 <= \texttt{src} (I)_0 < \texttt{upper} _0
-
-
-For single-channel arrays,
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{lower} _0 <= \texttt{src} (I)_0 < \texttt{upper} _0 \land \texttt{lower} _1 <= \texttt{src} (I)_1 < \texttt{upper} _1
-
-
-For two-channel arrays nd so forth,
-
-'dst(I)' is set to 0xff (all
-``1``
--bits) if 'src(I)' is within the range and 0 otherwise. All the arrays must have the same size (or ROI size).
-
-
-.. index:: InvSqrt
-
-.. _InvSqrt:
-
-InvSqrt
--------
-
-`id=0.147001602145 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/InvSqrt>`__
-
-
-.. function:: InvSqrt(value)-> float
-
- Calculates the inverse square root.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-The function calculates the inverse square root of the argument, and normally it is faster than
-``1./sqrt(value)``
-. If the argument is zero or negative, the result is not determined. Special values (
-:math:`\pm \infty`
-, NaN) are not handled.
-
-
-.. index:: Inv
-
-.. _Inv:
-
-Inv
----
-
-`id=0.269085828489 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Inv>`__
-
-
-:ref:`Invert`
-
-.. index::
-
-.. _:
-
-
-
-
-`id=0.192046413816 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/>`__
-
-
-.. function:: Invert(src,dst,method=CV_LU)-> double
-
- Finds the inverse or pseudo-inverse of a matrix.
-
-
-
-
-
-
- :param src: The source matrix
-
-
- :param dst: The destination matrix
-
-
- :param method: Inversion method
-
-
- * **CV_LU** Gaussian elimination with optimal pivot element chosen
-
-
- * **CV_SVD** Singular value decomposition (SVD) method
-
-
- * **CV_SVD_SYM** SVD method for a symmetric positively-defined matrix
-
-
-
-
-
-The function inverts matrix
-``src1``
-and stores the result in
-``src2``
-.
-
-In the case of
-``LU``
-method, the function returns the
-``src1``
-determinant (src1 must be square). If it is 0, the matrix is not inverted and
-``src2``
-is filled with zeros.
-
-In the case of
-``SVD``
-methods, the function returns the inversed condition of
-``src1``
-(ratio of the smallest singular value to the largest singular value) and 0 if
-``src1``
-is all zeros. The SVD methods calculate a pseudo-inverse matrix if
-``src1``
-is singular.
-
-
-
-.. index:: IsInf
-
-.. _IsInf:
-
-IsInf
------
-
-`id=0.525461990241 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/IsInf>`__
-
-
-.. function:: IsInf(value)-> int
-
- Determines if the argument is Infinity.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-The function returns 1 if the argument is
-:math:`\pm \infty`
-(as defined by IEEE754 standard), 0 otherwise.
-
-
-.. index:: IsNaN
-
-.. _IsNaN:
-
-IsNaN
------
-
-`id=0.476453204062 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/IsNaN>`__
-
-
-.. function:: IsNaN(value)-> int
-
- Determines if the argument is Not A Number.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-The function returns 1 if the argument is Not A Number (as defined by IEEE754 standard), 0 otherwise.
-
-
-
-.. index:: LUT
-
-.. _LUT:
-
-LUT
----
-
-`id=0.794484999286 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/LUT>`__
-
-
-.. function:: LUT(src,dst,lut)-> None
-
- Performs a look-up table transform of an array.
-
-
-
-
-
-
- :param src: Source array of 8-bit elements
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array of a given depth and of the same number of channels as the source array
-
- :type dst: :class:`CvArr`
-
-
- :param lut: Look-up table of 256 elements; should have the same depth as the destination array. In the case of multi-channel source and destination arrays, the table should either have a single-channel (in this case the same table is used for all channels) or the same number of channels as the source/destination array.
-
- :type lut: :class:`CvArr`
-
-
-
-The function fills the destination array with values from the look-up table. Indices of the entries are taken from the source array. That is, the function processes each element of
-``src``
-as follows:
-
-
-
-.. math::
-
- \texttt{dst} _i \leftarrow \texttt{lut} _{ \texttt{src} _i + d}
-
-
-where
-
-
-
-.. math::
-
- d = \fork{0}{if \texttt{src} has depth \texttt{CV\_8U}}{128}{if \texttt{src} has depth \texttt{CV\_8S}}
-
-
-
-.. index:: Log
-
-.. _Log:
-
-Log
----
-
-`id=0.651801543806 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Log>`__
-
-
-.. function:: Log(src,dst)-> None
-
- Calculates the natural logarithm of every array element's absolute value.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array, it should have ``double`` type or the same type as the source
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates the natural logarithm of the absolute value of every element of the input array:
-
-
-
-.. math::
-
- \texttt{dst} [I] = \fork{\log{|\texttt{src}(I)}}{if $\texttt{src}[I] \ne 0$ }{\texttt{C}}{otherwise}
-
-
-Where
-``C``
-is a large negative number (about -700 in the current implementation).
-
-
-.. index:: Mahalanobis
-
-.. _Mahalanobis:
-
-Mahalanobis
------------
-
-`id=0.523778731752 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Mahalanobis>`__
-
-
-.. function:: Mahalonobis(vec1,vec2,mat)-> None
-
- Calculates the Mahalanobis distance between two vectors.
-
-
-
-
-
-
- :param vec1: The first 1D source vector
-
-
- :param vec2: The second 1D source vector
-
-
- :param mat: The inverse covariance matrix
-
-
-
-The function calculates and returns the weighted distance between two vectors:
-
-
-
-.. math::
-
- d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }
-
-
-The covariance matrix may be calculated using the
-:ref:`CalcCovarMatrix`
-function and further inverted using the
-:ref:`Invert`
-function (CV
-_
-SVD method is the prefered one because the matrix might be singular).
-
-
-
-.. index:: Max
-
-.. _Max:
-
-Max
----
-
-`id=0.733148172089 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Max>`__
-
-
-.. function:: Max(src1,src2,dst)-> None
-
- Finds per-element maximum of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates per-element maximum of two arrays:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))
-
-
-All the arrays must have a single channel, the same data type and the same size (or ROI size).
-
-
-
-.. index:: MaxS
-
-.. _MaxS:
-
-MaxS
-----
-
-`id=0.953316700142 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MaxS>`__
-
-
-.. function:: MaxS(src,value,dst)-> None
-
- Finds per-element maximum of array and scalar.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param value: The scalar value
-
- :type value: float
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates per-element maximum of array and scalar:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \max ( \texttt{src} (I), \texttt{value} )
-
-
-All the arrays must have a single channel, the same data type and the same size (or ROI size).
-
-
-
-.. index:: Merge
-
-.. _Merge:
-
-Merge
------
-
-`id=0.00147544047998 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Merge>`__
-
-
-.. function:: Merge(src0,src1,src2,src3,dst)-> None
-
- Composes a multi-channel array from several single-channel arrays or inserts a single channel into the array.
-
-
-
-
-
-
- :param src0: Input channel 0
-
- :type src0: :class:`CvArr`
-
-
- :param src1: Input channel 1
-
- :type src1: :class:`CvArr`
-
-
- :param src2: Input channel 2
-
- :type src2: :class:`CvArr`
-
-
- :param src3: Input channel 3
-
- :type src3: :class:`CvArr`
-
-
- :param dst: Destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function is the opposite to
-:ref:`Split`
-. If the destination array has N channels then if the first N input channels are not NULL, they all are copied to the destination array; if only a single source channel of the first N is not NULL, this particular channel is copied into the destination array; otherwise an error is raised. The rest of the source channels (beyond the first N) must always be NULL. For IplImage
-:ref:`Copy`
-with COI set can be also used to insert a single channel into the image.
-
-
-.. index:: Min
-
-.. _Min:
-
-Min
----
-
-`id=0.262439732431 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Min>`__
-
-
-.. function:: Min(src1,src2,dst)-> None
-
- Finds per-element minimum of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates per-element minimum of two arrays:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))
-
-
-All the arrays must have a single channel, the same data type and the same size (or ROI size).
-
-
-
-.. index:: MinMaxLoc
-
-.. _MinMaxLoc:
-
-MinMaxLoc
----------
-
-`id=0.173746310408 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MinMaxLoc>`__
-
-
-.. function:: MinMaxLoc(arr,mask=NULL)-> (minVal,maxVal,minLoc,maxLoc)
-
- Finds global minimum and maximum in array or subarray.
-
-
-
-
-
-
- :param arr: The source array, single-channel or multi-channel with COI set
-
- :type arr: :class:`CvArr`
-
-
- :param minVal: Pointer to returned minimum value
-
- :type minVal: float
-
-
- :param maxVal: Pointer to returned maximum value
-
- :type maxVal: float
-
-
- :param minLoc: Pointer to returned minimum location
-
- :type minLoc: :class:`CvPoint`
-
-
- :param maxLoc: Pointer to returned maximum location
-
- :type maxLoc: :class:`CvPoint`
-
-
- :param mask: The optional mask used to select a subarray
-
- :type mask: :class:`CvArr`
-
-
-
-The function finds minimum and maximum element values
-and their positions. The extremums are searched across the whole array,
-selected
-``ROI``
-(in the case of
-``IplImage``
-) or, if
-``mask``
-is not
-``NULL``
-, in the specified array region. If the array has
-more than one channel, it must be
-``IplImage``
-with
-``COI``
-set. In the case of multi-dimensional arrays,
-``minLoc->x``
-and
-``maxLoc->x``
-will contain raw (linear) positions of the extremums.
-
-
-.. index:: MinS
-
-.. _MinS:
-
-MinS
-----
-
-`id=0.607133270067 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MinS>`__
-
-
-.. function:: MinS(src,value,dst)-> None
-
- Finds per-element minimum of an array and a scalar.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param value: The scalar value
-
- :type value: float
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates minimum of an array and a scalar:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \min ( \texttt{src} (I), \texttt{value} )
-
-
-All the arrays must have a single channel, the same data type and the same size (or ROI size).
-
-
-
-Mirror
-------
-
-
-Synonym for
-:ref:`Flip`
-.
-
-
-.. index:: MixChannels
-
-.. _MixChannels:
-
-MixChannels
------------
-
-`id=0.433721295926 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MixChannels>`__
-
-
-.. function:: MixChannels(src, dst, fromTo) -> None
-
- Copies several channels from input arrays to certain channels of output arrays
-
-
-
-
-
-
- :param src: Input arrays
-
- :type src: :class:`cvarr_count`
-
-
- :param dst: Destination arrays
-
- :type dst: :class:`cvarr_count`
-
-
- :param fromTo: The array of pairs of indices of the planes
- copied. Each pair ``fromTo[k]=(i,j)``
- means that i-th plane from ``src`` is copied to the j-th plane in ``dst`` , where continuous
- plane numbering is used both in the input array list and the output array list.
- As a special case, when the ``fromTo[k][0]`` is negative, the corresponding output plane ``j``
- is filled with zero.
-
- :type fromTo: :class:`intpair`
-
-
-
-The function is a generalized form of
-:ref:`cvSplit`
-and
-:ref:`Merge`
-and some forms of
-:ref:`CvtColor`
-. It can be used to change the order of the
-planes, add/remove alpha channel, extract or insert a single plane or
-multiple planes etc.
-
-As an example, this code splits a 4-channel RGBA image into a 3-channel
-BGR (i.e. with R and B swapped) and separate alpha channel image:
-
-
-
-
-::
-
-
-
- rgba = cv.CreateMat(100, 100, cv.CV_8UC4)
- bgr = cv.CreateMat(100, 100, cv.CV_8UC3)
- alpha = cv.CreateMat(100, 100, cv.CV_8UC1)
- cv.Set(rgba, (1,2,3,4))
- cv.MixChannels([rgba], [bgr, alpha], [
- (0, 2), # rgba[0] -> bgr[2]
- (1, 1), # rgba[1] -> bgr[1]
- (2, 0), # rgba[2] -> bgr[0]
- (3, 3) # rgba[3] -> alpha[0]
- ])
-
-
-..
-
-
-MulAddS
--------
-
-
-Synonym for
-:ref:`ScaleAdd`
-.
-
-
-.. index:: Mul
-
-.. _Mul:
-
-Mul
----
-
-`id=0.129939418647 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Mul>`__
-
-
-.. function:: Mul(src1,src2,dst,scale)-> None
-
- Calculates the per-element product of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param scale: Optional scale factor
-
- :type scale: float
-
-
-
-The function calculates the per-element product of two arrays:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I)
-
-
-All the arrays must have the same type and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-.. index:: MulSpectrums
-
-.. _MulSpectrums:
-
-MulSpectrums
-------------
-
-`id=0.811171034483 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MulSpectrums>`__
-
-
-.. function:: MulSpectrums(src1,src2,dst,flags)-> None
-
- Performs per-element multiplication of two Fourier spectrums.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array of the same type and the same size as the source arrays
-
- :type dst: :class:`CvArr`
-
-
- :param flags: A combination of the following values;
-
- * **CV_DXT_ROWS** treats each row of the arrays as a separate spectrum (see :ref:`DFT` parameters description).
-
- * **CV_DXT_MUL_CONJ** conjugate the second source array before the multiplication.
-
-
-
- :type flags: int
-
-
-
-The function performs per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform.
-
-The function, together with
-:ref:`DFT`
-, may be used to calculate convolution of two arrays rapidly.
-
-
-
-.. index:: MulTransposed
-
-.. _MulTransposed:
-
-MulTransposed
--------------
-
-`id=0.796123116677 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/MulTransposed>`__
-
-
-.. function:: MulTransposed(src,dst,order,delta=NULL,scale)-> None
-
- Calculates the product of an array and a transposed array.
-
-
-
-
-
-
- :param src: The source matrix
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination matrix. Must be ``CV_32F`` or ``CV_64F`` .
-
- :type dst: :class:`CvArr`
-
-
- :param order: Order of multipliers
-
- :type order: int
-
-
- :param delta: An optional array, subtracted from ``src`` before multiplication
-
- :type delta: :class:`CvArr`
-
-
- :param scale: An optional scaling
-
- :type scale: float
-
-
-
-The function calculates the product of src and its transposition:
-
-
-
-.. math::
-
- \texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T
-
-
-if
-:math:`\texttt{order}=0`
-, and
-
-
-
-.. math::
-
- \texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )
-
-
-otherwise.
-
-
-.. index:: Norm
-
-.. _Norm:
-
-Norm
-----
-
-`id=0.985970461005 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Norm>`__
-
-
-.. function:: Norm(arr1,arr2,normType=CV_L2,mask=NULL)-> double
-
- Calculates absolute array norm, absolute difference norm, or relative difference norm.
-
-
-
-
-
-
- :param arr1: The first source image
-
- :type arr1: :class:`CvArr`
-
-
- :param arr2: The second source image. If it is NULL, the absolute norm of ``arr1`` is calculated, otherwise the absolute or relative norm of ``arr1`` - ``arr2`` is calculated.
-
- :type arr2: :class:`CvArr`
-
-
- :param normType: Type of norm, see the discussion
-
- :type normType: int
-
-
- :param mask: The optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates the absolute norm of
-``arr1``
-if
-``arr2``
-is NULL:
-
-
-.. math::
-
- norm = \forkthree{||\texttt{arr1}||_C = \max_I |\texttt{arr1}(I)|}{if $\texttt{normType} = \texttt{CV\_C}$}{||\texttt{arr1}||_{L1} = \sum_I |\texttt{arr1}(I)|}{if $\texttt{normType} = \texttt{CV\_L1}$}{||\texttt{arr1}||_{L2} = \sqrt{\sum_I \texttt{arr1}(I)^2}}{if $\texttt{normType} = \texttt{CV\_L2}$}
-
-
-or the absolute difference norm if
-``arr2``
-is not NULL:
-
-
-.. math::
-
- norm = \forkthree{||\texttt{arr1}-\texttt{arr2}||_C = \max_I |\texttt{arr1}(I) - \texttt{arr2}(I)|}{if $\texttt{normType} = \texttt{CV\_C}$}{||\texttt{arr1}-\texttt{arr2}||_{L1} = \sum_I |\texttt{arr1}(I) - \texttt{arr2}(I)|}{if $\texttt{normType} = \texttt{CV\_L1}$}{||\texttt{arr1}-\texttt{arr2}||_{L2} = \sqrt{\sum_I (\texttt{arr1}(I) - \texttt{arr2}(I))^2}}{if $\texttt{normType} = \texttt{CV\_L2}$}
-
-
-or the relative difference norm if
-``arr2``
-is not NULL and
-``(normType & CV_RELATIVE) != 0``
-:
-
-
-
-.. math::
-
- norm = \forkthree{\frac{||\texttt{arr1}-\texttt{arr2}||_C }{||\texttt{arr2}||_C }}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_C}$}{\frac{||\texttt{arr1}-\texttt{arr2}||_{L1} }{||\texttt{arr2}||_{L1}}}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_L1}$}{\frac{||\texttt{arr1}-\texttt{arr2}||_{L2} }{||\texttt{arr2}||_{L2}}}{if $\texttt{normType} = \texttt{CV\_RELATIVE\_L2}$}
-
-
-The function returns the calculated norm. A multiple-channel array is treated as a single-channel, that is, the results for all channels are combined.
-
-
-.. index:: Not
-
-.. _Not:
-
-Not
----
-
-`id=0.541517301459 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Not>`__
-
-
-.. function:: Not(src,dst)-> None
-
- Performs per-element bit-wise inversion of array elements.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function Not inverses every bit of every array element:
-
-
-
-
-::
-
-
-
- dst(I)=~src(I)
-
-
-..
-
-
-.. index:: Or
-
-.. _Or:
-
-Or
---
-
-`id=0.0467854422514 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Or>`__
-
-
-.. function:: Or(src1,src2,dst,mask=NULL)-> None
-
- Calculates per-element bit-wise disjunction of two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates per-element bit-wise disjunction of two arrays:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)|src2(I)
-
-
-..
-
-In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size.
-
-
-.. index:: OrS
-
-.. _OrS:
-
-OrS
----
-
-`id=0.33757897546 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/OrS>`__
-
-
-.. function:: OrS(src,value,dst,mask=NULL)-> None
-
- Calculates a per-element bit-wise disjunction of an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Scalar to use in the operation
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function OrS calculates per-element bit-wise disjunction of an array and a scalar:
-
-
-
-
-::
-
-
-
- dst(I)=src(I)|value if mask(I)!=0
-
-
-..
-
-Prior to the actual operation, the scalar is converted to the same type as that of the array(s). In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size.
-
-
-
-.. index:: PerspectiveTransform
-
-.. _PerspectiveTransform:
-
-PerspectiveTransform
---------------------
-
-`id=0.118343635456 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/PerspectiveTransform>`__
-
-
-.. function:: PerspectiveTransform(src,dst,mat)-> None
-
- Performs perspective matrix transformation of a vector array.
-
-
-
-
-
-
- :param src: The source three-channel floating-point array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination three-channel floating-point array
-
- :type dst: :class:`CvArr`
-
-
- :param mat: :math:`3\times 3` or :math:`4 \times 4` transformation matrix
-
- :type mat: :class:`CvMat`
-
-
-
-The function transforms every element of
-``src``
-(by treating it as 2D or 3D vector) in the following way:
-
-
-
-.. math::
-
- (x, y, z) \rightarrow (x'/w, y'/w, z'/w)
-
-
-where
-
-
-
-.. math::
-
- (x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}
-
-
-and
-
-
-.. math::
-
- w = \fork{w'}{if $w' \ne 0$}{\infty}{otherwise}
-
-
-
-.. index:: PolarToCart
-
-.. _PolarToCart:
-
-PolarToCart
------------
-
-`id=0.200095825311 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/PolarToCart>`__
-
-
-.. function:: PolarToCart(magnitude,angle,x,y,angleInDegrees=0)-> None
-
- Calculates Cartesian coordinates of 2d vectors represented in polar form.
-
-
-
-
-
-
- :param magnitude: The array of magnitudes. If it is NULL, the magnitudes are assumed to be all 1's.
-
- :type magnitude: :class:`CvArr`
-
-
- :param angle: The array of angles, whether in radians or degrees
-
- :type angle: :class:`CvArr`
-
-
- :param x: The destination array of x-coordinates, may be set to NULL if it is not needed
-
- :type x: :class:`CvArr`
-
-
- :param y: The destination array of y-coordinates, mau be set to NULL if it is not needed
-
- :type y: :class:`CvArr`
-
-
- :param angleInDegrees: The flag indicating whether the angles are measured in radians, which is default mode, or in degrees
-
- :type angleInDegrees: int
-
-
-
-The function calculates either the x-coodinate, y-coordinate or both of every vector
-``magnitude(I)*exp(angle(I)*j), j=sqrt(-1)``
-:
-
-
-
-
-::
-
-
-
- x(I)=magnitude(I)*cos(angle(I)),
- y(I)=magnitude(I)*sin(angle(I))
-
-
-..
-
-
-.. index:: Pow
-
-.. _Pow:
-
-Pow
----
-
-`id=0.851609417669 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Pow>`__
-
-
-.. function:: Pow(src,dst,power)-> None
-
- Raises every array element to a power.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array, should be the same type as the source
-
- :type dst: :class:`CvArr`
-
-
- :param power: The exponent of power
-
- :type power: float
-
-
-
-The function raises every element of the input array to
-``p``
-:
-
-
-
-.. math::
-
- \texttt{dst} [I] = \fork{\texttt{src}(I)^p}{if \texttt{p} is integer}{|\texttt{src}(I)^p|}{otherwise}
-
-
-That is, for a non-integer power exponent the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations, as the following example, computing the cube root of array elements, shows:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> src = cv.CreateMat(1, 10, cv.CV_32FC1)
- >>> mask = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
- >>> dst = cv.CreateMat(src.rows, src.cols, cv.CV_32FC1)
- >>> cv.CmpS(src, 0, mask, cv.CV_CMP_LT) # find negative elements
- >>> cv.Pow(src, dst, 1. / 3)
- >>> cv.SubRS(dst, cv.ScalarAll(0), dst, mask) # negate the results of negative inputs
-
-
-..
-
-For some values of
-``power``
-, such as integer values, 0.5, and -0.5, specialized faster algorithms are used.
-
-
-.. index:: RNG
-
-.. _RNG:
-
-RNG
----
-
-`id=0.135992872937 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/RNG>`__
-
-
-.. function:: RNG(seed=-1LL)-> CvRNG
-
- Initializes a random number generator state.
-
-
-
-
-
-
- :param seed: 64-bit value used to initiate a random sequence
-
- :type seed: :class:`int64`
-
-
-
-The function initializes a random number generator
-and returns the state. The pointer to the state can be then passed to the
-:ref:`RandInt`
-,
-:ref:`RandReal`
-and
-:ref:`RandArr`
-functions. In the
-current implementation a multiply-with-carry generator is used.
-
-
-.. index:: RandArr
-
-.. _RandArr:
-
-RandArr
--------
-
-`id=0.371767350984 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/RandArr>`__
-
-
-.. function:: RandArr(rng,arr,distType,param1,param2)-> None
-
- Fills an array with random numbers and updates the RNG state.
-
-
-
-
-
-
- :param rng: RNG state initialized by :ref:`RNG`
-
- :type rng: :class:`CvRNG`
-
-
- :param arr: The destination array
-
- :type arr: :class:`CvArr`
-
-
- :param distType: Distribution type
-
- * **CV_RAND_UNI** uniform distribution
-
- * **CV_RAND_NORMAL** normal or Gaussian distribution
-
-
-
- :type distType: int
-
-
- :param param1: The first parameter of the distribution. In the case of a uniform distribution it is the inclusive lower boundary of the random numbers range. In the case of a normal distribution it is the mean value of the random numbers.
-
- :type param1: :class:`CvScalar`
-
-
- :param param2: The second parameter of the distribution. In the case of a uniform distribution it is the exclusive upper boundary of the random numbers range. In the case of a normal distribution it is the standard deviation of the random numbers.
-
- :type param2: :class:`CvScalar`
-
-
-
-The function fills the destination array with uniformly
-or normally distributed random numbers.
-
-
-.. index:: RandInt
-
-.. _RandInt:
-
-RandInt
--------
-
-`id=0.279691735983 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/RandInt>`__
-
-
-.. function:: RandInt(rng)-> unsigned
-
- Returns a 32-bit unsigned integer and updates RNG.
-
-
-
-
-
-
- :param rng: RNG state initialized by ``RandInit`` and, optionally, customized by ``RandSetRange`` (though, the latter function does not affect the discussed function outcome)
-
- :type rng: :class:`CvRNG`
-
-
-
-The function returns a uniformly-distributed random
-32-bit unsigned integer and updates the RNG state. It is similar to the rand()
-function from the C runtime library, but it always generates a 32-bit number
-whereas rand() returns a number in between 0 and
-``RAND_MAX``
-which is
-:math:`2^{16}`
-or
-:math:`2^{32}`
-, depending on the platform.
-
-The function is useful for generating scalar random numbers, such as
-points, patch sizes, table indices, etc., where integer numbers of a certain
-range can be generated using a modulo operation and floating-point numbers
-can be generated by scaling from 0 to 1 or any other specific range.
-
-
-.. index:: RandReal
-
-.. _RandReal:
-
-RandReal
---------
-
-`id=0.391748221323 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/RandReal>`__
-
-
-.. function:: RandReal(rng)-> double
-
- Returns a floating-point random number and updates RNG.
-
-
-
-
-
-
- :param rng: RNG state initialized by :ref:`RNG`
-
- :type rng: :class:`CvRNG`
-
-
-
-The function returns a uniformly-distributed random floating-point number between 0 and 1 (1 is not included).
-
-
-.. index:: Reduce
-
-.. _Reduce:
-
-Reduce
-------
-
-`id=0.208464357783 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Reduce>`__
-
-
-.. function:: Reduce(src,dst,dim=-1,op=CV_REDUCE_SUM)-> None
-
- Reduces a matrix to a vector.
-
-
-
-
-
-
- :param src: The input matrix.
-
- :type src: :class:`CvArr`
-
-
- :param dst: The output single-row/single-column vector that accumulates somehow all the matrix rows/columns.
-
- :type dst: :class:`CvArr`
-
-
- :param dim: The dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row, 1 means that the matrix is reduced to a single column and -1 means that the dimension is chosen automatically by analysing the dst size.
-
- :type dim: int
-
-
- :param op: The reduction operation. It can take of the following values:
-
- * **CV_REDUCE_SUM** The output is the sum of all of the matrix's rows/columns.
-
- * **CV_REDUCE_AVG** The output is the mean vector of all of the matrix's rows/columns.
-
- * **CV_REDUCE_MAX** The output is the maximum (column/row-wise) of all of the matrix's rows/columns.
-
- * **CV_REDUCE_MIN** The output is the minimum (column/row-wise) of all of the matrix's rows/columns.
-
-
-
- :type op: int
-
-
-
-The function reduces matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of an raster image. In the case of
-``CV_REDUCE_SUM``
-and
-``CV_REDUCE_AVG``
-the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.
-
-
-.. index:: Repeat
-
-.. _Repeat:
-
-Repeat
-------
-
-`id=0.376304633895 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Repeat>`__
-
-
-.. function:: Repeat(src,dst)-> None
-
- Fill the destination array with repeated copies of the source array.
-
-
-
-
-
-
- :param src: Source array, image or matrix
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array, image or matrix
-
- :type dst: :class:`CvArr`
-
-
-
-The function fills the destination array with repeated copies of the source array:
-
-
-
-
-::
-
-
-
- dst(i,j)=src(i mod rows(src), j mod cols(src))
-
-
-..
-
-So the destination array may be as larger as well as smaller than the source array.
-
-
-.. index:: ResetImageROI
-
-.. _ResetImageROI:
-
-ResetImageROI
--------------
-
-`id=0.764488576539 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ResetImageROI>`__
-
-
-.. function:: ResetImageROI(image)-> None
-
- Resets the image ROI to include the entire image and releases the ROI structure.
-
-
-
-
-
-
- :param image: A pointer to the image header
-
- :type image: :class:`IplImage`
-
-
-
-This produces a similar result to the following
-
-
-
-::
-
-
-
- cv.SetImageROI(image, (0, 0, image.width, image.height))
- cv.SetImageCOI(image, 0)
-
-
-..
-
-
-.. index:: Reshape
-
-.. _Reshape:
-
-Reshape
--------
-
-`id=0.474450183637 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Reshape>`__
-
-
-.. function:: Reshape(arr, newCn, newRows=0) -> cvmat
-
- Changes shape of matrix/image without copying data.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param newCn: New number of channels. 'newCn = 0' means that the number of channels remains unchanged.
-
- :type newCn: int
-
-
- :param newRows: New number of rows. 'newRows = 0' means that the number of rows remains unchanged unless it needs to be changed according to ``newCn`` value.
-
- :type newRows: int
-
-
-
-The function initializes the CvMat header so that it points to the same data as the original array but has a different shape - different number of channels, different number of rows, or both.
-
-
-.. index:: ReshapeMatND
-
-.. _ReshapeMatND:
-
-ReshapeMatND
-------------
-
-`id=0.916374204208 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ReshapeMatND>`__
-
-
-.. function:: ReshapeMatND(arr, newCn, newDims) -> cvmat
-
- Changes the shape of a multi-dimensional array without copying the data.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvMat`
-
-
- :param newCn: New number of channels. :math:`\texttt{newCn} = 0` means that the number of channels remains unchanged.
-
- :type newCn: int
-
-
- :param newDims: List of new dimensions.
-
- :type newDims: sequence of int
-
-
-
-Returns a new
-:ref:`CvMatND`
-that shares the same data as
-``arr``
-but has different dimensions or number of channels. The only requirement
-is that the total length of the data is unchanged.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> mat = cv.CreateMatND([24], cv.CV_32FC1)
- >>> print cv.GetDims(cv.ReshapeMatND(mat, 0, [8, 3]))
- (8, 3)
- >>> m2 = cv.ReshapeMatND(mat, 4, [3, 2])
- >>> print cv.GetDims(m2)
- (3, 2)
- >>> print m2.channels
- 4
-
-
-..
-
-
-.. index:: Round
-
-.. _Round:
-
-Round
------
-
-`id=0.62786499527 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Round>`__
-
-
-.. function:: Round(value) -> int
-
- Converts a floating-point number to the nearest integer value.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-On some architectures this function is much faster than the standard cast
-operations. If the absolute value of the argument is greater than
-:math:`2^{31}`
-, the result is not determined. Special values (
-:math:`\pm \infty`
-, NaN)
-are not handled.
-
-
-.. index:: Floor
-
-.. _Floor:
-
-Floor
------
-
-`id=0.303863189568 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Floor>`__
-
-
-.. function:: Floor(value) -> int
-
- Converts a floating-point number to the nearest integer value that is not larger than the argument.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-On some architectures this function is much faster than the standard cast
-operations. If the absolute value of the argument is greater than
-:math:`2^{31}`
-, the result is not determined. Special values (
-:math:`\pm \infty`
-, NaN)
-are not handled.
-
-
-.. index:: Ceil
-
-.. _Ceil:
-
-Ceil
-----
-
-`id=0.936674403829 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Ceil>`__
-
-
-.. function:: Ceil(value) -> int
-
- Converts a floating-point number to the nearest integer value that is not smaller than the argument.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-On some architectures this function is much faster than the standard cast
-operations. If the absolute value of the argument is greater than
-:math:`2^{31}`
-, the result is not determined. Special values (
-:math:`\pm \infty`
-, NaN)
-are not handled.
-
-
-.. index:: ScaleAdd
-
-.. _ScaleAdd:
-
-ScaleAdd
---------
-
-`id=0.543777958722 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/ScaleAdd>`__
-
-
-.. function:: ScaleAdd(src1,scale,src2,dst)-> None
-
- Calculates the sum of a scaled array and another array.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param scale: Scale factor for the first array
-
- :type scale: :class:`CvScalar`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
-
-The function calculates the sum of a scaled array and another array:
-
-
-
-.. math::
-
- \texttt{dst} (I)= \texttt{scale} \, \texttt{src1} (I) + \texttt{src2} (I)
-
-
-All array parameters should have the same type and the same size.
-
-
-.. index:: Set
-
-.. _Set:
-
-Set
----
-
-`id=0.311911914724 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Set>`__
-
-
-.. function:: Set(arr,value,mask=NULL)-> None
-
- Sets every element of an array to a given value.
-
-
-
-
-
-
- :param arr: The destination array
-
- :type arr: :class:`CvArr`
-
-
- :param value: Fill value
-
- :type value: :class:`CvScalar`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function copies the scalar
-``value``
-to every selected element of the destination array:
-
-
-
-.. math::
-
- \texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I) \ne 0
-
-
-If array
-``arr``
-is of
-``IplImage``
-type, then is ROI used, but COI must not be set.
-
-
-.. index:: Set1D
-
-.. _Set1D:
-
-Set1D
------
-
-`id=0.373645417692 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Set1D>`__
-
-
-.. function:: Set1D(arr, idx, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx: Zero-based element index
-
- :type idx: int
-
-
- :param value: The value to assign to the element
-
- :type value: :class:`CvScalar`
-
-
-
-Sets a specific array element. Array must have dimension 1.
-
-
-.. index:: Set2D
-
-.. _Set2D:
-
-Set2D
------
-
-`id=0.0250420294549 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Set2D>`__
-
-
-.. function:: Set2D(arr, idx0, idx1, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element row index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element column index
-
- :type idx1: int
-
-
- :param value: The value to assign to the element
-
- :type value: :class:`CvScalar`
-
-
-
-Sets a specific array element. Array must have dimension 2.
-
-
-.. index:: Set3D
-
-.. _Set3D:
-
-Set3D
------
-
-`id=0.221694881783 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Set3D>`__
-
-
-.. function:: Set3D(arr, idx0, idx1, idx2, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element index
-
- :type idx1: int
-
-
- :param idx2: Zero-based element index
-
- :type idx2: int
-
-
- :param value: The value to assign to the element
-
- :type value: :class:`CvScalar`
-
-
-
-Sets a specific array element. Array must have dimension 3.
-
-
-.. index:: SetND
-
-.. _SetND:
-
-SetND
------
-
-`id=0.00427984275033 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetND>`__
-
-
-.. function:: SetND(arr, indices, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param indices: List of zero-based element indices
-
- :type indices: sequence of int
-
-
- :param value: The value to assign to the element
-
- :type value: :class:`CvScalar`
-
-
-
-Sets a specific array element. The length of array indices must be the same as the dimension of the array.
-
-.. index:: SetData
-
-.. _SetData:
-
-SetData
--------
-
-`id=0.678853678425 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetData>`__
-
-
-.. function:: SetData(arr, data, step)-> None
-
- Assigns user data to the array header.
-
-
-
-
-
-
- :param arr: Array header
-
- :type arr: :class:`CvArr`
-
-
- :param data: User data
-
- :type data: object
-
-
- :param step: Full row length in bytes
-
- :type step: int
-
-
-
-The function assigns user data to the array header. Header should be initialized before using
-``cvCreate*Header``
-,
-``cvInit*Header``
-or
-:ref:`Mat`
-(in the case of matrix) function.
-
-
-.. index:: SetIdentity
-
-.. _SetIdentity:
-
-SetIdentity
------------
-
-`id=0.192253473137 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetIdentity>`__
-
-
-.. function:: SetIdentity(mat,value=1)-> None
-
- Initializes a scaled identity matrix.
-
-
-
-
-
-
- :param mat: The matrix to initialize (not necesserily square)
-
- :type mat: :class:`CvArr`
-
-
- :param value: The value to assign to the diagonal elements
-
- :type value: :class:`CvScalar`
-
-
-
-The function initializes a scaled identity matrix:
-
-
-
-.. math::
-
- \texttt{arr} (i,j)= \fork{\texttt{value}}{ if $i=j$}{0}{otherwise}
-
-
-
-.. index:: SetImageCOI
-
-.. _SetImageCOI:
-
-SetImageCOI
------------
-
-`id=0.712093321245 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetImageCOI>`__
-
-
-.. function:: SetImageCOI(image, coi)-> None
-
- Sets the channel of interest in an IplImage.
-
-
-
-
-
-
- :param image: A pointer to the image header
-
- :type image: :class:`IplImage`
-
-
- :param coi: The channel of interest. 0 - all channels are selected, 1 - first channel is selected, etc. Note that the channel indices become 1-based.
-
- :type coi: int
-
-
-
-If the ROI is set to
-``NULL``
-and the coi is
-*not*
-0,
-the ROI is allocated. Most OpenCV functions do
-*not*
-support
-the COI setting, so to process an individual image/matrix channel one
-may copy (via
-:ref:`Copy`
-or
-:ref:`Split`
-) the channel to a separate
-image/matrix, process it and then copy the result back (via
-:ref:`Copy`
-or
-:ref:`Merge`
-) if needed.
-
-
-.. index:: SetImageROI
-
-.. _SetImageROI:
-
-SetImageROI
------------
-
-`id=0.669600484476 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetImageROI>`__
-
-
-.. function:: SetImageROI(image, rect)-> None
-
- Sets an image Region Of Interest (ROI) for a given rectangle.
-
-
-
-
-
-
- :param image: A pointer to the image header
-
- :type image: :class:`IplImage`
-
-
- :param rect: The ROI rectangle
-
- :type rect: :class:`CvRect`
-
-
-
-If the original image ROI was
-``NULL``
-and the
-``rect``
-is not the whole image, the ROI structure is allocated.
-
-Most OpenCV functions support the use of ROI and treat the image rectangle as a separate image. For example, all of the pixel coordinates are counted from the top-left (or bottom-left) corner of the ROI, not the original image.
-
-
-.. index:: SetReal1D
-
-.. _SetReal1D:
-
-SetReal1D
----------
-
-`id=0.588784461383 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetReal1D>`__
-
-
-.. function:: SetReal1D(arr, idx, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx: Zero-based element index
-
- :type idx: int
-
-
- :param value: The value to assign to the element
-
- :type value: float
-
-
-
-Sets a specific array element. Array must have dimension 1.
-
-
-.. index:: SetReal2D
-
-.. _SetReal2D:
-
-SetReal2D
----------
-
-`id=0.428584366817 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetReal2D>`__
-
-
-.. function:: SetReal2D(arr, idx0, idx1, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element row index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element column index
-
- :type idx1: int
-
-
- :param value: The value to assign to the element
-
- :type value: float
-
-
-
-Sets a specific array element. Array must have dimension 2.
-
-
-.. index:: SetReal3D
-
-.. _SetReal3D:
-
-SetReal3D
----------
-
-`id=0.634141541403 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetReal3D>`__
-
-
-.. function:: SetReal3D(arr, idx0, idx1, idx2, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param idx0: Zero-based element index
-
- :type idx0: int
-
-
- :param idx1: Zero-based element index
-
- :type idx1: int
-
-
- :param idx2: Zero-based element index
-
- :type idx2: int
-
-
- :param value: The value to assign to the element
-
- :type value: float
-
-
-
-Sets a specific array element. Array must have dimension 3.
-
-
-.. index:: SetRealND
-
-.. _SetRealND:
-
-SetRealND
----------
-
-`id=0.900808330377 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetRealND>`__
-
-
-.. function:: SetRealND(arr, indices, value) -> None
-
- Set a specific array element.
-
-
-
-
-
-
- :param arr: Input array
-
- :type arr: :class:`CvArr`
-
-
- :param indices: List of zero-based element indices
-
- :type indices: sequence of int
-
-
- :param value: The value to assign to the element
-
- :type value: float
-
-
-
-Sets a specific array element. The length of array indices must be the same as the dimension of the array.
-
-.. index:: SetZero
-
-.. _SetZero:
-
-SetZero
--------
-
-`id=0.110196481513 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SetZero>`__
-
-
-.. function:: SetZero(arr)-> None
-
- Clears the array.
-
-
-
-
-
-
- :param arr: Array to be cleared
-
- :type arr: :class:`CvArr`
-
-
-
-The function clears the array. In the case of dense arrays (CvMat, CvMatND or IplImage), cvZero(array) is equivalent to cvSet(array,cvScalarAll(0),0).
-In the case of sparse arrays all the elements are removed.
-
-
-.. index:: Solve
-
-.. _Solve:
-
-Solve
------
-
-`id=0.525692887749 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Solve>`__
-
-
-.. function:: Solve(A,B,X,method=CV_LU)-> None
-
- Solves a linear system or least-squares problem.
-
-
-
-
-
-
- :param A: The source matrix
-
- :type A: :class:`CvArr`
-
-
- :param B: The right-hand part of the linear system
-
- :type B: :class:`CvArr`
-
-
- :param X: The output solution
-
- :type X: :class:`CvArr`
-
-
- :param method: The solution (matrix inversion) method
-
-
- * **CV_LU** Gaussian elimination with optimal pivot element chosen
-
-
- * **CV_SVD** Singular value decomposition (SVD) method
-
-
- * **CV_SVD_SYM** SVD method for a symmetric positively-defined matrix.
-
-
-
- :type method: int
-
-
-
-The function solves a linear system or least-squares problem (the latter is possible with SVD methods):
-
-
-
-.. math::
-
- \texttt{dst} = argmin_X|| \texttt{src1} \, \texttt{X} - \texttt{src2} ||
-
-
-If
-``CV_LU``
-method is used, the function returns 1 if
-``src1``
-is non-singular and 0 otherwise; in the latter case
-``dst``
-is not valid.
-
-
-.. index:: SolveCubic
-
-.. _SolveCubic:
-
-SolveCubic
-----------
-
-`id=0.387007589899 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SolveCubic>`__
-
-
-.. function:: SolveCubic(coeffs,roots)-> None
-
- Finds the real roots of a cubic equation.
-
-
-
-
-
-
- :param coeffs: The equation coefficients, an array of 3 or 4 elements
-
- :type coeffs: :class:`CvMat`
-
-
- :param roots: The output array of real roots which should have 3 elements
-
- :type roots: :class:`CvMat`
-
-
-
-The function finds the real roots of a cubic equation:
-
-If coeffs is a 4-element vector:
-
-
-
-.. math::
-
- \texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0
-
-
-or if coeffs is 3-element vector:
-
-
-
-.. math::
-
- x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0
-
-
-The function returns the number of real roots found. The roots are
-stored to
-``root``
-array, which is padded with zeros if there is
-only one root.
-
-
-.. index:: Split
-
-.. _Split:
-
-Split
------
-
-`id=0.314146185721 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Split>`__
-
-
-.. function:: Split(src,dst0,dst1,dst2,dst3)-> None
-
- Divides multi-channel array into several single-channel arrays or extracts a single channel from the array.
-
-
-
-
-
-
- :param src: Source array
-
- :type src: :class:`CvArr`
-
-
- :param dst0: Destination channel 0
-
- :type dst0: :class:`CvArr`
-
-
- :param dst1: Destination channel 1
-
- :type dst1: :class:`CvArr`
-
-
- :param dst2: Destination channel 2
-
- :type dst2: :class:`CvArr`
-
-
- :param dst3: Destination channel 3
-
- :type dst3: :class:`CvArr`
-
-
-
-The function divides a multi-channel array into separate
-single-channel arrays. Two modes are available for the operation. If the
-source array has N channels then if the first N destination channels
-are not NULL, they all are extracted from the source array;
-if only a single destination channel of the first N is not NULL, this
-particular channel is extracted; otherwise an error is raised. The rest
-of the destination channels (beyond the first N) must always be NULL. For
-IplImage
-:ref:`Copy`
-with COI set can be also used to extract a single
-channel from the image.
-
-
-
-.. index:: Sqrt
-
-.. _Sqrt:
-
-Sqrt
-----
-
-`id=0.461805105559 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Sqrt>`__
-
-
-.. function:: Sqrt(value)-> float
-
- Calculates the square root.
-
-
-
-
-
-
- :param value: The input floating-point value
-
- :type value: float
-
-
-
-The function calculates the square root of the argument. If the argument is negative, the result is not determined.
-
-
-.. index:: Sub
-
-.. _Sub:
-
-Sub
----
-
-`id=0.249321252752 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Sub>`__
-
-
-.. function:: Sub(src1,src2,dst,mask=NULL)-> None
-
- Computes the per-element difference between two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function subtracts one array from another one:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)-src2(I) if mask(I)!=0
-
-
-..
-
-All the arrays must have the same type, except the mask, and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-.. index:: SubRS
-
-.. _SubRS:
-
-SubRS
------
-
-`id=0.174857582392 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SubRS>`__
-
-
-.. function:: SubRS(src,value,dst,mask=NULL)-> None
-
- Computes the difference between a scalar and an array.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Scalar to subtract from
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function subtracts every element of source array from a scalar:
-
-
-
-
-::
-
-
-
- dst(I)=value-src(I) if mask(I)!=0
-
-
-..
-
-All the arrays must have the same type, except the mask, and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-.. index:: SubS
-
-.. _SubS:
-
-SubS
-----
-
-`id=0.519664754242 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SubS>`__
-
-
-.. function:: SubS(src,value,dst,mask=NULL)-> None
-
- Computes the difference between an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Subtracted scalar
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function subtracts a scalar from every element of the source array:
-
-
-
-
-::
-
-
-
- dst(I)=src(I)-value if mask(I)!=0
-
-
-..
-
-All the arrays must have the same type, except the mask, and the same size (or ROI size).
-For types that have limited range this operation is saturating.
-
-
-
-.. index:: Sum
-
-.. _Sum:
-
-Sum
----
-
-`id=0.967447366206 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Sum>`__
-
-
-.. function:: Sum(arr)-> CvScalar
-
- Adds up array elements.
-
-
-
-
-
-
- :param arr: The array
-
- :type arr: :class:`CvArr`
-
-
-
-The function calculates the sum
-``S``
-of array elements, independently for each channel:
-
-
-
-.. math::
-
- \sum _I \texttt{arr} (I)_c
-
-
-If the array is
-``IplImage``
-and COI is set, the function processes the selected channel only and stores the sum to the first scalar component.
-
-
-
-.. index:: SVBkSb
-
-.. _SVBkSb:
-
-SVBkSb
-------
-
-`id=0.35592825276 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SVBkSb>`__
-
-
-.. function:: SVBkSb(W,U,V,B,X,flags)-> None
-
- Performs singular value back substitution.
-
-
-
-
-
-
- :param W: Matrix or vector of singular values
-
- :type W: :class:`CvArr`
-
-
- :param U: Left orthogonal matrix (tranposed, perhaps)
-
- :type U: :class:`CvArr`
-
-
- :param V: Right orthogonal matrix (tranposed, perhaps)
-
- :type V: :class:`CvArr`
-
-
- :param B: The matrix to multiply the pseudo-inverse of the original matrix ``A`` by. This is an optional parameter. If it is omitted then it is assumed to be an identity matrix of an appropriate size (so that ``X`` will be the reconstructed pseudo-inverse of ``A`` ).
-
- :type B: :class:`CvArr`
-
-
- :param X: The destination matrix: result of back substitution
-
- :type X: :class:`CvArr`
-
-
- :param flags: Operation flags, should match exactly to the ``flags`` passed to :ref:`SVD`
-
- :type flags: int
-
-
-
-The function calculates back substitution for decomposed matrix
-``A``
-(see
-:ref:`SVD`
-description) and matrix
-``B``
-:
-
-
-
-.. math::
-
- \texttt{X} = \texttt{V} \texttt{W} ^{-1} \texttt{U} ^T \texttt{B}
-
-
-where
-
-
-
-.. math::
-
- W^{-1}_{(i,i)}= \fork{1/W_{(i,i)}}{if $W_{(i,i)} > \epsilon \sum_i{W_{(i,i)}}$ }{0}{otherwise}
-
-
-and
-:math:`\epsilon`
-is a small number that depends on the matrix data type.
-
-This function together with
-:ref:`SVD`
-is used inside
-:ref:`Invert`
-and
-:ref:`Solve`
-, and the possible reason to use these (svd and bksb)
-"low-level" function, is to avoid allocation of temporary matrices inside
-the high-level counterparts (inv and solve).
-
-
-.. index:: SVD
-
-.. _SVD:
-
-SVD
----
-
-`id=0.337653561571 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/SVD>`__
-
-
-.. function:: SVD(A,W, U = None, V = None, flags=0)-> None
-
- Performs singular value decomposition of a real floating-point matrix.
-
-
-
-
-
-
- :param A: Source :math:`\texttt{M} \times \texttt{N}` matrix
-
- :type A: :class:`CvArr`
-
-
- :param W: Resulting singular value diagonal matrix ( :math:`\texttt{M} \times \texttt{N}` or :math:`\min(\texttt{M}, \texttt{N}) \times \min(\texttt{M}, \texttt{N})` ) or :math:`\min(\texttt{M},\texttt{N}) \times 1` vector of the singular values
-
- :type W: :class:`CvArr`
-
-
- :param U: Optional left orthogonal matrix, :math:`\texttt{M} \times \min(\texttt{M}, \texttt{N})` (when ``CV_SVD_U_T`` is not set), or :math:`\min(\texttt{M},\texttt{N}) \times \texttt{M}` (when ``CV_SVD_U_T`` is set), or :math:`\texttt{M} \times \texttt{M}` (regardless of ``CV_SVD_U_T`` flag).
-
- :type U: :class:`CvArr`
-
-
- :param V: Optional right orthogonal matrix, :math:`\texttt{N} \times \min(\texttt{M}, \texttt{N})` (when ``CV_SVD_V_T`` is not set), or :math:`\min(\texttt{M},\texttt{N}) \times \texttt{N}` (when ``CV_SVD_V_T`` is set), or :math:`\texttt{N} \times \texttt{N}` (regardless of ``CV_SVD_V_T`` flag).
-
- :type V: :class:`CvArr`
-
-
- :param flags: Operation flags; can be 0 or a combination of the following values:
-
-
- * **CV_SVD_MODIFY_A** enables modification of matrix ``A`` during the operation. It speeds up the processing.
-
-
- * **CV_SVD_U_T** means that the transposed matrix ``U`` is returned. Specifying the flag speeds up the processing.
-
-
- * **CV_SVD_V_T** means that the transposed matrix ``V`` is returned. Specifying the flag speeds up the processing.
-
-
-
- :type flags: int
-
-
-
-The function decomposes matrix
-``A``
-into the product of a diagonal matrix and two
-
-orthogonal matrices:
-
-
-
-.. math::
-
- A=U \, W \, V^T
-
-
-where
-:math:`W`
-is a diagonal matrix of singular values that can be coded as a
-1D vector of singular values and
-:math:`U`
-and
-:math:`V`
-. All the singular values
-are non-negative and sorted (together with
-:math:`U`
-and
-:math:`V`
-columns)
-in descending order.
-
-An SVD algorithm is numerically robust and its typical applications include:
-
-
-
-
-
-*
- accurate eigenvalue problem solution when matrix
- ``A``
- is a square, symmetric, and positively defined matrix, for example, when
- it is a covariance matrix.
- :math:`W`
- in this case will be a vector/matrix
- of the eigenvalues, and
- :math:`U = V`
- will be a matrix of the eigenvectors.
-
-
-
-*
- accurate solution of a poor-conditioned linear system.
-
-
-
-*
- least-squares solution of an overdetermined linear system. This and the preceeding is done by using the
- :ref:`Solve`
- function with the
- ``CV_SVD``
- method.
-
-
-
-*
- accurate calculation of different matrix characteristics such as the matrix rank (the number of non-zero singular values), condition number (ratio of the largest singular value to the smallest one), and determinant (absolute value of the determinant is equal to the product of singular values).
-
-
-
-.. index:: Trace
-
-.. _Trace:
-
-Trace
------
-
-`id=0.336959724198 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Trace>`__
-
-
-.. function:: Trace(mat)-> CvScalar
-
- Returns the trace of a matrix.
-
-
-
-
-
-
- :param mat: The source matrix
-
- :type mat: :class:`CvArr`
-
-
-
-The function returns the sum of the diagonal elements of the matrix
-``src1``
-.
-
-
-
-.. math::
-
- tr( \texttt{mat} ) = \sum _i \texttt{mat} (i,i)
-
-
-
-.. index:: Transform
-
-.. _Transform:
-
-Transform
----------
-
-`id=0.503072283556 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Transform>`__
-
-
-.. function:: Transform(src,dst,transmat,shiftvec=NULL)-> None
-
- Performs matrix transformation of every array element.
-
-
-
-
-
-
- :param src: The first source array
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param transmat: Transformation matrix
-
- :type transmat: :class:`CvMat`
-
-
- :param shiftvec: Optional shift vector
-
- :type shiftvec: :class:`CvMat`
-
-
-
-The function performs matrix transformation of every element of array
-``src``
-and stores the results in
-``dst``
-:
-
-
-
-.. math::
-
- dst(I) = transmat \cdot src(I) + shiftvec
-
-
-That is, every element of an
-``N``
--channel array
-``src``
-is
-considered as an
-``N``
--element vector which is transformed using
-a
-:math:`\texttt{M} \times \texttt{N}`
-matrix
-``transmat``
-and shift
-vector
-``shiftvec``
-into an element of
-``M``
--channel array
-``dst``
-. There is an option to embedd
-``shiftvec``
-into
-``transmat``
-. In this case
-``transmat``
-should be a
-:math:`\texttt{M}
-\times (N+1)`
-matrix and the rightmost column is treated as the shift
-vector.
-
-Both source and destination arrays should have the same depth and the
-same size or selected ROI size.
-``transmat``
-and
-``shiftvec``
-should be real floating-point matrices.
-
-The function may be used for geometrical transformation of n dimensional
-point set, arbitrary linear color space transformation, shuffling the
-channels and so forth.
-
-
-.. index:: Transpose
-
-.. _Transpose:
-
-Transpose
----------
-
-`id=0.420471231844 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Transpose>`__
-
-
-.. function:: Transpose(src,dst)-> None
-
- Transposes a matrix.
-
-
-
-
-
-
- :param src: The source matrix
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination matrix
-
- :type dst: :class:`CvArr`
-
-
-
-The function transposes matrix
-``src1``
-:
-
-
-
-.. math::
-
- \texttt{dst} (i,j) = \texttt{src} (j,i)
-
-
-Note that no complex conjugation is done in the case of a complex
-matrix. Conjugation should be done separately: look at the sample code
-in
-:ref:`XorS`
-for an example.
-
-
-.. index:: Xor
-
-.. _Xor:
-
-Xor
----
-
-`id=0.104176616033 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Xor>`__
-
-
-.. function:: Xor(src1,src2,dst,mask=NULL)-> None
-
- Performs per-element bit-wise "exclusive or" operation on two arrays.
-
-
-
-
-
-
- :param src1: The first source array
-
- :type src1: :class:`CvArr`
-
-
- :param src2: The second source array
-
- :type src2: :class:`CvArr`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates per-element bit-wise logical conjunction of two arrays:
-
-
-
-
-::
-
-
-
- dst(I)=src1(I)^src2(I) if mask(I)!=0
-
-
-..
-
-In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size.
-
-
-.. index:: XorS
-
-.. _XorS:
-
-XorS
-----
-
-`id=0.85429590946 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/XorS>`__
-
-
-.. function:: XorS(src,value,dst,mask=NULL)-> None
-
- Performs per-element bit-wise "exclusive or" operation on an array and a scalar.
-
-
-
-
-
-
- :param src: The source array
-
- :type src: :class:`CvArr`
-
-
- :param value: Scalar to use in the operation
-
- :type value: :class:`CvScalar`
-
-
- :param dst: The destination array
-
- :type dst: :class:`CvArr`
-
-
- :param mask: Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed
-
- :type mask: :class:`CvArr`
-
-
-
-The function XorS calculates per-element bit-wise conjunction of an array and a scalar:
-
-
-
-
-::
-
-
-
- dst(I)=src(I)^value if mask(I)!=0
-
-
-..
-
-Prior to the actual operation, the scalar is converted to the same type as that of the array(s). In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size
-
-
-.. index:: mGet
-
-.. _mGet:
-
-mGet
-----
-
-`id=0.391829237572 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/mGet>`__
-
-
-.. function:: mGet(mat,row,col)-> double
-
- Returns the particular element of single-channel floating-point matrix.
-
-
-
-
-
-
- :param mat: Input matrix
-
- :type mat: :class:`CvMat`
-
-
- :param row: The zero-based index of row
-
- :type row: int
-
-
- :param col: The zero-based index of column
-
- :type col: int
-
-
-
-The function is a fast replacement for
-:ref:`GetReal2D`
-in the case of single-channel floating-point matrices. It is faster because
-it is inline, it does fewer checks for array type and array element type,
-and it checks for the row and column ranges only in debug mode.
-
-
-.. index:: mSet
-
-.. _mSet:
-
-mSet
-----
-
-`id=0.217865654034 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/mSet>`__
-
-
-.. function:: mSet(mat,row,col,value)-> None
-
- Returns a specific element of a single-channel floating-point matrix.
-
-
-
-
-
-
- :param mat: The matrix
-
- :type mat: :class:`CvMat`
-
-
- :param row: The zero-based index of row
-
- :type row: int
-
-
- :param col: The zero-based index of column
-
- :type col: int
-
-
- :param value: The new value of the matrix element
-
- :type value: float
-
-
-
-The function is a fast replacement for
-:ref:`SetReal2D`
-in the case of single-channel floating-point matrices. It is faster because
-it is inline, it does fewer checks for array type and array element type,
-and it checks for the row and column ranges only in debug mode.
-
+++ /dev/null
-Utility and System Functions and Macros
-=======================================
-
-.. highlight:: python
-
-
-
-Error Handling
---------------
-
-
-Errors in argument type cause a
-``TypeError``
-exception.
-OpenCV errors cause an
-``cv.error``
-exception.
-
-For example a function argument that is the wrong type produces a
-``TypeError``
-:
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> cv.LoadImage(4)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- TypeError: argument 1 must be string, not int
-
-
-..
-
-A function with the
-
-
-
-
-.. doctest::
-
-
-
- >>> cv.CreateMat(-1, -1, cv.CV_8UC1)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- error: Non-positive width or height
-
-
-..
-
-
-.. index:: GetTickCount
-
-.. _GetTickCount:
-
-GetTickCount
-------------
-
-`id=0.81706194546 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetTickCount>`__
-
-
-.. function:: GetTickCount() -> long
-
- Returns the number of ticks.
-
-
-
-The function returns number of the ticks starting from some platform-dependent event (number of CPU ticks from the startup, number of milliseconds from 1970th year, etc.). The function is useful for accurate measurement of a function/user-code execution time. To convert the number of ticks to time units, use
-:ref:`GetTickFrequency`
-.
-
-
-.. index:: GetTickFrequency
-
-.. _GetTickFrequency:
-
-GetTickFrequency
-----------------
-
-`id=0.967317163838 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/GetTickFrequency>`__
-
-
-.. function:: GetTickFrequency() -> long
-
- Returns the number of ticks per microsecond.
-
-
-
-The function returns the number of ticks per microsecond. Thus, the quotient of
-:ref:`GetTickCount`
-and
-:ref:`GetTickFrequency`
-will give the number of microseconds starting from the platform-dependent event.
-
+++ /dev/null
-XML/YAML Persistence
-====================
-
-.. highlight:: python
-
-
-
-.. index:: Load
-
-.. _Load:
-
-Load
-----
-
-`id=0.778290631419 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Load>`__
-
-
-.. function:: Load(filename,storage=NULL,name=NULL)-> generic
-
- Loads an object from a file.
-
-
-
-
-
-
- :param filename: File name
-
- :type filename: str
-
-
- :param storage: Memory storage for dynamic structures, such as :ref:`CvSeq` or :ref:`CvGraph` . It is not used for matrices or images.
-
- :type storage: :class:`CvMemStorage`
-
-
- :param name: Optional object name. If it is NULL, the first top-level object in the storage will be loaded.
-
- :type name: str
-
-
-
-The function loads an object from a file. It provides a
-simple interface to
-:ref:`Read`
-. After the object is loaded, the file
-storage is closed and all the temporary buffers are deleted. Thus,
-to load a dynamic structure, such as a sequence, contour, or graph, one
-should pass a valid memory storage destination to the function.
-
-
-.. index:: Save
-
-.. _Save:
-
-Save
-----
-
-`id=0.295047298682 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/core/Save>`__
-
-
-.. function:: Save(filename,structPtr,name=NULL,comment=NULL)-> None
-
- Saves an object to a file.
-
-
-
-
-
-
- :param filename: File name
-
- :type filename: str
-
-
- :param structPtr: Object to save
-
- :type structPtr: :class:`generic`
-
-
- :param name: Optional object name. If it is NULL, the name will be formed from ``filename`` .
-
- :type name: str
-
-
- :param comment: Optional comment to put in the beginning of the file
-
- :type comment: str
-
-
-
-The function saves an object to a file. It provides a simple interface to
-:ref:`Write`
-.
-
+++ /dev/null
-*******************************************************
-features2d. Feature Detection and Descriptor Extraction
-*******************************************************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- features2d_feature_detection_and_description
+++ /dev/null
-Feature detection and description
-=================================
-
-.. highlight:: python
-
-
-
-
-
- * **image** The image. Keypoints (corners) will be detected on this.
-
-
- * **keypoints** Keypoints detected on the image.
-
-
- * **threshold** Threshold on difference between intensity of center pixel and
- pixels on circle around this pixel. See description of the algorithm.
-
-
- * **nonmaxSupression** If it is true then non-maximum supression will be applied to detected corners (keypoints).
-
-
-
-
-.. index:: CvSURFPoint
-
-.. _CvSURFPoint:
-
-CvSURFPoint
------------
-
-`id=0.785092904945 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/features2d/CvSURFPoint>`__
-
-.. class:: CvSURFPoint
-
-
-
-A SURF keypoint, represented as a tuple
-``((x, y), laplacian, size, dir, hessian)``
-.
-
-
-
-
-
- .. attribute:: x
-
-
-
- x-coordinate of the feature within the image
-
-
-
- .. attribute:: y
-
-
-
- y-coordinate of the feature within the image
-
-
-
- .. attribute:: laplacian
-
-
-
- -1, 0 or +1. sign of the laplacian at the point. Can be used to speedup feature comparison since features with laplacians of different signs can not match
-
-
-
- .. attribute:: size
-
-
-
- size of the feature
-
-
-
- .. attribute:: dir
-
-
-
- orientation of the feature: 0..360 degrees
-
-
-
- .. attribute:: hessian
-
-
-
- value of the hessian (can be used to approximately estimate the feature strengths; see also params.hessianThreshold)
-
-
-
-
-.. index:: ExtractSURF
-
-.. _ExtractSURF:
-
-ExtractSURF
------------
-
-`id=0.999928834286 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/features2d/ExtractSURF>`__
-
-
-.. function:: ExtractSURF(image,mask,storage,params)-> (keypoints,descriptors)
-
- Extracts Speeded Up Robust Features from an image.
-
-
-
-
-
-
- :param image: The input 8-bit grayscale image
-
- :type image: :class:`CvArr`
-
-
- :param mask: The optional input 8-bit mask. The features are only found in the areas that contain more than 50 % of non-zero mask pixels
-
- :type mask: :class:`CvArr`
-
-
- :param keypoints: sequence of keypoints.
-
- :type keypoints: :class:`CvSeq` of :class:`CvSURFPoint`
-
-
- :param descriptors: sequence of descriptors. Each SURF descriptor is a list of floats, of length 64 or 128.
-
- :type descriptors: :class:`CvSeq` of list of float
-
-
- :param storage: Memory storage where keypoints and descriptors will be stored
-
- :type storage: :class:`CvMemStorage`
-
-
- :param params: Various algorithm parameters in a tuple ``(extended, hessianThreshold, nOctaves, nOctaveLayers)`` :
-
- * **extended** 0 means basic descriptors (64 elements each), 1 means extended descriptors (128 elements each)
-
- * **hessianThreshold** only features with hessian larger than that are extracted. good default value is ~300-500 (can depend on the average local contrast and sharpness of the image). user can further filter out some features based on their hessian values and other characteristics.
-
- * **nOctaves** the number of octaves to be used for extraction. With each next octave the feature size is doubled (3 by default)
-
- * **nOctaveLayers** The number of layers within each octave (4 by default)
-
-
-
- :type params: :class:`CvSURFParams`
-
-
-
-The function cvExtractSURF finds robust features in the image, as
-described in
-Bay06
-. For each feature it returns its location, size,
-orientation and optionally the descriptor, basic or extended. The function
-can be used for object tracking and localization, image stitching etc.
-
-To extract strong SURF features from an image
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> im = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
- >>> (keypoints, descriptors) = cv.ExtractSURF(im, None, cv.CreateMemStorage(), (0, 30000, 3, 1))
- >>> print len(keypoints), len(descriptors)
- 6 6
- >>> for ((x, y), laplacian, size, dir, hessian) in keypoints:
- ... print "x=%d y=%d laplacian=%d size=%d dir=%f hessian=%f" % (x, y, laplacian, size, dir, hessian)
- x=30 y=27 laplacian=-1 size=31 dir=69.778503 hessian=36979.789062
- x=296 y=197 laplacian=1 size=33 dir=111.081039 hessian=31514.349609
- x=296 y=266 laplacian=1 size=32 dir=107.092300 hessian=31477.908203
- x=254 y=284 laplacian=1 size=31 dir=279.137360 hessian=34169.800781
- x=498 y=525 laplacian=-1 size=33 dir=278.006592 hessian=31002.759766
- x=777 y=281 laplacian=1 size=70 dir=167.940964 hessian=35538.363281
-
-
-..
-
-
-.. index:: GetStarKeypoints
-
-.. _GetStarKeypoints:
-
-GetStarKeypoints
-----------------
-
-`id=0.373658080009 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/features2d/GetStarKeypoints>`__
-
-
-.. function:: GetStarKeypoints(image,storage,params)-> keypoints
-
- Retrieves keypoints using the StarDetector algorithm.
-
-
-
-
-
-
- :param image: The input 8-bit grayscale image
-
- :type image: :class:`CvArr`
-
-
- :param storage: Memory storage where the keypoints will be stored
-
- :type storage: :class:`CvMemStorage`
-
-
- :param params: Various algorithm parameters in a tuple ``(maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize)`` :
-
- * **maxSize** maximal size of the features detected. The following values of the parameter are supported: 4, 6, 8, 11, 12, 16, 22, 23, 32, 45, 46, 64, 90, 128
-
- * **responseThreshold** threshold for the approximatd laplacian, used to eliminate weak features
-
- * **lineThresholdProjected** another threshold for laplacian to eliminate edges
-
- * **lineThresholdBinarized** another threshold for the feature scale to eliminate edges
-
- * **suppressNonmaxSize** linear size of a pixel neighborhood for non-maxima suppression
-
-
-
- :type params: :class:`CvStarDetectorParams`
-
-
-
-The function GetStarKeypoints extracts keypoints that are local
-scale-space extremas. The scale-space is constructed by computing
-approximate values of laplacians with different sigma's at each
-pixel. Instead of using pyramids, a popular approach to save computing
-time, all of the laplacians are computed at each pixel of the original
-high-resolution image. But each approximate laplacian value is computed
-in O(1) time regardless of the sigma, thanks to the use of integral
-images. The algorithm is based on the paper
-Agrawal08
-, but instead
-of a square, hexagon or octagon it uses an 8-end star shape, hence the name,
-consisting of overlapping upright and tilted squares.
-
-Each keypoint is represented by a tuple
-``((x, y), size, response)``
-:
-
-
-
- * **x, y** Screen coordinates of the keypoint
-
-
- * **size** feature size, up to ``maxSize``
-
-
- * **response** approximated laplacian value for the keypoint
-
-
-
+++ /dev/null
-*************************************
-highgui. High-level GUI and Media I/O
-*************************************
-
-
-While OpenCV was designed for use in full-scale
-applications and can be used within functionally rich UI frameworks (such as Qt, WinForms or Cocoa) or without any UI at all, sometimes there is a need to try some functionality quickly and visualize the results. This is what the HighGUI module has been designed for.
-
-It provides easy interface to:
-
-
-
-
-*
- create and manipulate windows that can display images and "remember" their content (no need to handle repaint events from OS)
-
-
-
-*
- add trackbars to the windows, handle simple mouse events as well as keyboard commmands
-
-
-
-*
- read and write images to/from disk or memory.
-
-
-
-*
- read video from camera or file and write video to a file.
-
-
-
-.. toctree::
- :maxdepth: 2
-
- highgui_user_interface
- highgui_reading_and_writing_images_and_video
+++ /dev/null
-Reading and Writing Images and Video
-====================================
-
-.. highlight:: python
-
-
-
-.. index:: LoadImage
-
-.. _LoadImage:
-
-LoadImage
----------
-
-`id=0.709113485048 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/LoadImage>`__
-
-
-.. function:: LoadImage(filename, iscolor=CV_LOAD_IMAGE_COLOR)->None
-
- Loads an image from a file as an IplImage.
-
-
-
-
-
-
- :param filename: Name of file to be loaded.
-
- :type filename: str
-
-
- :param iscolor: Specific color type of the loaded image:
-
- * **CV_LOAD_IMAGE_COLOR** the loaded image is forced to be a 3-channel color image
-
- * **CV_LOAD_IMAGE_GRAYSCALE** the loaded image is forced to be grayscale
-
- * **CV_LOAD_IMAGE_UNCHANGED** the loaded image will be loaded as is.
-
-
-
- :type iscolor: int
-
-
-
-The function
-``cvLoadImage``
-loads an image from the specified file and returns the pointer to the loaded image. Currently the following file formats are supported:
-
-
-
-
-*
- Windows bitmaps - BMP, DIB
-
-
-*
- JPEG files - JPEG, JPG, JPE
-
-
-*
- Portable Network Graphics - PNG
-
-
-*
- Portable image format - PBM, PGM, PPM
-
-
-*
- Sun rasters - SR, RAS
-
-
-*
- TIFF files - TIFF, TIF
-
-
-Note that in the current implementation the alpha channel, if any, is stripped from the output image, e.g. 4-channel RGBA image will be loaded as RGB.
-
-
-.. index:: LoadImageM
-
-.. _LoadImageM:
-
-LoadImageM
-----------
-
-`id=0.915605899901 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/LoadImageM>`__
-
-
-.. function:: LoadImageM(filename, iscolor=CV_LOAD_IMAGE_COLOR)->None
-
- Loads an image from a file as a CvMat.
-
-
-
-
-
-
- :param filename: Name of file to be loaded.
-
- :type filename: str
-
-
- :param iscolor: Specific color type of the loaded image:
-
- * **CV_LOAD_IMAGE_COLOR** the loaded image is forced to be a 3-channel color image
-
- * **CV_LOAD_IMAGE_GRAYSCALE** the loaded image is forced to be grayscale
-
- * **CV_LOAD_IMAGE_UNCHANGED** the loaded image will be loaded as is.
-
-
-
- :type iscolor: int
-
-
-
-The function
-``cvLoadImageM``
-loads an image from the specified file and returns the pointer to the loaded image.
-urrently the following file formats are supported:
-
-
-
-
-*
- Windows bitmaps - BMP, DIB
-
-
-*
- JPEG files - JPEG, JPG, JPE
-
-
-*
- Portable Network Graphics - PNG
-
-
-*
- Portable image format - PBM, PGM, PPM
-
-
-*
- Sun rasters - SR, RAS
-
-
-*
- TIFF files - TIFF, TIF
-
-
-Note that in the current implementation the alpha channel, if any, is stripped from the output image, e.g. 4-channel RGBA image will be loaded as RGB.
-
-
-.. index:: SaveImage
-
-.. _SaveImage:
-
-SaveImage
----------
-
-`id=0.496487139898 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/SaveImage>`__
-
-
-.. function:: SaveImage(filename,image)-> None
-
- Saves an image to a specified file.
-
-
-
-
-
-
- :param filename: Name of the file.
-
- :type filename: str
-
-
- :param image: Image to be saved.
-
- :type image: :class:`CvArr`
-
-
-
-The function
-``cvSaveImage``
-saves the image to the specified file. The image format is chosen based on the
-``filename``
-extension, see
-:ref:`LoadImage`
-. Only 8-bit single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function. If the format, depth or channel order is different, use
-``cvCvtScale``
-and
-``cvCvtColor``
-to convert it before saving, or use universal
-``cvSave``
-to save the image to XML or YAML format.
-
-
-
-.. index:: CvCapture
-
-.. _CvCapture:
-
-CvCapture
----------
-
-`id=0.364337205432 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/CvCapture>`__
-
-.. class:: CvCapture
-
-
-
-Video capturing structure.
-
-The structure
-``CvCapture``
-does not have a public interface and is used only as a parameter for video capturing functions.
-
-
-.. index:: CaptureFromCAM
-
-.. _CaptureFromCAM:
-
-CaptureFromCAM
---------------
-
-`id=0.68934258142 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/CaptureFromCAM>`__
-
-
-.. function:: CaptureFromCAM(index) -> CvCapture
-
- Initializes capturing a video from a camera.
-
-
-
-
-
-
- :param index: Index of the camera to be used. If there is only one camera or it does not matter what camera is used -1 may be passed.
-
- :type index: int
-
-
-
-The function
-``cvCaptureFromCAM``
-allocates and initializes the CvCapture structure for reading a video stream from the camera. Currently two camera interfaces can be used on Windows: Video for Windows (VFW) and Matrox Imaging Library (MIL); and two on Linux: V4L and FireWire (IEEE1394).
-
-To release the structure, use
-:ref:`ReleaseCapture`
-.
-
-
-
-.. index:: CaptureFromFile
-
-.. _CaptureFromFile:
-
-CaptureFromFile
----------------
-
-`id=0.627099214181 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/CaptureFromFile>`__
-
-
-.. function:: CaptureFromFile(filename) -> CvCapture
-
- Initializes capturing a video from a file.
-
-
-
-
-
-
- :param filename: Name of the video file.
-
- :type filename: str
-
-
-
-The function
-``cvCaptureFromFile``
-allocates and initializes the CvCapture structure for reading the video stream from the specified file. Which codecs and file formats are supported depends on the back end library. On Windows HighGui uses Video for Windows (VfW), on Linux ffmpeg is used and on Mac OS X the back end is QuickTime. See VideoCodecs for some discussion on what to expect and how to prepare your video files.
-
-After the allocated structure is not used any more it should be released by the
-:ref:`ReleaseCapture`
-function.
-
-
-.. index:: GetCaptureProperty
-
-.. _GetCaptureProperty:
-
-GetCaptureProperty
-------------------
-
-`id=0.295657731336 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/GetCaptureProperty>`__
-
-
-.. function:: GetCaptureProperty(capture, property_id)->double
-
- Gets video capturing properties.
-
-
-
-
-
-
- :param capture: video capturing structure.
-
- :type capture: :class:`CvCapture`
-
-
- :param property_id: Property identifier. Can be one of the following:
-
- :type property_id: int
-
-
-
-
- * **CV_CAP_PROP_POS_MSEC** Film current position in milliseconds or video capture timestamp
-
-
- * **CV_CAP_PROP_POS_FRAMES** 0-based index of the frame to be decoded/captured next
-
-
- * **CV_CAP_PROP_POS_AVI_RATIO** Relative position of the video file (0 - start of the film, 1 - end of the film)
-
-
- * **CV_CAP_PROP_FRAME_WIDTH** Width of the frames in the video stream
-
-
- * **CV_CAP_PROP_FRAME_HEIGHT** Height of the frames in the video stream
-
-
- * **CV_CAP_PROP_FPS** Frame rate
-
-
- * **CV_CAP_PROP_FOURCC** 4-character code of codec
-
-
- * **CV_CAP_PROP_FRAME_COUNT** Number of frames in the video file
-
-
- * **CV_CAP_PROP_FORMAT** The format of the Mat objects returned by retrieve()
-
-
- * **CV_CAP_PROP_MODE** A backend-specific value indicating the current capture mode
-
-
- * **CV_CAP_PROP_BRIGHTNESS** Brightness of the image (only for cameras)
-
-
- * **CV_CAP_PROP_CONTRAST** Contrast of the image (only for cameras)
-
-
- * **CV_CAP_PROP_SATURATION** Saturation of the image (only for cameras)
-
-
- * **CV_CAP_PROP_HUE** Hue of the image (only for cameras)
-
-
- * **CV_CAP_PROP_GAIN** Gain of the image (only for cameras)
-
-
- * **CV_CAP_PROP_EXPOSURE** Exposure (only for cameras)
-
-
- * **CV_CAP_PROP_CONVERT_RGB** Boolean flags indicating whether images should be converted to RGB
-
-
- * **CV_CAP_PROP_WHITE_BALANCE** Currently unsupported
-
-
- * **CV_CAP_PROP_RECTIFICATION** TOWRITE (note: only supported by DC1394 v 2.x backend currently)
-
-
-
-
-
-The function
-``cvGetCaptureProperty``
-retrieves the specified property of the camera or video file.
-
-
-.. index:: GrabFrame
-
-.. _GrabFrame:
-
-GrabFrame
----------
-
-`id=0.664037861142 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/GrabFrame>`__
-
-
-.. function:: GrabFrame(capture) -> int
-
- Grabs the frame from a camera or file.
-
-
-
-
-
-
- :param capture: video capturing structure.
-
- :type capture: :class:`CvCapture`
-
-
-
-The function
-``cvGrabFrame``
-grabs the frame from a camera or file. The grabbed frame is stored internally. The purpose of this function is to grab the frame
-*quickly*
-so that syncronization can occur if it has to read from several cameras simultaneously. The grabbed frames are not exposed because they may be stored in a compressed format (as defined by the camera/driver). To retrieve the grabbed frame,
-:ref:`RetrieveFrame`
-should be used.
-
-
-
-.. index:: QueryFrame
-
-.. _QueryFrame:
-
-QueryFrame
-----------
-
-`id=0.15232451714 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/QueryFrame>`__
-
-
-.. function:: QueryFrame(capture) -> iplimage
-
- Grabs and returns a frame from a camera or file.
-
-
-
-
-
-
- :param capture: video capturing structure.
-
- :type capture: :class:`CvCapture`
-
-
-
-The function
-``cvQueryFrame``
-grabs a frame from a camera or video file, decompresses it and returns it. This function is just a combination of
-:ref:`GrabFrame`
-and
-:ref:`RetrieveFrame`
-, but in one call. The returned image should not be released or modified by the user. In the event of an error, the return value may be NULL.
-
-
-.. index:: RetrieveFrame
-
-.. _RetrieveFrame:
-
-RetrieveFrame
--------------
-
-`id=0.978271497895 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/RetrieveFrame>`__
-
-
-.. function:: RetrieveFrame(capture) -> iplimage
-
- Gets the image grabbed with cvGrabFrame.
-
-
-
-
-
-
- :param capture: video capturing structure.
-
- :type capture: :class:`CvCapture`
-
-
-
-The function
-``cvRetrieveFrame``
-returns the pointer to the image grabbed with the
-:ref:`GrabFrame`
-function. The returned image should not be released or modified by the user. In the event of an error, the return value may be NULL.
-
-
-
-.. index:: SetCaptureProperty
-
-.. _SetCaptureProperty:
-
-SetCaptureProperty
-------------------
-
-`id=0.42439239326 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/SetCaptureProperty>`__
-
-
-.. function:: SetCaptureProperty(capture, property_id,value)->None
-
- Sets video capturing properties.
-
-
-
-
-
-
- :param capture: video capturing structure.
-
- :type capture: :class:`CvCapture`
-
-
- :param property_id: property identifier. Can be one of the following:
-
- :type property_id: int
-
-
-
-
- * **CV_CAP_PROP_POS_MSEC** Film current position in milliseconds or video capture timestamp
-
-
- * **CV_CAP_PROP_POS_FRAMES** 0-based index of the frame to be decoded/captured next
-
-
- * **CV_CAP_PROP_POS_AVI_RATIO** Relative position of the video file (0 - start of the film, 1 - end of the film)
-
-
- * **CV_CAP_PROP_FRAME_WIDTH** Width of the frames in the video stream
-
-
- * **CV_CAP_PROP_FRAME_HEIGHT** Height of the frames in the video stream
-
-
- * **CV_CAP_PROP_FPS** Frame rate
-
-
- * **CV_CAP_PROP_FOURCC** 4-character code of codec
-
-
- * **CV_CAP_PROP_FRAME_COUNT** Number of frames in the video file
-
-
- * **CV_CAP_PROP_FORMAT** The format of the Mat objects returned by retrieve()
-
-
- * **CV_CAP_PROP_MODE** A backend-specific value indicating the current capture mode
-
-
- * **CV_CAP_PROP_BRIGHTNESS** Brightness of the image (only for cameras)
-
-
- * **CV_CAP_PROP_CONTRAST** Contrast of the image (only for cameras)
-
-
- * **CV_CAP_PROP_SATURATION** Saturation of the image (only for cameras)
-
-
- * **CV_CAP_PROP_HUE** Hue of the image (only for cameras)
-
-
- * **CV_CAP_PROP_GAIN** Gain of the image (only for cameras)
-
-
- * **CV_CAP_PROP_EXPOSURE** Exposure (only for cameras)
-
-
- * **CV_CAP_PROP_CONVERT_RGB** Boolean flags indicating whether images should be converted to RGB
-
-
- * **CV_CAP_PROP_WHITE_BALANCE** Currently unsupported
-
-
- * **CV_CAP_PROP_RECTIFICATION** TOWRITE (note: only supported by DC1394 v 2.x backend currently)
-
-
-
-
- :param value: value of the property.
-
- :type value: float
-
-
-
-The function
-``cvSetCaptureProperty``
-sets the specified property of video capturing. Currently the function supports only video files:
-``CV_CAP_PROP_POS_MSEC, CV_CAP_PROP_POS_FRAMES, CV_CAP_PROP_POS_AVI_RATIO``
-.
-
-NB This function currently does nothing when using the latest CVS download on linux with FFMPEG (the function contents are hidden if 0 is used and returned).
-
-
-
-.. index:: CreateVideoWriter
-
-.. _CreateVideoWriter:
-
-CreateVideoWriter
------------------
-
-`id=0.778639527068 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/CreateVideoWriter>`__
-
-
-.. function:: CreateVideoWriter(filename, fourcc, fps, frame_size, is_color) -> CvVideoWriter
-
- Creates the video file writer.
-
-
-
-
-
-
- :param filename: Name of the output video file.
-
- :type filename: str
-
-
- :param fourcc: 4-character code of codec used to compress the frames. For example, ``CV_FOURCC('P','I','M,'1')`` is a MPEG-1 codec, ``CV_FOURCC('M','J','P','G')`` is a motion-jpeg codec etc.
- Under Win32 it is possible to pass -1 in order to choose compression method and additional compression parameters from dialog. Under Win32 if 0 is passed while using an avi filename it will create a video writer that creates an uncompressed avi file.
-
- :type fourcc: int
-
-
- :param fps: Framerate of the created video stream.
-
- :type fps: float
-
-
- :param frame_size: Size of the video frames.
-
- :type frame_size: :class:`CvSize`
-
-
- :param is_color: If it is not zero, the encoder will expect and encode color frames, otherwise it will work with grayscale frames (the flag is currently supported on Windows only).
-
- :type is_color: int
-
-
-
-The function
-``cvCreateVideoWriter``
-creates the video writer structure.
-
-Which codecs and file formats are supported depends on the back end library. On Windows HighGui uses Video for Windows (VfW), on Linux ffmpeg is used and on Mac OS X the back end is QuickTime. See VideoCodecs for some discussion on what to expect.
-
-
-
-.. index:: WriteFrame
-
-.. _WriteFrame:
-
-WriteFrame
-----------
-
-`id=0.0385991600269 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/WriteFrame>`__
-
-
-.. function:: WriteFrame(writer, image)->int
-
- Writes a frame to a video file.
-
-
-
-
-
-
- :param writer: Video writer structure
-
- :type writer: :class:`CvVideoWriter`
-
-
- :param image: The written frame
-
- :type image: :class:`IplImage`
-
-
-
-The function
-``cvWriteFrame``
-writes/appends one frame to a video file.
-
+++ /dev/null
-User Interface
-==============
-
-.. highlight:: python
-
-
-
-.. index:: CreateTrackbar
-
-.. _CreateTrackbar:
-
-CreateTrackbar
---------------
-
-`id=0.859200002353 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/CreateTrackbar>`__
-
-
-.. function:: CreateTrackbar(trackbarName, windowName, value, count, onChange) -> None
-
- Creates a trackbar and attaches it to the specified window
-
-
-
-
-
-
- :param trackbarName: Name of the created trackbar.
-
- :type trackbarName: str
-
-
- :param windowName: Name of the window which will be used as a parent for created trackbar.
-
- :type windowName: str
-
-
- :param value: Initial value for the slider position, between 0 and ``count`` .
-
- :type value: int
-
-
- :param count: Maximal position of the slider. Minimal position is always 0.
-
- :type count: int
-
-
- :param onChange:
- OpenCV calls ``onChange`` every time the slider changes position.
- OpenCV will call it as ``func(x)`` where ``x`` is the new position of the slider.
-
- :type onChange: :class:`PyCallableObject`
-
-
-
-The function
-``cvCreateTrackbar``
-creates a trackbar (a.k.a. slider or range control) with the specified name and range, assigns a variable to be syncronized with trackbar position and specifies a callback function to be called on trackbar position change. The created trackbar is displayed on the top of the given window.
-\
-\
-**[Qt Backend Only]**
-qt-specific details:
-
-
-
- * **windowName** Name of the window which will be used as a parent for created trackbar. Can be NULL if the trackbar should be attached to the control panel.
-
-
-
-The created trackbar is displayed at the bottom of the given window if
-*windowName*
-is correctly provided, or displayed on the control panel if
-*windowName*
-is NULL.
-
-By clicking on the label of each trackbar, it is possible to edit the trackbar's value manually for a more accurate control of it.
-
-
-.. index:: DestroyAllWindows
-
-.. _DestroyAllWindows:
-
-DestroyAllWindows
------------------
-
-`id=0.386578572057 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/DestroyAllWindows>`__
-
-
-.. function:: DestroyAllWindows()-> None
-
- Destroys all of the HighGUI windows.
-
-
-
-The function
-``cvDestroyAllWindows``
-destroys all of the opened HighGUI windows.
-
-
-.. index:: DestroyWindow
-
-.. _DestroyWindow:
-
-DestroyWindow
--------------
-
-`id=0.0256606142145 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/DestroyWindow>`__
-
-
-.. function:: DestroyWindow(name)-> None
-
- Destroys a window.
-
-
-
-
-
-
- :param name: Name of the window to be destroyed.
-
- :type name: str
-
-
-
-The function
-``cvDestroyWindow``
-destroys the window with the given name.
-
-
-.. index:: GetTrackbarPos
-
-.. _GetTrackbarPos:
-
-GetTrackbarPos
---------------
-
-`id=0.0119794922165 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/GetTrackbarPos>`__
-
-
-.. function:: GetTrackbarPos(trackbarName,windowName)-> None
-
- Returns the trackbar position.
-
-
-
-
-
-
- :param trackbarName: Name of the trackbar.
-
- :type trackbarName: str
-
-
- :param windowName: Name of the window which is the parent of the trackbar.
-
- :type windowName: str
-
-
-
-The function
-``cvGetTrackbarPos``
-returns the current position of the specified trackbar.
-\
-\
-**[Qt Backend Only]**
-qt-specific details:
-
-
-
- * **windowName** Name of the window which is the parent of the trackbar. Can be NULL if the trackbar is attached to the control panel.
-
-
-
-
-.. index:: MoveWindow
-
-.. _MoveWindow:
-
-MoveWindow
-----------
-
-`id=0.0432662100889 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/MoveWindow>`__
-
-
-.. function:: MoveWindow(name,x,y)-> None
-
- Sets the position of the window.
-
-
-
-
-
-
- :param name: Name of the window to be moved.
-
- :type name: str
-
-
- :param x: New x coordinate of the top-left corner
-
- :type x: int
-
-
- :param y: New y coordinate of the top-left corner
-
- :type y: int
-
-
-
-The function
-``cvMoveWindow``
-changes the position of the window.
-
-
-.. index:: NamedWindow
-
-.. _NamedWindow:
-
-NamedWindow
------------
-
-`id=0.155885062255 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/NamedWindow>`__
-
-
-.. function:: NamedWindow(name,flags=CV_WINDOW_AUTOSIZE)-> None
-
- Creates a window.
-
-
-
-
-
-
- :param name: Name of the window in the window caption that may be used as a window identifier.
-
- :type name: str
-
-
- :param flags: Flags of the window. Currently the only supported flag is ``CV_WINDOW_AUTOSIZE`` . If this is set, window size is automatically adjusted to fit the displayed image (see :ref:`ShowImage` ), and the user can not change the window size manually.
-
- :type flags: int
-
-
-
-The function
-``cvNamedWindow``
-creates a window which can be used as a placeholder for images and trackbars. Created windows are referred to by their names.
-
-If a window with the same name already exists, the function does nothing.
-\
-\
-**[Qt Backend Only]**
-qt-specific details:
-
-
-
- * **flags** Flags of the window. Currently the supported flags are:
-
-
- * **CV_WINDOW_NORMAL or CV_WINDOW_AUTOSIZE:** ``CV_WINDOW_NORMAL`` let the user resize the window, whereas ``CV_WINDOW_AUTOSIZE`` adjusts automatically the window's size to fit the displayed image (see :ref:`ShowImage` ), and the user can not change the window size manually.
-
-
- * **CV_WINDOW_FREERATIO or CV_WINDOW_KEEPRATIO:** ``CV_WINDOW_FREERATIO`` adjust the image without respect the its ration, whereas ``CV_WINDOW_KEEPRATIO`` keep the image's ratio.
-
-
- * **CV_GUI_NORMAL or CV_GUI_EXPANDED:** ``CV_GUI_NORMAL`` is the old way to draw the window without statusbar and toolbar, whereas ``CV_GUI_EXPANDED`` is the new enhance GUI.
-
-
-
- This parameter is optional. The default flags set for a new window are ``CV_WINDOW_AUTOSIZE`` , ``CV_WINDOW_KEEPRATIO`` , and ``CV_GUI_EXPANDED`` .
-
- However, if you want to modify the flags, you can combine them using OR operator, ie:
-
-
- ::
-
-
-
- cvNamedWindow( ``myWindow'', ``CV_WINDOW_NORMAL`` textbar ``CV_GUI_NORMAL`` );
-
-
-
- ..
-
-
-
-
-.. index:: ResizeWindow
-
-.. _ResizeWindow:
-
-ResizeWindow
-------------
-
-`id=0.266699312987 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/ResizeWindow>`__
-
-
-.. function:: ResizeWindow(name,width,height)-> None
-
- Sets the window size.
-
-
-
-
-
-
- :param name: Name of the window to be resized.
-
- :type name: str
-
-
- :param width: New width
-
- :type width: int
-
-
- :param height: New height
-
- :type height: int
-
-
-
-The function
-``cvResizeWindow``
-changes the size of the window.
-
-
-.. index:: SetMouseCallback
-
-.. _SetMouseCallback:
-
-SetMouseCallback
-----------------
-
-`id=0.299310906828 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/SetMouseCallback>`__
-
-
-.. function:: SetMouseCallback(windowName, onMouse, param) -> None
-
- Assigns callback for mouse events.
-
-
-
-
-
-
- :param windowName: Name of the window.
-
- :type windowName: str
-
-
- :param onMouse: Callable to be called every time a mouse event occurs in the specified window. This callable should have signature `` Foo(event, x, y, flags, param)-> None ``
- where ``event`` is one of ``CV_EVENT_*`` , ``x`` and ``y`` are the coordinates of the mouse pointer in image coordinates (not window coordinates), ``flags`` is a combination of ``CV_EVENT_FLAG_*`` , and ``param`` is a user-defined parameter passed to the ``cvSetMouseCallback`` function call.
-
- :type onMouse: :class:`PyCallableObject`
-
-
- :param param: User-defined parameter to be passed to the callback function.
-
- :type param: object
-
-
-
-The function
-``cvSetMouseCallback``
-sets the callback function for mouse events occuring within the specified window.
-
-The
-``event``
-parameter is one of:
-
-
-
-
- * **CV_EVENT_MOUSEMOVE** Mouse movement
-
-
- * **CV_EVENT_LBUTTONDOWN** Left button down
-
-
- * **CV_EVENT_RBUTTONDOWN** Right button down
-
-
- * **CV_EVENT_MBUTTONDOWN** Middle button down
-
-
- * **CV_EVENT_LBUTTONUP** Left button up
-
-
- * **CV_EVENT_RBUTTONUP** Right button up
-
-
- * **CV_EVENT_MBUTTONUP** Middle button up
-
-
- * **CV_EVENT_LBUTTONDBLCLK** Left button double click
-
-
- * **CV_EVENT_RBUTTONDBLCLK** Right button double click
-
-
- * **CV_EVENT_MBUTTONDBLCLK** Middle button double click
-
-
-
-The
-``flags``
-parameter is a combination of :
-
-
-
-
- * **CV_EVENT_FLAG_LBUTTON** Left button pressed
-
-
- * **CV_EVENT_FLAG_RBUTTON** Right button pressed
-
-
- * **CV_EVENT_FLAG_MBUTTON** Middle button pressed
-
-
- * **CV_EVENT_FLAG_CTRLKEY** Control key pressed
-
-
- * **CV_EVENT_FLAG_SHIFTKEY** Shift key pressed
-
-
- * **CV_EVENT_FLAG_ALTKEY** Alt key pressed
-
-
-
-
-.. index:: SetTrackbarPos
-
-.. _SetTrackbarPos:
-
-SetTrackbarPos
---------------
-
-`id=0.722744232916 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/SetTrackbarPos>`__
-
-
-.. function:: SetTrackbarPos(trackbarName,windowName,pos)-> None
-
- Sets the trackbar position.
-
-
-
-
-
-
- :param trackbarName: Name of the trackbar.
-
- :type trackbarName: str
-
-
- :param windowName: Name of the window which is the parent of trackbar.
-
- :type windowName: str
-
-
- :param pos: New position.
-
- :type pos: int
-
-
-
-The function
-``cvSetTrackbarPos``
-sets the position of the specified trackbar.
-\
-\
-**[Qt Backend Only]**
-qt-specific details:
-
-
-
- * **windowName** Name of the window which is the parent of trackbar. Can be NULL if the trackbar is attached to the control panel.
-
-
-
-
-.. index:: ShowImage
-
-.. _ShowImage:
-
-ShowImage
----------
-
-`id=0.260802502296 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/ShowImage>`__
-
-
-.. function:: ShowImage(name,image)-> None
-
- Displays the image in the specified window
-
-
-
-
-
-
- :param name: Name of the window.
-
- :type name: str
-
-
- :param image: Image to be shown.
-
- :type image: :class:`CvArr`
-
-
-
-The function
-``cvShowImage``
-displays the image in the specified window. If the window was created with the
-``CV_WINDOW_AUTOSIZE``
-flag then the image is shown with its original size, otherwise the image is scaled to fit in the window. The function may scale the image, depending on its depth:
-
-
-
-
-*
- If the image is 8-bit unsigned, it is displayed as is.
-
-
-
-*
- If the image is 16-bit unsigned or 32-bit integer, the pixels are divided by 256. That is, the value range [0,255*256] is mapped to [0,255].
-
-
-
-*
- If the image is 32-bit floating-point, the pixel values are multiplied by 255. That is, the value range [0,1] is mapped to [0,255].
-
-
-
-.. index:: WaitKey
-
-.. _WaitKey:
-
-WaitKey
--------
-
-`id=0.742095797983 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/highgui/WaitKey>`__
-
-
-.. function:: WaitKey(delay=0)-> int
-
- Waits for a pressed key.
-
-
-
-
-
-
- :param delay: Delay in milliseconds.
-
- :type delay: int
-
-
-
-The function
-``cvWaitKey``
-waits for key event infinitely (
-:math:`\texttt{delay} <= 0`
-) or for
-``delay``
-milliseconds. Returns the code of the pressed key or -1 if no key was pressed before the specified time had elapsed.
-
-**Note:**
-This function is the only method in HighGUI that can fetch and handle events, so it needs to be called periodically for normal event processing, unless HighGUI is used within some environment that takes care of event processing.
-\
-\
-**[Qt Backend Only]**
-qt-specific details:
-With this current Qt implementation, this is the only way to process event such as repaint for the windows, and so on
-ldots
+++ /dev/null
-*************************
-imgproc. Image Processing
-*************************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- imgproc_histograms
- imgproc_image_filtering
- imgproc_geometric_image_transformations
- imgproc_miscellaneous_image_transformations
- imgproc_structural_analysis_and_shape_descriptors
- imgproc_planar_subdivisions
- imgproc_motion_analysis_and_object_tracking
- imgproc_feature_detection
- imgproc_object_detection
+++ /dev/null
-Feature Detection
-=================
-
-.. highlight:: python
-
-
-
-.. index:: Canny
-
-.. _Canny:
-
-Canny
------
-
-`id=0.573160740956 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Canny>`__
-
-
-.. function:: Canny(image,edges,threshold1,threshold2,aperture_size=3)-> None
-
- Implements the Canny algorithm for edge detection.
-
-
-
-
-
-
- :param image: Single-channel input image
-
- :type image: :class:`CvArr`
-
-
- :param edges: Single-channel image to store the edges found by the function
-
- :type edges: :class:`CvArr`
-
-
- :param threshold1: The first threshold
-
- :type threshold1: float
-
-
- :param threshold2: The second threshold
-
- :type threshold2: float
-
-
- :param aperture_size: Aperture parameter for the Sobel operator (see :ref:`Sobel` )
-
- :type aperture_size: int
-
-
-
-The function finds the edges on the input image
-``image``
-and marks them in the output image
-``edges``
-using the Canny algorithm. The smallest value between
-``threshold1``
-and
-``threshold2``
-is used for edge linking, the largest value is used to find the initial segments of strong edges.
-
-
-.. index:: CornerEigenValsAndVecs
-
-.. _CornerEigenValsAndVecs:
-
-CornerEigenValsAndVecs
-----------------------
-
-`id=0.769586068428 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CornerEigenValsAndVecs>`__
-
-
-.. function:: CornerEigenValsAndVecs(image,eigenvv,blockSize,aperture_size=3)-> None
-
- Calculates eigenvalues and eigenvectors of image blocks for corner detection.
-
-
-
-
-
-
- :param image: Input image
-
- :type image: :class:`CvArr`
-
-
- :param eigenvv: Image to store the results. It must be 6 times wider than the input image
-
- :type eigenvv: :class:`CvArr`
-
-
- :param blockSize: Neighborhood size (see discussion)
-
- :type blockSize: int
-
-
- :param aperture_size: Aperture parameter for the Sobel operator (see :ref:`Sobel` )
-
- :type aperture_size: int
-
-
-
-For every pixel, the function
-``cvCornerEigenValsAndVecs``
-considers a
-:math:`\texttt{blockSize} \times \texttt{blockSize}`
-neigborhood S(p). It calcualtes the covariation matrix of derivatives over the neigborhood as:
-
-
-
-.. math::
-
- M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}(dI/dx \cdot dI/dy)^2 \\ \sum _{S(p)}(dI/dx \cdot dI/dy)^2 & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}
-
-
-After that it finds eigenvectors and eigenvalues of the matrix and stores them into destination image in form
-:math:`(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)`
-where
-
-
-
-
-* :math:`\lambda_1, \lambda_2`
- are the eigenvalues of
- :math:`M`
- ; not sorted
-
-
-* :math:`x_1, y_1`
- are the eigenvectors corresponding to
- :math:`\lambda_1`
-
-
-* :math:`x_2, y_2`
- are the eigenvectors corresponding to
- :math:`\lambda_2`
-
-
-
-.. index:: CornerHarris
-
-.. _CornerHarris:
-
-CornerHarris
-------------
-
-`id=0.619256620171 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CornerHarris>`__
-
-
-.. function:: CornerHarris(image,harris_dst,blockSize,aperture_size=3,k=0.04)-> None
-
- Harris edge detector.
-
-
-
-
-
-
- :param image: Input image
-
- :type image: :class:`CvArr`
-
-
- :param harris_dst: Image to store the Harris detector responses. Should have the same size as ``image``
-
- :type harris_dst: :class:`CvArr`
-
-
- :param blockSize: Neighborhood size (see the discussion of :ref:`CornerEigenValsAndVecs` )
-
- :type blockSize: int
-
-
- :param aperture_size: Aperture parameter for the Sobel operator (see :ref:`Sobel` ).
-
- :type aperture_size: int
-
-
- :param k: Harris detector free parameter. See the formula below
-
- :type k: float
-
-
-
-The function runs the Harris edge detector on the image. Similarly to
-:ref:`CornerMinEigenVal`
-and
-:ref:`CornerEigenValsAndVecs`
-, for each pixel it calculates a
-:math:`2\times2`
-gradient covariation matrix
-:math:`M`
-over a
-:math:`\texttt{blockSize} \times \texttt{blockSize}`
-neighborhood. Then, it stores
-
-
-
-.. math::
-
- det(M) - k \, trace(M)^2
-
-
-to the destination image. Corners in the image can be found as the local maxima of the destination image.
-
-
-.. index:: CornerMinEigenVal
-
-.. _CornerMinEigenVal:
-
-CornerMinEigenVal
------------------
-
-`id=0.523904183834 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CornerMinEigenVal>`__
-
-
-.. function:: CornerMinEigenVal(image,eigenval,blockSize,aperture_size=3)-> None
-
- Calculates the minimal eigenvalue of gradient matrices for corner detection.
-
-
-
-
-
-
- :param image: Input image
-
- :type image: :class:`CvArr`
-
-
- :param eigenval: Image to store the minimal eigenvalues. Should have the same size as ``image``
-
- :type eigenval: :class:`CvArr`
-
-
- :param blockSize: Neighborhood size (see the discussion of :ref:`CornerEigenValsAndVecs` )
-
- :type blockSize: int
-
-
- :param aperture_size: Aperture parameter for the Sobel operator (see :ref:`Sobel` ).
-
- :type aperture_size: int
-
-
-
-The function is similar to
-:ref:`CornerEigenValsAndVecs`
-but it calculates and stores only the minimal eigen value of derivative covariation matrix for every pixel, i.e.
-:math:`min(\lambda_1, \lambda_2)`
-in terms of the previous function.
-
-
-.. index:: FindCornerSubPix
-
-.. _FindCornerSubPix:
-
-FindCornerSubPix
-----------------
-
-`id=0.448453276565 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FindCornerSubPix>`__
-
-
-.. function:: FindCornerSubPix(image,corners,win,zero_zone,criteria)-> corners
-
- Refines the corner locations.
-
-
-
-
-
-
- :param image: Input image
-
- :type image: :class:`CvArr`
-
-
- :param corners: Initial coordinates of the input corners as a list of (x, y) pairs
-
- :type corners: sequence of (float, float)
-
-
- :param win: Half of the side length of the search window. For example, if ``win`` =(5,5), then a :math:`5*2+1 \times 5*2+1 = 11 \times 11` search window would be used
-
- :type win: :class:`CvSize`
-
-
- :param zero_zone: Half of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such size
-
- :type zero_zone: :class:`CvSize`
-
-
- :param criteria: Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after a certain number of iterations or when a required accuracy is achieved. The ``criteria`` may specify either of or both the maximum number of iteration and the required accuracy
-
- :type criteria: :class:`CvTermCriteria`
-
-
-
-The function iterates to find the sub-pixel accurate location of corners, or radial saddle points, as shown in on the picture below.
-It returns the refined coordinates as a list of (x, y) pairs.
-
-
-.. image:: ../pics/cornersubpix.png
-
-
-
-Sub-pixel accurate corner locator is based on the observation that every vector from the center
-:math:`q`
-to a point
-:math:`p`
-located within a neighborhood of
-:math:`q`
-is orthogonal to the image gradient at
-:math:`p`
-subject to image and measurement noise. Consider the expression:
-
-
-
-.. math::
-
- \epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)
-
-
-where
-:math:`{DI_{p_i}}`
-is the image gradient at the one of the points
-:math:`p_i`
-in a neighborhood of
-:math:`q`
-. The value of
-:math:`q`
-is to be found such that
-:math:`\epsilon_i`
-is minimized. A system of equations may be set up with
-:math:`\epsilon_i`
-set to zero:
-
-
-
-.. math::
-
- \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) q = \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)
-
-
-where the gradients are summed within a neighborhood ("search window") of
-:math:`q`
-. Calling the first gradient term
-:math:`G`
-and the second gradient term
-:math:`b`
-gives:
-
-
-
-.. math::
-
- q = G^{-1} \cdot b
-
-
-The algorithm sets the center of the neighborhood window at this new center
-:math:`q`
-and then iterates until the center keeps within a set threshold.
-
-
-.. index:: GoodFeaturesToTrack
-
-.. _GoodFeaturesToTrack:
-
-GoodFeaturesToTrack
--------------------
-
-`id=0.0875265840344 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GoodFeaturesToTrack>`__
-
-
-.. function:: GoodFeaturesToTrack(image,eigImage,tempImage,cornerCount,qualityLevel,minDistance,mask=NULL,blockSize=3,useHarris=0,k=0.04)-> corners
-
- Determines strong corners on an image.
-
-
-
-
-
-
- :param image: The source 8-bit or floating-point 32-bit, single-channel image
-
- :type image: :class:`CvArr`
-
-
- :param eigImage: Temporary floating-point 32-bit image, the same size as ``image``
-
- :type eigImage: :class:`CvArr`
-
-
- :param tempImage: Another temporary image, the same size and format as ``eigImage``
-
- :type tempImage: :class:`CvArr`
-
-
- :param cornerCount: number of corners to detect
-
- :type cornerCount: int
-
-
- :param qualityLevel: Multiplier for the max/min eigenvalue; specifies the minimal accepted quality of image corners
-
- :type qualityLevel: float
-
-
- :param minDistance: Limit, specifying the minimum possible distance between the returned corners; Euclidian distance is used
-
- :type minDistance: float
-
-
- :param mask: Region of interest. The function selects points either in the specified region or in the whole image if the mask is NULL
-
- :type mask: :class:`CvArr`
-
-
- :param blockSize: Size of the averaging block, passed to the underlying :ref:`CornerMinEigenVal` or :ref:`CornerHarris` used by the function
-
- :type blockSize: int
-
-
- :param useHarris: If nonzero, Harris operator ( :ref:`CornerHarris` ) is used instead of default :ref:`CornerMinEigenVal`
-
- :type useHarris: int
-
-
- :param k: Free parameter of Harris detector; used only if ( :math:`\texttt{useHarris} != 0` )
-
- :type k: float
-
-
-
-The function finds the corners with big eigenvalues in the image. The function first calculates the minimal
-eigenvalue for every source image pixel using the
-:ref:`CornerMinEigenVal`
-function and stores them in
-``eigImage``
-. Then it performs
-non-maxima suppression (only the local maxima in
-:math:`3\times 3`
-neighborhood
-are retained). The next step rejects the corners with the minimal
-eigenvalue less than
-:math:`\texttt{qualityLevel} \cdot max(\texttt{eigImage}(x,y))`
-.
-Finally, the function ensures that the distance between any two corners is not smaller than
-``minDistance``
-. The weaker corners (with a smaller min eigenvalue) that are too close to the stronger corners are rejected.
-
-Note that the if the function is called with different values
-``A``
-and
-``B``
-of the parameter
-``qualityLevel``
-, and
-``A``
-> {B}, the array of returned corners with
-``qualityLevel=A``
-will be the prefix of the output corners array with
-``qualityLevel=B``
-.
-
-
-.. index:: HoughLines2
-
-.. _HoughLines2:
-
-HoughLines2
------------
-
-`id=0.925466467327 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/HoughLines2>`__
-
-
-.. function:: HoughLines2(image,storage,method,rho,theta,threshold,param1=0,param2=0)-> lines
-
- Finds lines in a binary image using a Hough transform.
-
-
-
-
-
-
- :param image: The 8-bit, single-channel, binary source image. In the case of a probabilistic method, the image is modified by the function
-
- :type image: :class:`CvArr`
-
-
- :param storage: The storage for the lines that are detected. It can
- be a memory storage (in this case a sequence of lines is created in
- the storage and returned by the function) or single row/single column
- matrix (CvMat*) of a particular type (see below) to which the lines'
- parameters are written. The matrix header is modified by the function
- so its ``cols`` or ``rows`` will contain the number of lines
- detected. If ``storage`` is a matrix and the actual number
- of lines exceeds the matrix size, the maximum possible number of lines
- is returned (in the case of standard hough transform the lines are sorted
- by the accumulator value)
-
- :type storage: :class:`CvMemStorage`
-
-
- :param method: The Hough transform variant, one of the following:
-
-
- * **CV_HOUGH_STANDARD** classical or standard Hough transform. Every line is represented by two floating-point numbers :math:`(\rho, \theta)` , where :math:`\rho` is a distance between (0,0) point and the line, and :math:`\theta` is the angle between x-axis and the normal to the line. Thus, the matrix must be (the created sequence will be) of ``CV_32FC2`` type
-
-
- * **CV_HOUGH_PROBABILISTIC** probabilistic Hough transform (more efficient in case if picture contains a few long linear segments). It returns line segments rather than the whole line. Each segment is represented by starting and ending points, and the matrix must be (the created sequence will be) of ``CV_32SC4`` type
-
-
- * **CV_HOUGH_MULTI_SCALE** multi-scale variant of the classical Hough transform. The lines are encoded the same way as ``CV_HOUGH_STANDARD``
-
-
-
- :type method: int
-
-
- :param rho: Distance resolution in pixel-related units
-
- :type rho: float
-
-
- :param theta: Angle resolution measured in radians
-
- :type theta: float
-
-
- :param threshold: Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than ``threshold``
-
- :type threshold: int
-
-
- :param param1: The first method-dependent parameter:
-
-
-
- * For the classical Hough transform it is not used (0).
-
-
- * For the probabilistic Hough transform it is the minimum line length.
-
-
- * For the multi-scale Hough transform it is the divisor for the distance resolution :math:`\rho` . (The coarse distance resolution will be :math:`\rho` and the accurate resolution will be :math:`(\rho / \texttt{param1})` ).
-
-
- :type param1: float
-
-
- :param param2: The second method-dependent parameter:
-
-
-
- * For the classical Hough transform it is not used (0).
-
-
- * For the probabilistic Hough transform it is the maximum gap between line segments lying on the same line to treat them as a single line segment (i.e. to join them).
-
-
- * For the multi-scale Hough transform it is the divisor for the angle resolution :math:`\theta` . (The coarse angle resolution will be :math:`\theta` and the accurate resolution will be :math:`(\theta / \texttt{param2})` ).
-
-
- :type param2: float
-
-
-
-The function implements a few variants of the Hough transform for line detection.
-
-
-.. index:: PreCornerDetect
-
-.. _PreCornerDetect:
-
-PreCornerDetect
----------------
-
-`id=0.420590326716 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/PreCornerDetect>`__
-
-
-.. function:: PreCornerDetect(image,corners,apertureSize=3)-> None
-
- Calculates the feature map for corner detection.
-
-
-
-
-
-
- :param image: Input image
-
- :type image: :class:`CvArr`
-
-
- :param corners: Image to store the corner candidates
-
- :type corners: :class:`CvArr`
-
-
- :param apertureSize: Aperture parameter for the Sobel operator (see :ref:`Sobel` )
-
- :type apertureSize: int
-
-
-
-The function calculates the function
-
-
-
-.. math::
-
- D_x^2 D_{yy} + D_y^2 D_{xx} - 2 D_x D_y D_{xy}
-
-
-where
-:math:`D_?`
-denotes one of the first image derivatives and
-:math:`D_{??}`
-denotes a second image derivative.
-
-The corners can be found as local maximums of the function below:
-
-.. include:: /Users/vp/Projects/ocv/opencv/doc/python_fragments/precornerdetect.py
- :literal:
-
-
+++ /dev/null
-Geometric Image Transformations
-===============================
-
-.. highlight:: python
-
-
-The functions in this section perform various geometrical transformations of 2D images. That is, they do not change the image content, but deform the pixel grid, and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel
-:math:`(x, y)`
-of the destination image, the functions compute coordinates of the corresponding "donor" pixel in the source image and copy the pixel value, that is:
-
-
-
-.. math::
-
- \texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))
-
-
-In the case when the user specifies the forward mapping:
-:math:`\left<g_x, g_y\right>: \texttt{src} \rightarrow \texttt{dst}`
-, the OpenCV functions first compute the corresponding inverse mapping:
-:math:`\left<f_x, f_y\right>: \texttt{dst} \rightarrow \texttt{src}`
-and then use the above formula.
-
-The actual implementations of the geometrical transformations, from the most generic
-:ref:`Remap`
-and to the simplest and the fastest
-:ref:`Resize`
-, need to solve the 2 main problems with the above formula:
-
-
-
-
-#.
- extrapolation of non-existing pixels. Similarly to the filtering functions, described in the previous section, for some
- :math:`(x,y)`
- one of
- :math:`f_x(x,y)`
- or
- :math:`f_y(x,y)`
- , or they both, may fall outside of the image, in which case some extrapolation method needs to be used. OpenCV provides the same selection of the extrapolation methods as in the filtering functions, but also an additional method
- ``BORDER_TRANSPARENT``
- , which means that the corresponding pixels in the destination image will not be modified at all.
-
-
-
-#.
- interpolation of pixel values. Usually
- :math:`f_x(x,y)`
- and
- :math:`f_y(x,y)`
- are floating-point numbers (i.e.
- :math:`\left<f_x, f_y\right>`
- can be an affine or perspective transformation, or radial lens distortion correction etc.), so a pixel values at fractional coordinates needs to be retrieved. In the simplest case the coordinates can be just rounded to the nearest integer coordinates and the corresponding pixel used, which is called nearest-neighbor interpolation. However, a better result can be achieved by using more sophisticated
- `interpolation methods <http://en.wikipedia.org/wiki/Multivariate_interpolation>`_
- , where a polynomial function is fit into some neighborhood of the computed pixel
- :math:`(f_x(x,y), f_y(x,y))`
- and then the value of the polynomial at
- :math:`(f_x(x,y), f_y(x,y))`
- is taken as the interpolated pixel value. In OpenCV you can choose between several interpolation methods, see
- :ref:`Resize`
- .
-
-
-
-.. index:: GetRotationMatrix2D
-
-.. _GetRotationMatrix2D:
-
-GetRotationMatrix2D
--------------------
-
-`id=0.155746043393 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetRotationMatrix2D>`__
-
-
-.. function:: GetRotationMatrix2D(center,angle,scale,mapMatrix)-> None
-
- Calculates the affine matrix of 2d rotation.
-
-
-
-
-
-
- :param center: Center of the rotation in the source image
-
- :type center: :class:`CvPoint2D32f`
-
-
- :param angle: The rotation angle in degrees. Positive values mean counter-clockwise rotation (the coordinate origin is assumed to be the top-left corner)
-
- :type angle: float
-
-
- :param scale: Isotropic scale factor
-
- :type scale: float
-
-
- :param mapMatrix: Pointer to the destination :math:`2\times 3` matrix
-
- :type mapMatrix: :class:`CvMat`
-
-
-
-The function
-``cv2DRotationMatrix``
-calculates the following matrix:
-
-
-
-.. math::
-
- \begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} - (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}
-
-
-where
-
-
-
-.. math::
-
- \alpha = \texttt{scale} \cdot cos( \texttt{angle} ), \beta = \texttt{scale} \cdot sin( \texttt{angle} )
-
-
-The transformation maps the rotation center to itself. If this is not the purpose, the shift should be adjusted.
-
-
-.. index:: GetAffineTransform
-
-.. _GetAffineTransform:
-
-GetAffineTransform
-------------------
-
-`id=0.131853152013 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetAffineTransform>`__
-
-
-.. function:: GetAffineTransform(src,dst,mapMatrix)-> None
-
- Calculates the affine transform from 3 corresponding points.
-
-
-
-
-
-
- :param src: Coordinates of 3 triangle vertices in the source image
-
- :type src: :class:`CvPoint2D32f`
-
-
- :param dst: Coordinates of the 3 corresponding triangle vertices in the destination image
-
- :type dst: :class:`CvPoint2D32f`
-
-
- :param mapMatrix: Pointer to the destination :math:`2 \times 3` matrix
-
- :type mapMatrix: :class:`CvMat`
-
-
-
-The function cvGetAffineTransform calculates the matrix of an affine transform such that:
-
-
-
-.. math::
-
- \begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}
-
-
-where
-
-
-
-.. math::
-
- dst(i)=(x'_i,y'_i),
- src(i)=(x_i, y_i),
- i=0,1,2
-
-
-
-.. index:: GetPerspectiveTransform
-
-.. _GetPerspectiveTransform:
-
-GetPerspectiveTransform
------------------------
-
-`id=0.411609579387 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetPerspectiveTransform>`__
-
-
-.. function:: GetPerspectiveTransform(src,dst,mapMatrix)-> None
-
- Calculates the perspective transform from 4 corresponding points.
-
-
-
-
-
-
- :param src: Coordinates of 4 quadrangle vertices in the source image
-
- :type src: :class:`CvPoint2D32f`
-
-
- :param dst: Coordinates of the 4 corresponding quadrangle vertices in the destination image
-
- :type dst: :class:`CvPoint2D32f`
-
-
- :param mapMatrix: Pointer to the destination :math:`3\times 3` matrix
-
- :type mapMatrix: :class:`CvMat`
-
-
-
-The function
-``cvGetPerspectiveTransform``
-calculates a matrix of perspective transforms such that:
-
-
-
-.. math::
-
- \begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}
-
-
-where
-
-
-
-.. math::
-
- dst(i)=(x'_i,y'_i),
- src(i)=(x_i, y_i),
- i=0,1,2,3
-
-
-
-.. index:: GetQuadrangleSubPix
-
-.. _GetQuadrangleSubPix:
-
-GetQuadrangleSubPix
--------------------
-
-`id=0.522776327076 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetQuadrangleSubPix>`__
-
-
-.. function:: GetQuadrangleSubPix(src,dst,mapMatrix)-> None
-
- Retrieves the pixel quadrangle from an image with sub-pixel accuracy.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Extracted quadrangle
-
- :type dst: :class:`CvArr`
-
-
- :param mapMatrix: The transformation :math:`2 \times 3` matrix :math:`[A|b]` (see the discussion)
-
- :type mapMatrix: :class:`CvMat`
-
-
-
-The function
-``cvGetQuadrangleSubPix``
-extracts pixels from
-``src``
-at sub-pixel accuracy and stores them to
-``dst``
-as follows:
-
-
-
-.. math::
-
- dst(x, y)= src( A_{11} x' + A_{12} y' + b_1, A_{21} x' + A_{22} y' + b_2)
-
-
-where
-
-
-
-.. math::
-
- x'=x- \frac{(width(dst)-1)}{2} ,
- y'=y- \frac{(height(dst)-1)}{2}
-
-
-and
-
-
-
-.. math::
-
- \texttt{mapMatrix} = \begin{bmatrix} A_{11} & A_{12} & b_1 \\ A_{21} & A_{22} & b_2 \end{bmatrix}
-
-
-The values of pixels at non-integer coordinates are retrieved using bilinear interpolation. When the function needs pixels outside of the image, it uses replication border mode to reconstruct the values. Every channel of multiple-channel images is processed independently.
-
-
-
-.. index:: GetRectSubPix
-
-.. _GetRectSubPix:
-
-GetRectSubPix
--------------
-
-`id=0.947278759693 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetRectSubPix>`__
-
-
-.. function:: GetRectSubPix(src,dst,center)-> None
-
- Retrieves the pixel rectangle from an image with sub-pixel accuracy.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Extracted rectangle
-
- :type dst: :class:`CvArr`
-
-
- :param center: Floating point coordinates of the extracted rectangle center within the source image. The center must be inside the image
-
- :type center: :class:`CvPoint2D32f`
-
-
-
-The function
-``cvGetRectSubPix``
-extracts pixels from
-``src``
-:
-
-
-
-.. math::
-
- dst(x, y) = src(x + \texttt{center.x} - (width( \texttt{dst} )-1)*0.5, y + \texttt{center.y} - (height( \texttt{dst} )-1)*0.5)
-
-
-where the values of the pixels at non-integer coordinates are retrieved
-using bilinear interpolation. Every channel of multiple-channel
-images is processed independently. While the rectangle center
-must be inside the image, parts of the rectangle may be
-outside. In this case, the replication border mode is used to get
-pixel values beyond the image boundaries.
-
-
-
-.. index:: LogPolar
-
-.. _LogPolar:
-
-LogPolar
---------
-
-`id=0.991629705277 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/LogPolar>`__
-
-
-.. function:: LogPolar(src,dst,center,M,flags=CV_INNER_LINEAR+CV_WARP_FILL_OUTLIERS)-> None
-
- Remaps an image to log-polar space.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param center: The transformation center; where the output precision is maximal
-
- :type center: :class:`CvPoint2D32f`
-
-
- :param M: Magnitude scale parameter. See below
-
- :type M: float
-
-
- :param flags: A combination of interpolation methods and the following optional flags:
-
-
- * **CV_WARP_FILL_OUTLIERS** fills all of the destination image pixels. If some of them correspond to outliers in the source image, they are set to zero
-
-
- * **CV_WARP_INVERSE_MAP** See below
-
-
-
- :type flags: int
-
-
-
-The function
-``cvLogPolar``
-transforms the source image using the following transformation:
-
-Forward transformation (
-``CV_WARP_INVERSE_MAP``
-is not set):
-
-
-
-.. math::
-
- dst( \phi , \rho ) = src(x,y)
-
-
-Inverse transformation (
-``CV_WARP_INVERSE_MAP``
-is set):
-
-
-
-.. math::
-
- dst(x,y) = src( \phi , \rho )
-
-
-where
-
-
-
-.. math::
-
- \rho = M \cdot \log{\sqrt{x^2 + y^2}} , \phi =atan(y/x)
-
-
-The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking and so forth.
-The function can not operate in-place.
-
-
-.. index:: Remap
-
-.. _Remap:
-
-Remap
------
-
-`id=0.129979785029 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Remap>`__
-
-
-.. function:: Remap(src,dst,mapx,mapy,flags=CV_INNER_LINEAR+CV_WARP_FILL_OUTLIERS,fillval=(0,0,0,0))-> None
-
- Applies a generic geometrical transformation to the image.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param mapx: The map of x-coordinates (CV _ 32FC1 image)
-
- :type mapx: :class:`CvArr`
-
-
- :param mapy: The map of y-coordinates (CV _ 32FC1 image)
-
- :type mapy: :class:`CvArr`
-
-
- :param flags: A combination of interpolation method and the following optional flag(s):
-
-
- * **CV_WARP_FILL_OUTLIERS** fills all of the destination image pixels. If some of them correspond to outliers in the source image, they are set to ``fillval``
-
-
-
- :type flags: int
-
-
- :param fillval: A value used to fill outliers
-
- :type fillval: :class:`CvScalar`
-
-
-
-The function
-``cvRemap``
-transforms the source image using the specified map:
-
-
-
-.. math::
-
- \texttt{dst} (x,y) = \texttt{src} ( \texttt{mapx} (x,y), \texttt{mapy} (x,y))
-
-
-Similar to other geometrical transformations, some interpolation method (specified by user) is used to extract pixels with non-integer coordinates.
-Note that the function can not operate in-place.
-
-
-.. index:: Resize
-
-.. _Resize:
-
-Resize
-------
-
-`id=0.923811087592 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Resize>`__
-
-
-.. function:: Resize(src,dst,interpolation=CV_INTER_LINEAR)-> None
-
- Resizes an image.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param interpolation: Interpolation method:
-
- * **CV_INTER_NN** nearest-neigbor interpolation
-
- * **CV_INTER_LINEAR** bilinear interpolation (used by default)
-
- * **CV_INTER_AREA** resampling using pixel area relation. It is the preferred method for image decimation that gives moire-free results. In terms of zooming it is similar to the ``CV_INTER_NN`` method
-
- * **CV_INTER_CUBIC** bicubic interpolation
-
-
-
- :type interpolation: int
-
-
-
-The function
-``cvResize``
-resizes an image
-``src``
-so that it fits exactly into
-``dst``
-. If ROI is set, the function considers the ROI as supported.
-
-
-
-.. index:: WarpAffine
-
-.. _WarpAffine:
-
-WarpAffine
-----------
-
-`id=0.314654704506 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/WarpAffine>`__
-
-
-.. function:: WarpAffine(src,dst,mapMatrix,flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,fillval=(0,0,0,0))-> None
-
- Applies an affine transformation to an image.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param mapMatrix: :math:`2\times 3` transformation matrix
-
- :type mapMatrix: :class:`CvMat`
-
-
- :param flags: A combination of interpolation methods and the following optional flags:
-
-
- * **CV_WARP_FILL_OUTLIERS** fills all of the destination image pixels; if some of them correspond to outliers in the source image, they are set to ``fillval``
-
-
- * **CV_WARP_INVERSE_MAP** indicates that ``matrix`` is inversely
- transformed from the destination image to the source and, thus, can be used
- directly for pixel interpolation. Otherwise, the function finds
- the inverse transform from ``mapMatrix``
-
-
- :type flags: int
-
-
-
-
- :param fillval: A value used to fill outliers
-
- :type fillval: :class:`CvScalar`
-
-
-
-The function
-``cvWarpAffine``
-transforms the source image using the specified matrix:
-
-
-
-.. math::
-
- dst(x',y') = src(x,y)
-
-
-where
-
-
-
-.. math::
-
- \begin{matrix} \begin{bmatrix} x' \\ y' \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} & \mbox{if CV\_WARP\_INVERSE\_MAP is not set} \\ \begin{bmatrix} x \\ y \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} & \mbox{otherwise} \end{matrix}
-
-
-The function is similar to
-:ref:`GetQuadrangleSubPix`
-but they are not exactly the same.
-:ref:`WarpAffine`
-requires input and output image have the same data type, has larger overhead (so it is not quite suitable for small images) and can leave part of destination image unchanged. While
-:ref:`GetQuadrangleSubPix`
-may extract quadrangles from 8-bit images into floating-point buffer, has smaller overhead and always changes the whole destination image content.
-Note that the function can not operate in-place.
-
-To transform a sparse set of points, use the
-:ref:`Transform`
-function from cxcore.
-
-
-.. index:: WarpPerspective
-
-.. _WarpPerspective:
-
-WarpPerspective
----------------
-
-`id=0.554206520217 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/WarpPerspective>`__
-
-
-.. function:: WarpPerspective(src,dst,mapMatrix,flags=CV_INNER_LINEAR+CV_WARP_FILL_OUTLIERS,fillval=(0,0,0,0))-> None
-
- Applies a perspective transformation to an image.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param mapMatrix: :math:`3\times 3` transformation matrix
-
- :type mapMatrix: :class:`CvMat`
-
-
- :param flags: A combination of interpolation methods and the following optional flags:
-
-
- * **CV_WARP_FILL_OUTLIERS** fills all of the destination image pixels; if some of them correspond to outliers in the source image, they are set to ``fillval``
-
-
- * **CV_WARP_INVERSE_MAP** indicates that ``matrix`` is inversely transformed from the destination image to the source and, thus, can be used directly for pixel interpolation. Otherwise, the function finds the inverse transform from ``mapMatrix``
-
-
-
- :type flags: int
-
-
- :param fillval: A value used to fill outliers
-
- :type fillval: :class:`CvScalar`
-
-
-
-The function
-``cvWarpPerspective``
-transforms the source image using the specified matrix:
-
-
-
-.. math::
-
- \begin{matrix} \begin{bmatrix} x' \\ y' \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} & \mbox{if CV\_WARP\_INVERSE\_MAP is not set} \\ \begin{bmatrix} x \\ y \end{bmatrix} = \texttt{mapMatrix} \cdot \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} & \mbox{otherwise} \end{matrix}
-
-
-Note that the function can not operate in-place.
-For a sparse set of points use the
-:ref:`PerspectiveTransform`
-function from CxCore.
-
+++ /dev/null
-Histograms
-==========
-
-.. highlight:: python
-
-
-
-.. index:: CvHistogram
-
-.. _CvHistogram:
-
-CvHistogram
------------
-
-`id=0.182438452658 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvHistogram>`__
-
-.. class:: CvHistogram
-
-
-
-Multi-dimensional histogram.
-
-A CvHistogram is a multi-dimensional histogram, created by function
-:ref:`CreateHist`
-. It has an attribute
-``bins``
-a
-:ref:`CvMatND`
-containing the histogram counts.
-
-.. index:: CalcBackProject
-
-.. _CalcBackProject:
-
-CalcBackProject
----------------
-
-`id=0.913786988566 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcBackProject>`__
-
-
-.. function:: CalcBackProject(image,back_project,hist)-> None
-
- Calculates the back projection.
-
-
-
-
-
-
- :param image: Source images (though you may pass CvMat** as well)
-
- :type image: sequence of :class:`IplImage`
-
-
- :param back_project: Destination back projection image of the same type as the source images
-
- :type back_project: :class:`CvArr`
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
-
-The function calculates the back project of the histogram. For each
-tuple of pixels at the same position of all input single-channel images
-the function puts the value of the histogram bin, corresponding to the
-tuple in the destination image. In terms of statistics, the value of
-each output image pixel is the probability of the observed tuple given
-the distribution (histogram). For example, to find a red object in the
-picture, one may do the following:
-
-
-
-
-
-#.
- Calculate a hue histogram for the red object assuming the image contains only this object. The histogram is likely to have a strong maximum, corresponding to red color.
-
-
-
-#.
- Calculate back projection of a hue plane of input image where the object is searched, using the histogram. Threshold the image.
-
-
-
-#.
- Find connected components in the resulting picture and choose the right component using some additional criteria, for example, the largest connected component.
-
-
-That is the approximate algorithm of Camshift color object tracker, except for the 3rd step, instead of which CAMSHIFT algorithm is used to locate the object on the back projection given the previous object position.
-
-
-.. index:: CalcBackProjectPatch
-
-.. _CalcBackProjectPatch:
-
-CalcBackProjectPatch
---------------------
-
-`id=0.817068389137 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcBackProjectPatch>`__
-
-
-.. function:: CalcBackProjectPatch(images,dst,patch_size,hist,method,factor)-> None
-
- Locates a template within an image by using a histogram comparison.
-
-
-
-
-
-
- :param images: Source images (though, you may pass CvMat** as well)
-
- :type images: sequence of :class:`IplImage`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param patch_size: Size of the patch slid though the source image
-
- :type patch_size: :class:`CvSize`
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param method: Comparison method, passed to :ref:`CompareHist` (see description of that function)
-
- :type method: int
-
-
- :param factor: Normalization factor for histograms, will affect the normalization scale of the destination image, pass 1 if unsure
-
- :type factor: float
-
-
-
-The function calculates the back projection by comparing histograms of the source image patches with the given histogram. Taking measurement results from some image at each location over ROI creates an array
-``image``
-. These results might be one or more of hue,
-``x``
-derivative,
-``y``
-derivative, Laplacian filter, oriented Gabor filter, etc. Each measurement output is collected into its own separate image. The
-``image``
-image array is a collection of these measurement images. A multi-dimensional histogram
-``hist``
-is constructed by sampling from the
-``image``
-image array. The final histogram is normalized. The
-``hist``
-histogram has as many dimensions as the number of elements in
-``image``
-array.
-
-Each new image is measured and then converted into an
-``image``
-image array over a chosen ROI. Histograms are taken from this
-``image``
-image in an area covered by a "patch" with an anchor at center as shown in the picture below. The histogram is normalized using the parameter
-``norm_factor``
-so that it may be compared with
-``hist``
-. The calculated histogram is compared to the model histogram;
-``hist``
-uses The function
-``cvCompareHist``
-with the comparison method=
-``method``
-). The resulting output is placed at the location corresponding to the patch anchor in the probability image
-``dst``
-. This process is repeated as the patch is slid over the ROI. Iterative histogram update by subtracting trailing pixels covered by the patch and adding newly covered pixels to the histogram can save a lot of operations, though it is not implemented yet.
-
-Back Project Calculation by Patches
-
-
-
-.. image:: ../pics/backprojectpatch.png
-
-
-
-
-.. index:: CalcHist
-
-.. _CalcHist:
-
-CalcHist
---------
-
-`id=0.937336139373 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcHist>`__
-
-
-.. function:: CalcHist(image,hist,accumulate=0,mask=NULL)-> None
-
- Calculates the histogram of image(s).
-
-
-
-
-
-
- :param image: Source images (though you may pass CvMat** as well)
-
- :type image: sequence of :class:`IplImage`
-
-
- :param hist: Pointer to the histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param accumulate: Accumulation flag. If it is set, the histogram is not cleared in the beginning. This feature allows user to compute a single histogram from several images, or to update the histogram online
-
- :type accumulate: int
-
-
- :param mask: The operation mask, determines what pixels of the source images are counted
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates the histogram of one or more
-single-channel images. The elements of a tuple that is used to increment
-a histogram bin are taken at the same location from the corresponding
-input images.
-
-.. include:: /Users/vp/Projects/ocv/opencv/doc/python_fragments/calchist.py
- :literal:
-
-
-
-.. index:: CalcProbDensity
-
-.. _CalcProbDensity:
-
-CalcProbDensity
----------------
-
-`id=0.656540136559 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcProbDensity>`__
-
-
-.. function:: CalcProbDensity(hist1,hist2,dst_hist,scale=255)-> None
-
- Divides one histogram by another.
-
-
-
-
-
-
- :param hist1: first histogram (the divisor)
-
- :type hist1: :class:`CvHistogram`
-
-
- :param hist2: second histogram
-
- :type hist2: :class:`CvHistogram`
-
-
- :param dst_hist: destination histogram
-
- :type dst_hist: :class:`CvHistogram`
-
-
- :param scale: scale factor for the destination histogram
-
- :type scale: float
-
-
-
-The function calculates the object probability density from the two histograms as:
-
-
-
-.. math::
-
- \texttt{dist\_hist} (I)= \forkthree{0}{if $\texttt{hist1}(I)=0$}{\texttt{scale}}{if $\texttt{hist1}(I) \ne 0$ and $\texttt{hist2}(I) > \texttt{hist1}(I)$}{\frac{\texttt{hist2}(I) \cdot \texttt{scale}}{\texttt{hist1}(I)}}{if $\texttt{hist1}(I) \ne 0$ and $\texttt{hist2}(I) \le \texttt{hist1}(I)$}
-
-
-So the destination histogram bins are within less than
-``scale``
-.
-
-
-.. index:: ClearHist
-
-.. _ClearHist:
-
-ClearHist
----------
-
-`id=0.0803392460869 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ClearHist>`__
-
-
-.. function:: ClearHist(hist)-> None
-
- Clears the histogram.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
-
-The function sets all of the histogram bins to 0 in the case of a dense histogram and removes all histogram bins in the case of a sparse array.
-
-
-.. index:: CompareHist
-
-.. _CompareHist:
-
-CompareHist
------------
-
-`id=0.913670879358 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CompareHist>`__
-
-
-.. function:: CompareHist(hist1,hist2,method)->float
-
- Compares two dense histograms.
-
-
-
-
-
-
- :param hist1: The first dense histogram
-
- :type hist1: :class:`CvHistogram`
-
-
- :param hist2: The second dense histogram
-
- :type hist2: :class:`CvHistogram`
-
-
- :param method: Comparison method, one of the following:
-
-
- * **CV_COMP_CORREL** Correlation
-
-
- * **CV_COMP_CHISQR** Chi-Square
-
-
- * **CV_COMP_INTERSECT** Intersection
-
-
- * **CV_COMP_BHATTACHARYYA** Bhattacharyya distance
-
-
-
- :type method: int
-
-
-
-The function compares two dense histograms using the specified method (
-:math:`H_1`
-denotes the first histogram,
-:math:`H_2`
-the second):
-
-
-
-
-
-* Correlation (method=CV\_COMP\_CORREL)
-
-
- .. math::
-
- d(H_1,H_2) = \frac{\sum_I (H'_1(I) \cdot H'_2(I))}{\sqrt{\sum_I(H'_1(I)^2) \cdot \sum_I(H'_2(I)^2)}}
-
-
- where
-
-
- .. math::
-
- H'_k(I) = \frac{H_k(I) - 1}{N \cdot \sum_J H_k(J)}
-
-
- where N is the number of histogram bins.
-
-
-
-* Chi-Square (method=CV\_COMP\_CHISQR)
-
-
- .. math::
-
- d(H_1,H_2) = \sum _I \frac{(H_1(I)-H_2(I))^2}{H_1(I)+H_2(I)}
-
-
-
-
-* Intersection (method=CV\_COMP\_INTERSECT)
-
-
- .. math::
-
- d(H_1,H_2) = \sum _I \min (H_1(I), H_2(I))
-
-
-
-
-* Bhattacharyya distance (method=CV\_COMP\_BHATTACHARYYA)
-
-
- .. math::
-
- d(H_1,H_2) = \sqrt{1 - \sum_I \frac{\sqrt{H_1(I) \cdot H_2(I)}}{ \sqrt{ \sum_I H_1(I) \cdot \sum_I H_2(I) }}}
-
-
-
-
-The function returns
-:math:`d(H_1, H_2)`
-.
-
-Note: the method
-``CV_COMP_BHATTACHARYYA``
-only works with normalized histograms.
-
-To compare a sparse histogram or more general sparse configurations of weighted points, consider using the
-:ref:`CalcEMD2`
-function.
-
-
-.. index:: CreateHist
-
-.. _CreateHist:
-
-CreateHist
-----------
-
-`id=0.716036535258 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CreateHist>`__
-
-
-.. function:: CreateHist(dims, type, ranges, uniform = 1) -> hist
-
- Creates a histogram.
-
-
-
-
-
-
- :param dims: for an N-dimensional histogram, list of length N giving the size of each dimension
-
- :type dims: sequence of int
-
-
- :param type: Histogram representation format: ``CV_HIST_ARRAY`` means that the histogram data is represented as a multi-dimensional dense array CvMatND; ``CV_HIST_SPARSE`` means that histogram data is represented as a multi-dimensional sparse array CvSparseMat
-
- :type type: int
-
-
- :param ranges: Array of ranges for the histogram bins. Its meaning depends on the ``uniform`` parameter value. The ranges are used for when the histogram is calculated or backprojected to determine which histogram bin corresponds to which value/tuple of values from the input image(s)
-
- :type ranges: list of tuples of ints
-
-
- :param uniform: Uniformity flag; if not 0, the histogram has evenly
- spaced bins and for every :math:`0<=i<cDims` ``ranges[i]``
- is an array of two numbers: lower and upper boundaries for the i-th
- histogram dimension.
- The whole range [lower,upper] is then split
- into ``dims[i]`` equal parts to determine the ``i-th`` input
- tuple value ranges for every histogram bin. And if ``uniform=0`` ,
- then ``i-th`` element of ``ranges`` array contains ``dims[i]+1`` elements: :math:`\texttt{lower}_0, \texttt{upper}_0,
- \texttt{lower}_1, \texttt{upper}_1 = \texttt{lower}_2,
- ...
- \texttt{upper}_{dims[i]-1}`
- where :math:`\texttt{lower}_j` and :math:`\texttt{upper}_j`
- are lower and upper
- boundaries of ``i-th`` input tuple value for ``j-th``
- bin, respectively. In either case, the input values that are beyond
- the specified range for a histogram bin are not counted by :ref:`CalcHist` and filled with 0 by :ref:`CalcBackProject`
-
- :type uniform: int
-
-
-
-The function creates a histogram of the specified
-size and returns a pointer to the created histogram. If the array
-``ranges``
-is 0, the histogram bin ranges must be specified later
-via the function
-:ref:`SetHistBinRanges`
-. Though
-:ref:`CalcHist`
-and
-:ref:`CalcBackProject`
-may process 8-bit images without setting
-bin ranges, they assume thy are equally spaced in 0 to 255 bins.
-
-
-.. index:: GetMinMaxHistValue
-
-.. _GetMinMaxHistValue:
-
-GetMinMaxHistValue
-------------------
-
-`id=0.698817534292 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetMinMaxHistValue>`__
-
-
-.. function:: GetMinMaxHistValue(hist)-> (min_value,max_value,min_idx,max_idx)
-
- Finds the minimum and maximum histogram bins.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param min_value: Minimum value of the histogram
-
- :type min_value: :class:`CvScalar`
-
-
- :param max_value: Maximum value of the histogram
-
- :type max_value: :class:`CvScalar`
-
-
- :param min_idx: Coordinates of the minimum
-
- :type min_idx: sequence of int
-
-
- :param max_idx: Coordinates of the maximum
-
- :type max_idx: sequence of int
-
-
-
-The function finds the minimum and
-maximum histogram bins and their positions. All of output arguments are
-optional. Among several extremas with the same value the ones with the
-minimum index (in lexicographical order) are returned. In the case of several maximums
-or minimums, the earliest in lexicographical order (extrema locations)
-is returned.
-
-
-.. index:: NormalizeHist
-
-.. _NormalizeHist:
-
-NormalizeHist
--------------
-
-`id=0.905166705956 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/NormalizeHist>`__
-
-
-.. function:: NormalizeHist(hist,factor)-> None
-
- Normalizes the histogram.
-
-
-
-
-
-
- :param hist: Pointer to the histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param factor: Normalization factor
-
- :type factor: float
-
-
-
-The function normalizes the histogram bins by scaling them, such that the sum of the bins becomes equal to
-``factor``
-.
-
-
-.. index:: QueryHistValue_1D
-
-.. _QueryHistValue_1D:
-
-QueryHistValue_1D
------------------
-
-`id=0.26842391983 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/QueryHistValue_1D>`__
-
-
-.. function:: QueryHistValue_1D(hist, idx0) -> float
-
- Returns the value from a 1D histogram bin.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param idx0: bin index 0
-
- :type idx0: int
-
-
-
-
-.. index:: QueryHistValue_2D
-
-.. _QueryHistValue_2D:
-
-QueryHistValue_2D
------------------
-
-`id=0.149356032534 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/QueryHistValue_2D>`__
-
-
-.. function:: QueryHistValue_2D(hist, idx0, idx1) -> float
-
- Returns the value from a 2D histogram bin.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param idx0: bin index 0
-
- :type idx0: int
-
-
- :param idx1: bin index 1
-
- :type idx1: int
-
-
-
-
-.. index:: QueryHistValue_3D
-
-.. _QueryHistValue_3D:
-
-QueryHistValue_3D
------------------
-
-`id=0.846880584809 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/QueryHistValue_3D>`__
-
-
-.. function:: QueryHistValue_3D(hist, idx0, idx1, idx2) -> float
-
- Returns the value from a 3D histogram bin.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param idx0: bin index 0
-
- :type idx0: int
-
-
- :param idx1: bin index 1
-
- :type idx1: int
-
-
- :param idx2: bin index 2
-
- :type idx2: int
-
-
-
-
-.. index:: QueryHistValue_nD
-
-.. _QueryHistValue_nD:
-
-QueryHistValue_nD
------------------
-
-`id=0.36909443826 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/QueryHistValue_nD>`__
-
-
-.. function:: QueryHistValue_nD(hist, idx) -> float
-
- Returns the value from a 1D histogram bin.
-
-
-
-
-
-
- :param hist: Histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param idx: list of indices, of same length as the dimension of the histogram's bin.
-
- :type idx: sequence of int
-
-
-
-
-.. index:: ThreshHist
-
-.. _ThreshHist:
-
-ThreshHist
-----------
-
-`id=0.255496509485 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ThreshHist>`__
-
-
-.. function:: ThreshHist(hist,threshold)-> None
-
- Thresholds the histogram.
-
-
-
-
-
-
- :param hist: Pointer to the histogram
-
- :type hist: :class:`CvHistogram`
-
-
- :param threshold: Threshold level
-
- :type threshold: float
-
-
-
-The function clears histogram bins that are below the specified threshold.
-
+++ /dev/null
-Image Filtering
-===============
-
-.. highlight:: python
-
-
-Functions and classes described in this section are used to perform various linear or non-linear filtering operations on 2D images (represented as
-:func:`Mat`
-'s), that is, for each pixel location
-:math:`(x,y)`
-in the source image some its (normally rectangular) neighborhood is considered and used to compute the response. In case of a linear filter it is a weighted sum of pixel values, in case of morphological operations it is the minimum or maximum etc. The computed response is stored to the destination image at the same location
-:math:`(x,y)`
-. It means, that the output image will be of the same size as the input image. Normally, the functions supports multi-channel arrays, in which case every channel is processed independently, therefore the output image will also have the same number of channels as the input one.
-
-Another common feature of the functions and classes described in this section is that, unlike simple arithmetic functions, they need to extrapolate values of some non-existing pixels. For example, if we want to smooth an image using a Gaussian
-:math:`3 \times 3`
-filter, then during the processing of the left-most pixels in each row we need pixels to the left of them, i.e. outside of the image. We can let those pixels be the same as the left-most image pixels (i.e. use "replicated border" extrapolation method), or assume that all the non-existing pixels are zeros ("contant border" extrapolation method) etc.
-
-.. index:: IplConvKernel
-
-.. _IplConvKernel:
-
-IplConvKernel
--------------
-
-`id=0.589941281227 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/IplConvKernel>`__
-
-.. class:: IplConvKernel
-
-
-
-An IplConvKernel is a rectangular convolution kernel, created by function
-:ref:`CreateStructuringElementEx`
-.
-
-
-.. index:: CopyMakeBorder
-
-.. _CopyMakeBorder:
-
-CopyMakeBorder
---------------
-
-`id=0.392095677822 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CopyMakeBorder>`__
-
-
-.. function:: CopyMakeBorder(src,dst,offset,bordertype,value=(0,0,0,0))-> None
-
- Copies an image and makes a border around it.
-
-
-
-
-
-
- :param src: The source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image
-
- :type dst: :class:`CvArr`
-
-
- :param offset: Coordinates of the top-left corner (or bottom-left in the case of images with bottom-left origin) of the destination image rectangle where the source image (or its ROI) is copied. Size of the rectanlge matches the source image size/ROI size
-
- :type offset: :class:`CvPoint`
-
-
- :param bordertype: Type of the border to create around the copied source image rectangle; types include:
-
- * **IPL_BORDER_CONSTANT** border is filled with the fixed value, passed as last parameter of the function.
-
- * **IPL_BORDER_REPLICATE** the pixels from the top and bottom rows, the left-most and right-most columns are replicated to fill the border.
-
-
- (The other two border types from IPL, ``IPL_BORDER_REFLECT`` and ``IPL_BORDER_WRAP`` , are currently unsupported)
-
- :type bordertype: int
-
-
- :param value: Value of the border pixels if ``bordertype`` is ``IPL_BORDER_CONSTANT``
-
- :type value: :class:`CvScalar`
-
-
-
-The function copies the source 2D array into the interior of the destination array and makes a border of the specified type around the copied area. The function is useful when one needs to emulate border type that is different from the one embedded into a specific algorithm implementation. For example, morphological functions, as well as most of other filtering functions in OpenCV, internally use replication border type, while the user may need a zero border or a border, filled with 1's or 255's.
-
-
-.. index:: CreateStructuringElementEx
-
-.. _CreateStructuringElementEx:
-
-CreateStructuringElementEx
---------------------------
-
-`id=0.317060827729 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CreateStructuringElementEx>`__
-
-
-.. function:: CreateStructuringElementEx(cols,rows,anchorX,anchorY,shape,values=None)-> kernel
-
- Creates a structuring element.
-
-
-
-
-
-
- :param cols: Number of columns in the structuring element
-
- :type cols: int
-
-
- :param rows: Number of rows in the structuring element
-
- :type rows: int
-
-
- :param anchorX: Relative horizontal offset of the anchor point
-
- :type anchorX: int
-
-
- :param anchorY: Relative vertical offset of the anchor point
-
- :type anchorY: int
-
-
- :param shape: Shape of the structuring element; may have the following values:
-
-
- * **CV_SHAPE_RECT** a rectangular element
-
-
- * **CV_SHAPE_CROSS** a cross-shaped element
-
-
- * **CV_SHAPE_ELLIPSE** an elliptic element
-
-
- * **CV_SHAPE_CUSTOM** a user-defined element. In this case the parameter ``values`` specifies the mask, that is, which neighbors of the pixel must be considered
-
-
-
- :type shape: int
-
-
- :param values: Pointer to the structuring element data, a plane array, representing row-by-row scanning of the element matrix. Non-zero values indicate points that belong to the element. If the pointer is ``NULL`` , then all values are considered non-zero, that is, the element is of a rectangular shape. This parameter is considered only if the shape is ``CV_SHAPE_CUSTOM``
-
- :type values: sequence of int
-
-
-
-The function CreateStructuringElementEx allocates and fills the structure
-``IplConvKernel``
-, which can be used as a structuring element in the morphological operations.
-
-
-.. index:: Dilate
-
-.. _Dilate:
-
-Dilate
-------
-
-`id=0.716788417488 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Dilate>`__
-
-
-.. function:: Dilate(src,dst,element=None,iterations=1)-> None
-
- Dilates an image by using a specific structuring element.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param element: Structuring element used for dilation. If it is ``None`` ,
- a :math:`3\times 3` rectangular structuring element is used
-
- :type element: :class:`IplConvKernel`
-
-
- :param iterations: Number of times dilation is applied
-
- :type iterations: int
-
-
-
-The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:
-
-
-
-.. math::
-
- \max _{(x',y') \, in \, \texttt{element} }src(x+x',y+y')
-
-
-The function supports the in-place mode. Dilation can be applied several (
-``iterations``
-) times. For color images, each channel is processed independently.
-
-
-.. index:: Erode
-
-.. _Erode:
-
-Erode
------
-
-`id=0.842620131268 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Erode>`__
-
-
-.. function:: Erode(src,dst,element=None,iterations=1)-> None
-
- Erodes an image by using a specific structuring element.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param element: Structuring element used for erosion. If it is ``None`` ,
- a :math:`3\times 3` rectangular structuring element is used
-
- :type element: :class:`IplConvKernel`
-
-
- :param iterations: Number of times erosion is applied
-
- :type iterations: int
-
-
-
-The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:
-
-
-
-.. math::
-
- \min _{(x',y') \, in \, \texttt{element} }src(x+x',y+y')
-
-
-The function supports the in-place mode. Erosion can be applied several (
-``iterations``
-) times. For color images, each channel is processed independently.
-
-
-.. index:: Filter2D
-
-.. _Filter2D:
-
-Filter2D
---------
-
-`id=0.460981812748 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Filter2D>`__
-
-
-.. function:: Filter2D(src,dst,kernel,anchor=(-1,-1))-> None
-
- Convolves an image with the kernel.
-
-
-
-
-
-
- :param src: The source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image
-
- :type dst: :class:`CvArr`
-
-
- :param kernel: Convolution kernel, a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using :ref:`Split` and process them individually
-
- :type kernel: :class:`CvMat`
-
-
- :param anchor: The anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor shoud lie within the kernel. The special default value (-1,-1) means that it is at the kernel center
-
- :type anchor: :class:`CvPoint`
-
-
-
-The function applies an arbitrary linear filter to the image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values from the nearest pixels that are inside the image.
-
-
-.. index:: Laplace
-
-.. _Laplace:
-
-Laplace
--------
-
-`id=0.292603296168 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Laplace>`__
-
-
-.. function:: Laplace(src,dst,apertureSize=3)-> None
-
- Calculates the Laplacian of an image.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param apertureSize: Aperture size (it has the same meaning as :ref:`Sobel` )
-
- :type apertureSize: int
-
-
-
-The function calculates the Laplacian of the source image by adding up the second x and y derivatives calculated using the Sobel operator:
-
-
-
-.. math::
-
- \texttt{dst} (x,y) = \frac{d^2 \texttt{src}}{dx^2} + \frac{d^2 \texttt{src}}{dy^2}
-
-
-Setting
-``apertureSize``
-= 1 gives the fastest variant that is equal to convolving the image with the following kernel:
-
-
-
-.. math::
-
- \vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}
-
-
-Similar to the
-:ref:`Sobel`
-function, no scaling is done and the same combinations of input and output formats are supported.
-
-
-.. index:: MorphologyEx
-
-.. _MorphologyEx:
-
-MorphologyEx
-------------
-
-`id=0.989292823459 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MorphologyEx>`__
-
-
-.. function:: MorphologyEx(src,dst,temp,element,operation,iterations=1)-> None
-
- Performs advanced morphological transformations.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param temp: Temporary image, required in some cases
-
- :type temp: :class:`CvArr`
-
-
- :param element: Structuring element
-
- :type element: :class:`IplConvKernel`
-
-
- :param operation: Type of morphological operation, one of the following:
-
- * **CV_MOP_OPEN** opening
-
- * **CV_MOP_CLOSE** closing
-
- * **CV_MOP_GRADIENT** morphological gradient
-
- * **CV_MOP_TOPHAT** "top hat"
-
- * **CV_MOP_BLACKHAT** "black hat"
-
-
-
- :type operation: int
-
-
- :param iterations: Number of times erosion and dilation are applied
-
- :type iterations: int
-
-
-
-The function can perform advanced morphological transformations using erosion and dilation as basic operations.
-
-Opening:
-
-
-
-.. math::
-
- dst=open(src,element)=dilate(erode(src,element),element)
-
-
-Closing:
-
-
-
-.. math::
-
- dst=close(src,element)=erode(dilate(src,element),element)
-
-
-Morphological gradient:
-
-
-
-.. math::
-
- dst=morph \_ grad(src,element)=dilate(src,element)-erode(src,element)
-
-
-"Top hat":
-
-
-
-.. math::
-
- dst=tophat(src,element)=src-open(src,element)
-
-
-"Black hat":
-
-
-
-.. math::
-
- dst=blackhat(src,element)=close(src,element)-src
-
-
-The temporary image
-``temp``
-is required for a morphological gradient and, in the case of in-place operation, for "top hat" and "black hat".
-
-
-.. index:: PyrDown
-
-.. _PyrDown:
-
-PyrDown
--------
-
-`id=0.761058003811 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/PyrDown>`__
-
-
-.. function:: PyrDown(src,dst,filter=CV_GAUSSIAN_5X5)-> None
-
- Downsamples an image.
-
-
-
-
-
-
- :param src: The source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image, should have a half as large width and height than the source
-
- :type dst: :class:`CvArr`
-
-
- :param filter: Type of the filter used for convolution; only ``CV_GAUSSIAN_5x5`` is currently supported
-
- :type filter: int
-
-
-
-The function performs the downsampling step of the Gaussian pyramid decomposition. First it convolves the source image with the specified filter and then downsamples the image by rejecting even rows and columns.
-
-
-.. index:: Smooth
-
-.. _Smooth:
-
-Smooth
-------
-
-`id=0.981627398232 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Smooth>`__
-
-
-.. function:: Smooth(src,dst,smoothtype=CV_GAUSSIAN,param1=3,param2=0,param3=0,param4=0)-> None
-
- Smooths the image in one of several ways.
-
-
-
-
-
-
- :param src: The source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image
-
- :type dst: :class:`CvArr`
-
-
- :param smoothtype: Type of the smoothing:
-
-
- * **CV_BLUR_NO_SCALE** linear convolution with :math:`\texttt{param1}\times\texttt{param2}` box kernel (all 1's). If you want to smooth different pixels with different-size box kernels, you can use the integral image that is computed using :ref:`Integral`
-
-
- * **CV_BLUR** linear convolution with :math:`\texttt{param1}\times\texttt{param2}` box kernel (all 1's) with subsequent scaling by :math:`1/(\texttt{param1}\cdot\texttt{param2})`
-
-
- * **CV_GAUSSIAN** linear convolution with a :math:`\texttt{param1}\times\texttt{param2}` Gaussian kernel
-
-
- * **CV_MEDIAN** median filter with a :math:`\texttt{param1}\times\texttt{param1}` square aperture
-
-
- * **CV_BILATERAL** bilateral filter with a :math:`\texttt{param1}\times\texttt{param1}` square aperture, color sigma= ``param3`` and spatial sigma= ``param4`` . If ``param1=0`` , the aperture square side is set to ``cvRound(param4*1.5)*2+1`` . Information about bilateral filtering can be found at http://www.dai.ed.ac.uk/CVonline/LOCAL\_COPIES/MANDUCHI1/Bilateral\_Filtering.html
-
-
-
- :type smoothtype: int
-
-
- :param param1: The first parameter of the smoothing operation, the aperture width. Must be a positive odd number (1, 3, 5, ...)
-
- :type param1: int
-
-
- :param param2: The second parameter of the smoothing operation, the aperture height. Ignored by ``CV_MEDIAN`` and ``CV_BILATERAL`` methods. In the case of simple scaled/non-scaled and Gaussian blur if ``param2`` is zero, it is set to ``param1`` . Otherwise it must be a positive odd number.
-
- :type param2: int
-
-
- :param param3: In the case of a Gaussian parameter this parameter may specify Gaussian :math:`\sigma` (standard deviation). If it is zero, it is calculated from the kernel size:
-
- .. math::
-
- \sigma = 0.3 (n/2 - 1) + 0.8 \quad \text{where} \quad n= \begin{array}{l l} \mbox{\texttt{param1} for horizontal kernel} \\ \mbox{\texttt{param2} for vertical kernel} \end{array}
-
- Using standard sigma for small kernels ( :math:`3\times 3` to :math:`7\times 7` ) gives better speed. If ``param3`` is not zero, while ``param1`` and ``param2`` are zeros, the kernel size is calculated from the sigma (to provide accurate enough operation).
-
- :type param3: float
-
-
-
-The function smooths an image using one of several methods. Every of the methods has some features and restrictions listed below
-
-Blur with no scaling works with single-channel images only and supports accumulation of 8-bit to 16-bit format (similar to
-:ref:`Sobel`
-and
-:ref:`Laplace`
-) and 32-bit floating point to 32-bit floating-point format.
-
-Simple blur and Gaussian blur support 1- or 3-channel, 8-bit and 32-bit floating point images. These two methods can process images in-place.
-
-Median and bilateral filters work with 1- or 3-channel 8-bit images and can not process images in-place.
-
-
-.. index:: Sobel
-
-.. _Sobel:
-
-Sobel
------
-
-`id=0.141242620837 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Sobel>`__
-
-
-.. function:: Sobel(src,dst,xorder,yorder,apertureSize = 3)-> None
-
- Calculates the first, second, third or mixed image derivatives using an extended Sobel operator.
-
-
-
-
-
-
- :param src: Source image of type CvArr*
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param xorder: Order of the derivative x
-
- :type xorder: int
-
-
- :param yorder: Order of the derivative y
-
- :type yorder: int
-
-
- :param apertureSize: Size of the extended Sobel kernel, must be 1, 3, 5 or 7
-
- :type apertureSize: int
-
-
-
-In all cases except 1, an
-:math:`\texttt{apertureSize} \times
-\texttt{apertureSize}`
-separable kernel will be used to calculate the
-derivative. For
-:math:`\texttt{apertureSize} = 1`
-a
-:math:`3 \times 1`
-or
-:math:`1 \times 3`
-a kernel is used (Gaussian smoothing is not done). There is also the special
-value
-``CV_SCHARR``
-(-1) that corresponds to a
-:math:`3\times3`
-Scharr
-filter that may give more accurate results than a
-:math:`3\times3`
-Sobel. Scharr
-aperture is
-
-
-
-.. math::
-
- \vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}
-
-
-for the x-derivative or transposed for the y-derivative.
-
-The function calculates the image derivative by convolving the image with the appropriate kernel:
-
-
-
-.. math::
-
- \texttt{dst} (x,y) = \frac{d^{xorder+yorder} \texttt{src}}{dx^{xorder} \cdot dy^{yorder}}
-
-
-The Sobel operators combine Gaussian smoothing and differentiation
-so the result is more or less resistant to the noise. Most often,
-the function is called with (
-``xorder``
-= 1,
-``yorder``
-= 0,
-``apertureSize``
-= 3) or (
-``xorder``
-= 0,
-``yorder``
-= 1,
-``apertureSize``
-= 3) to calculate the first x- or y- image
-derivative. The first case corresponds to a kernel of:
-
-
-
-.. math::
-
- \vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}
-
-
-and the second one corresponds to a kernel of:
-
-
-.. math::
-
- \vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}
-
-
-or a kernel of:
-
-
-.. math::
-
- \vecthreethree{1}{2}{1}{0}{0}{0}{-1}{2}{-1}
-
-
-depending on the image origin (
-``origin``
-field of
-``IplImage``
-structure). No scaling is done, so the destination image
-usually has larger numbers (in absolute values) than the source image does. To
-avoid overflow, the function requires a 16-bit destination image if the
-source image is 8-bit. The result can be converted back to 8-bit using the
-:ref:`ConvertScale`
-or the
-:ref:`ConvertScaleAbs`
-function. Besides 8-bit images
-the function can process 32-bit floating-point images. Both the source and the
-destination must be single-channel images of equal size or equal ROI size.
-
+++ /dev/null
-Miscellaneous Image Transformations
-===================================
-
-.. highlight:: python
-
-
-
-.. index:: AdaptiveThreshold
-
-.. _AdaptiveThreshold:
-
-AdaptiveThreshold
------------------
-
-`id=0.347945671563 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/AdaptiveThreshold>`__
-
-
-.. function:: AdaptiveThreshold(src,dst,maxValue, adaptive_method=CV_ADAPTIVE_THRESH_MEAN_C, thresholdType=CV_THRESH_BINARY,blockSize=3,param1=5)-> None
-
- Applies an adaptive threshold to an array.
-
-
-
-
-
-
- :param src: Source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination image
-
- :type dst: :class:`CvArr`
-
-
- :param maxValue: Maximum value that is used with ``CV_THRESH_BINARY`` and ``CV_THRESH_BINARY_INV``
-
- :type maxValue: float
-
-
- :param adaptive_method: Adaptive thresholding algorithm to use: ``CV_ADAPTIVE_THRESH_MEAN_C`` or ``CV_ADAPTIVE_THRESH_GAUSSIAN_C`` (see the discussion)
-
- :type adaptive_method: int
-
-
- :param thresholdType: Thresholding type; must be one of
-
- * **CV_THRESH_BINARY** xxx
-
- * **CV_THRESH_BINARY_INV** xxx
-
-
-
- :type thresholdType: int
-
-
- :param blockSize: The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on
-
- :type blockSize: int
-
-
- :param param1: The method-dependent parameter. For the methods ``CV_ADAPTIVE_THRESH_MEAN_C`` and ``CV_ADAPTIVE_THRESH_GAUSSIAN_C`` it is a constant subtracted from the mean or weighted mean (see the discussion), though it may be negative
-
- :type param1: float
-
-
-
-The function transforms a grayscale image to a binary image according to the formulas:
-
-
-
-
- * **CV_THRESH_BINARY**
-
- .. math::
-
- dst(x,y) = \fork{\texttt{maxValue}}{if $src(x,y) > T(x,y)$}{0}{otherwise}
-
-
-
-
- * **CV_THRESH_BINARY_INV**
-
- .. math::
-
- dst(x,y) = \fork{0}{if $src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}
-
-
-
-
-
-where
-:math:`T(x,y)`
-is a threshold calculated individually for each pixel.
-
-For the method
-``CV_ADAPTIVE_THRESH_MEAN_C``
-it is the mean of a
-:math:`\texttt{blockSize} \times \texttt{blockSize}`
-pixel neighborhood, minus
-``param1``
-.
-
-For the method
-``CV_ADAPTIVE_THRESH_GAUSSIAN_C``
-it is the weighted sum (gaussian) of a
-:math:`\texttt{blockSize} \times \texttt{blockSize}`
-pixel neighborhood, minus
-``param1``
-.
-
-
-.. index:: CvtColor
-
-.. _CvtColor:
-
-CvtColor
---------
-
-`id=0.514105031816 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvtColor>`__
-
-
-.. function:: CvtColor(src,dst,code)-> None
-
- Converts an image from one color space to another.
-
-
-
-
-
-
- :param src: The source 8-bit (8u), 16-bit (16u) or single-precision floating-point (32f) image
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image of the same data type as the source. The number of channels may be different
-
- :type dst: :class:`CvArr`
-
-
- :param code: Color conversion operation that can be specifed using ``CV_ *src_color_space* 2 *dst_color_space*`` constants (see below)
-
- :type code: int
-
-
-
-The function converts the input image from one color
-space to another. The function ignores the
-``colorModel``
-and
-``channelSeq``
-fields of the
-``IplImage``
-header, so the
-source image color space should be specified correctly (including
-order of the channels in the case of RGB space. For example, BGR means 24-bit
-format with
-:math:`B_0, G_0, R_0, B_1, G_1, R_1, ...`
-layout
-whereas RGB means 24-format with
-:math:`R_0, G_0, B_0, R_1, G_1, B_1, ...`
-layout).
-
-The conventional range for R,G,B channel values is:
-
-
-
-
-
-*
- 0 to 255 for 8-bit images
-
-
-*
- 0 to 65535 for 16-bit images and
-
-
-*
- 0 to 1 for floating-point images.
-
-
-Of course, in the case of linear transformations the range can be
-specific, but in order to get correct results in the case of non-linear
-transformations, the input image should be scaled.
-
-The function can do the following transformations:
-
-
-
-
-
-*
- Transformations within RGB space like adding/removing the alpha channel, reversing the channel order, conversion to/from 16-bit RGB color (R5:G6:B5 or R5:G5:B5), as well as conversion to/from grayscale using:
-
-
- .. math::
-
- \text{RGB[A] to Gray:} Y \leftarrow 0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B
-
-
- and
-
-
- .. math::
-
- \text{Gray to RGB[A]:} R \leftarrow Y, G \leftarrow Y, B \leftarrow Y, A \leftarrow 0
-
-
- The conversion from a RGB image to gray is done with:
-
-
-
- ::
-
-
-
- cvCvtColor(src ,bwsrc, CV_RGB2GRAY)
-
-
- ..
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- CIE XYZ.Rec 709 with D65 white point (
- ``CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB``
- ):
-
-
- .. math::
-
- \begin{bmatrix} X \\ Y \\ Z \end{bmatrix} \leftarrow \begin{bmatrix} 0.412453 & 0.357580 & 0.180423 \\ 0.212671 & 0.715160 & 0.072169 \\ 0.019334 & 0.119193 & 0.950227 \end{bmatrix} \cdot \begin{bmatrix} R \\ G \\ B \end{bmatrix}
-
-
-
-
- .. math::
-
- \begin{bmatrix} R \\ G \\ B \end{bmatrix} \leftarrow \begin{bmatrix} 3.240479 & -1.53715 & -0.498535 \\ -0.969256 & 1.875991 & 0.041556 \\ 0.055648 & -0.204043 & 1.057311 \end{bmatrix} \cdot \begin{bmatrix} X \\ Y \\ Z \end{bmatrix}
-
-
- :math:`X`
- ,
- :math:`Y`
- and
- :math:`Z`
- cover the whole value range (in the case of floating-point images
- :math:`Z`
- may exceed 1).
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- YCrCb JPEG (a.k.a. YCC) (
- ``CV_BGR2YCrCb, CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB``
- )
-
-
- .. math::
-
- Y \leftarrow 0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B
-
-
-
-
- .. math::
-
- Cr \leftarrow (R-Y) \cdot 0.713 + delta
-
-
-
-
- .. math::
-
- Cb \leftarrow (B-Y) \cdot 0.564 + delta
-
-
-
-
- .. math::
-
- R \leftarrow Y + 1.403 \cdot (Cr - delta)
-
-
-
-
- .. math::
-
- G \leftarrow Y - 0.344 \cdot (Cr - delta) - 0.714 \cdot (Cb - delta)
-
-
-
-
- .. math::
-
- B \leftarrow Y + 1.773 \cdot (Cb - delta)
-
-
- where
-
-
- .. math::
-
- delta = \left \{ \begin{array}{l l} 128 & \mbox{for 8-bit images} \\ 32768 & \mbox{for 16-bit images} \\ 0.5 & \mbox{for floating-point images} \end{array} \right .
-
-
- Y, Cr and Cb cover the whole value range.
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- HSV (
- ``CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB``
- )
- in the case of 8-bit and 16-bit images
- R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range
-
-
- .. math::
-
- V \leftarrow max(R,G,B)
-
-
-
-
- .. math::
-
- S \leftarrow \fork{\frac{V-min(R,G,B)}{V}}{if $V \neq 0$}{0}{otherwise}
-
-
-
-
- .. math::
-
- H \leftarrow \forkthree{{60(G - B)}/{S}}{if $V=R$}{{120+60(B - R)}/{S}}{if $V=G$}{{240+60(R - G)}/{S}}{if $V=B$}
-
-
- if
- :math:`H<0`
- then
- :math:`H \leftarrow H+360`
- On output
- :math:`0 \leq V \leq 1`
- ,
- :math:`0 \leq S \leq 1`
- ,
- :math:`0 \leq H \leq 360`
- .
-
- The values are then converted to the destination data type:
-
-
-
-
- * 8-bit images
-
-
- .. math::
-
- V \leftarrow 255 V, S \leftarrow 255 S, H \leftarrow H/2 \text{(to fit to 0 to 255)}
-
-
-
-
- * 16-bit images (currently not supported)
-
-
- .. math::
-
- V <- 65535 V, S <- 65535 S, H <- H
-
-
-
-
- * 32-bit images
- H, S, V are left as is
-
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- HLS (
- ``CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR, CV_HLS2RGB``
- ).
- in the case of 8-bit and 16-bit images
- R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range.
-
-
- .. math::
-
- V_{max} \leftarrow {max}(R,G,B)
-
-
-
-
- .. math::
-
- V_{min} \leftarrow {min}(R,G,B)
-
-
-
-
- .. math::
-
- L \leftarrow \frac{V_{max} + V_{min}}{2}
-
-
-
-
- .. math::
-
- S \leftarrow \fork{\frac{V_{max} - V_{min}}{V_{max} + V_{min}}}{if $L < 0.5$}{\frac{V_{max} - V_{min}}{2 - (V_{max} + V_{min})}}{if $L \ge 0.5$}
-
-
-
-
- .. math::
-
- H \leftarrow \forkthree{{60(G - B)}/{S}}{if $V_{max}=R$}{{120+60(B - R)}/{S}}{if $V_{max}=G$}{{240+60(R - G)}/{S}}{if $V_{max}=B$}
-
-
- if
- :math:`H<0`
- then
- :math:`H \leftarrow H+360`
- On output
- :math:`0 \leq L \leq 1`
- ,
- :math:`0 \leq S \leq 1`
- ,
- :math:`0 \leq H \leq 360`
- .
-
- The values are then converted to the destination data type:
-
-
-
-
- * 8-bit images
-
-
- .. math::
-
- V \leftarrow 255 V, S \leftarrow 255 S, H \leftarrow H/2 \text{(to fit to 0 to 255)}
-
-
-
-
- * 16-bit images (currently not supported)
-
-
- .. math::
-
- V <- 65535 V, S <- 65535 S, H <- H
-
-
-
-
- * 32-bit images
- H, S, V are left as is
-
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- CIE L*a*b* (
- ``CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR, CV_Lab2RGB``
- )
- in the case of 8-bit and 16-bit images
- R, G and B are converted to floating-point format and scaled to fit the 0 to 1 range
-
-
- .. math::
-
- \vecthree{X}{Y}{Z} \leftarrow \vecthreethree{0.412453}{0.357580}{0.180423}{0.212671}{0.715160}{0.072169}{0.019334}{0.119193}{0.950227} \cdot \vecthree{R}{G}{B}
-
-
-
-
- .. math::
-
- X \leftarrow X/X_n, \text{where} X_n = 0.950456
-
-
-
-
- .. math::
-
- Z \leftarrow Z/Z_n, \text{where} Z_n = 1.088754
-
-
-
-
- .. math::
-
- L \leftarrow \fork{116*Y^{1/3}-16}{for $Y>0.008856$}{903.3*Y}{for $Y \le 0.008856$}
-
-
-
-
- .. math::
-
- a \leftarrow 500 (f(X)-f(Y)) + delta
-
-
-
-
- .. math::
-
- b \leftarrow 200 (f(Y)-f(Z)) + delta
-
-
- where
-
-
- .. math::
-
- f(t)= \fork{t^{1/3}}{for $t>0.008856$}{7.787 t+16/116}{for $t<=0.008856$}
-
-
- and
-
-
- .. math::
-
- delta = \fork{128}{for 8-bit images}{0}{for floating-point images}
-
-
- On output
- :math:`0 \leq L \leq 100`
- ,
- :math:`-127 \leq a \leq 127`
- ,
- :math:`-127 \leq b \leq 127`
- The values are then converted to the destination data type:
-
-
-
-
- * 8-bit images
-
-
- .. math::
-
- L \leftarrow L*255/100, a \leftarrow a + 128, b \leftarrow b + 128
-
-
-
-
- * 16-bit images
- currently not supported
-
-
- * 32-bit images
- L, a, b are left as is
-
-
-
-
-*
- RGB
- :math:`\leftrightarrow`
- CIE L*u*v* (
- ``CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR, CV_Luv2RGB``
- )
- in the case of 8-bit and 16-bit images
- R, G and B are converted to floating-point format and scaled to fit 0 to 1 range
-
-
- .. math::
-
- \vecthree{X}{Y}{Z} \leftarrow \vecthreethree{0.412453}{0.357580}{0.180423}{0.212671}{0.715160}{0.072169}{0.019334}{0.119193}{0.950227} \cdot \vecthree{R}{G}{B}
-
-
-
-
- .. math::
-
- L \leftarrow \fork{116 Y^{1/3}}{for $Y>0.008856$}{903.3 Y}{for $Y<=0.008856$}
-
-
-
-
- .. math::
-
- u' \leftarrow 4*X/(X + 15*Y + 3 Z)
-
-
-
-
- .. math::
-
- v' \leftarrow 9*Y/(X + 15*Y + 3 Z)
-
-
-
-
- .. math::
-
- u \leftarrow 13*L*(u' - u_n) \quad \text{where} \quad u_n=0.19793943
-
-
-
-
- .. math::
-
- v \leftarrow 13*L*(v' - v_n) \quad \text{where} \quad v_n=0.46831096
-
-
- On output
- :math:`0 \leq L \leq 100`
- ,
- :math:`-134 \leq u \leq 220`
- ,
- :math:`-140 \leq v \leq 122`
- .
-
- The values are then converted to the destination data type:
-
-
-
-
- * 8-bit images
-
-
- .. math::
-
- L \leftarrow 255/100 L, u \leftarrow 255/354 (u + 134), v \leftarrow 255/256 (v + 140)
-
-
-
-
- * 16-bit images
- currently not supported
-
-
- * 32-bit images
- L, u, v are left as is
-
-
- The above formulas for converting RGB to/from various color spaces have been taken from multiple sources on Web, primarily from
- the Ford98
- at the Charles Poynton site.
-
-
-
-*
- Bayer
- :math:`\rightarrow`
- RGB (
- ``CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB, CV_BayerRG2RGB, CV_BayerGR2RGB``
- ) The Bayer pattern is widely used in CCD and CMOS cameras. It allows one to get color pictures from a single plane where R,G and B pixels (sensors of a particular component) are interleaved like this:
-
-
-
-
-
- .. math::
-
- \newcommand{\Rcell}{\color{red}R} \newcommand{\Gcell}{\color{green}G} \newcommand{\Bcell}{\color{blue}B} \definecolor{BackGray}{rgb}{0.8,0.8,0.8} \begin{array}{ c c c c c } \Rcell & \Gcell & \Rcell & \Gcell & \Rcell \\ \Gcell & \colorbox{BackGray}{\Bcell} & \colorbox{BackGray}{\Gcell} & \Bcell & \Gcell \\ \Rcell & \Gcell & \Rcell & \Gcell & \Rcell \\ \Gcell & \Bcell & \Gcell & \Bcell & \Gcell \\ \Rcell & \Gcell & \Rcell & \Gcell & \Rcell \end{array}
-
-
- The output RGB components of a pixel are interpolated from 1, 2 or
- 4 neighbors of the pixel having the same color. There are several
- modifications of the above pattern that can be achieved by shifting
- the pattern one pixel left and/or one pixel up. The two letters
- :math:`C_1`
- and
- :math:`C_2`
- in the conversion constants
- ``CV_Bayer``
- :math:`C_1 C_2`
- ``2BGR``
- and
- ``CV_Bayer``
- :math:`C_1 C_2`
- ``2RGB``
- indicate the particular pattern
- type - these are components from the second row, second and third
- columns, respectively. For example, the above pattern has very
- popular "BG" type.
-
-
-
-.. index:: DistTransform
-
-.. _DistTransform:
-
-DistTransform
--------------
-
-`id=0.403544454308 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/DistTransform>`__
-
-
-.. function:: DistTransform(src,dst,distance_type=CV_DIST_L2,mask_size=3,mask=None,labels=NULL)-> None
-
- Calculates the distance to the closest zero pixel for all non-zero pixels of the source image.
-
-
-
-
-
-
- :param src: 8-bit, single-channel (binary) source image
-
- :type src: :class:`CvArr`
-
-
- :param dst: Output image with calculated distances (32-bit floating-point, single-channel)
-
- :type dst: :class:`CvArr`
-
-
- :param distance_type: Type of distance; can be ``CV_DIST_L1, CV_DIST_L2, CV_DIST_C`` or ``CV_DIST_USER``
-
- :type distance_type: int
-
-
- :param mask_size: Size of the distance transform mask; can be 3 or 5. in the case of ``CV_DIST_L1`` or ``CV_DIST_C`` the parameter is forced to 3, because a :math:`3\times 3` mask gives the same result as a :math:`5\times 5` yet it is faster
-
- :type mask_size: int
-
-
- :param mask: User-defined mask in the case of a user-defined distance, it consists of 2 numbers (horizontal/vertical shift cost, diagonal shift cost) in the case ofa :math:`3\times 3` mask and 3 numbers (horizontal/vertical shift cost, diagonal shift cost, knight's move cost) in the case of a :math:`5\times 5` mask
-
- :type mask: sequence of float
-
-
- :param labels: The optional output 2d array of integer type labels, the same size as ``src`` and ``dst``
-
- :type labels: :class:`CvArr`
-
-
-
-The function calculates the approximated
-distance from every binary image pixel to the nearest zero pixel.
-For zero pixels the function sets the zero distance, for others it
-finds the shortest path consisting of basic shifts: horizontal,
-vertical, diagonal or knight's move (the latest is available for a
-:math:`5\times 5`
-mask). The overall distance is calculated as a sum of these
-basic distances. Because the distance function should be symmetric,
-all of the horizontal and vertical shifts must have the same cost (that
-is denoted as
-``a``
-), all the diagonal shifts must have the
-same cost (denoted
-``b``
-), and all knight's moves must have
-the same cost (denoted
-``c``
-). For
-``CV_DIST_C``
-and
-``CV_DIST_L1``
-types the distance is calculated precisely,
-whereas for
-``CV_DIST_L2``
-(Euclidian distance) the distance
-can be calculated only with some relative error (a
-:math:`5\times 5`
-mask
-gives more accurate results), OpenCV uses the values suggested in
-Borgefors86
-:
-
-
-
-.. table::
-
- ============== =================== ======================
- ``CV_DIST_C`` :math:`(3\times 3)` a = 1, b = 1 \
- ============== =================== ======================
- ``CV_DIST_L1`` :math:`(3\times 3)` a = 1, b = 2 \
- ``CV_DIST_L2`` :math:`(3\times 3)` a=0.955, b=1.3693 \
- ``CV_DIST_L2`` :math:`(5\times 5)` a=1, b=1.4, c=2.1969 \
- ============== =================== ======================
-
-And below are samples of the distance field (black (0) pixel is in the middle of white square) in the case of a user-defined distance:
-
-User-defined
-:math:`3 \times 3`
-mask (a=1, b=1.5)
-
-
-.. table::
-
- === === === = === === =====
- 4.5 4 3.5 3 3.5 4 4.5 \
- === === === = === === =====
- 4 3 2.5 2 2.5 3 4 \
- 3.5 2.5 1.5 1 1.5 2.5 3.5 \
- 3 2 1 1 2 3 \
- 3.5 2.5 1.5 1 1.5 2.5 3.5 \
- 4 3 2.5 2 2.5 3 4 \
- 4.5 4 3.5 3 3.5 4 4.5 \
- === === === = === === =====
-
-User-defined
-:math:`5 \times 5`
-mask (a=1, b=1.5, c=2)
-
-
-.. table::
-
- === === === = === === =====
- 4.5 3.5 3 3 3 3.5 4.5 \
- === === === = === === =====
- 3.5 3 2 2 2 3 3.5 \
- 3 2 1.5 1 1.5 2 3 \
- 3 2 1 1 2 3 \
- 3 2 1.5 1 1.5 2 3 \
- 3.5 3 2 2 2 3 3.5 \
- 4 3.5 3 3 3 3.5 4 \
- === === === = === === =====
-
-Typically, for a fast, coarse distance estimation
-``CV_DIST_L2``
-,
-a
-:math:`3\times 3`
-mask is used, and for a more accurate distance estimation
-``CV_DIST_L2``
-, a
-:math:`5\times 5`
-mask is used.
-
-When the output parameter
-``labels``
-is not
-``NULL``
-, for
-every non-zero pixel the function also finds the nearest connected
-component consisting of zero pixels. The connected components
-themselves are found as contours in the beginning of the function.
-
-In this mode the processing time is still O(N), where N is the number of
-pixels. Thus, the function provides a very fast way to compute approximate
-Voronoi diagram for the binary image.
-
-
-.. index:: CvConnectedComp
-
-.. _CvConnectedComp:
-
-CvConnectedComp
----------------
-
-`id=0.582359535464 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvConnectedComp>`__
-
-.. class:: CvConnectedComp
-
-
-
-Connected component, represented as a tuple (area, value, rect), where
-area is the area of the component as a float, value is the average color
-as a
-:ref:`CvScalar`
-, and rect is the ROI of the component, as a
-:ref:`CvRect`
-.
-
-.. index:: FloodFill
-
-.. _FloodFill:
-
-FloodFill
----------
-
-`id=0.993822136735 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FloodFill>`__
-
-
-.. function:: FloodFill(image,seed_point,new_val,lo_diff=(0,0,0,0),up_diff=(0,0,0,0),flags=4,mask=NULL)-> comp
-
- Fills a connected component with the given color.
-
-
-
-
-
-
- :param image: Input 1- or 3-channel, 8-bit or floating-point image. It is modified by the function unless the ``CV_FLOODFILL_MASK_ONLY`` flag is set (see below)
-
- :type image: :class:`CvArr`
-
-
- :param seed_point: The starting point
-
- :type seed_point: :class:`CvPoint`
-
-
- :param new_val: New value of the repainted domain pixels
-
- :type new_val: :class:`CvScalar`
-
-
- :param lo_diff: Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. In the case of 8-bit color images it is a packed value
-
- :type lo_diff: :class:`CvScalar`
-
-
- :param up_diff: Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. In the case of 8-bit color images it is a packed value
-
- :type up_diff: :class:`CvScalar`
-
-
- :param comp: Returned connected component for the repainted domain. Note that the function does not fill ``comp->contour`` field. The boundary of the filled component can be retrieved from the output mask image using :ref:`FindContours`
-
- :type comp: :class:`CvConnectedComp`
-
-
- :param flags: The operation flags. Lower bits contain connectivity value, 4 (by default) or 8, used within the function. Connectivity determines which neighbors of a pixel are considered. Upper bits can be 0 or a combination of the following flags:
-
-
- * **CV_FLOODFILL_FIXED_RANGE** if set, the difference between the current pixel and seed pixel is considered, otherwise the difference between neighbor pixels is considered (the range is floating)
-
-
- * **CV_FLOODFILL_MASK_ONLY** if set, the function does not fill the image ( ``new_val`` is ignored), but fills the mask (that must be non-NULL in this case)
-
-
-
- :type flags: int
-
-
- :param mask: Operation mask, should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than ``image`` . If not NULL, the function uses and updates the mask, so the user takes responsibility of initializing the ``mask`` content. Floodfilling can't go across non-zero pixels in the mask, for example, an edge detector output can be used as a mask to stop filling at edges. It is possible to use the same mask in multiple calls to the function to make sure the filled area do not overlap. **Note** : because the mask is larger than the filled image, a pixel in ``mask`` that corresponds to :math:`(x,y)` pixel in ``image`` will have coordinates :math:`(x+1,y+1)`
-
- :type mask: :class:`CvArr`
-
-
-
-The function fills a connected component starting from the seed point with the specified color. The connectivity is determined by the closeness of pixel values. The pixel at
-:math:`(x,y)`
-is considered to belong to the repainted domain if:
-
-
-
-
-
-* grayscale image, floating range
-
-
- .. math::
-
- src(x',y')- \texttt{lo\_diff} <= src(x,y) <= src(x',y')+ \texttt{up\_diff}
-
-
-
-
-* grayscale image, fixed range
-
-
- .. math::
-
- src(seed.x,seed.y)- \texttt{lo\_diff} <=src(x,y)<=src(seed.x,seed.y)+ \texttt{up\_diff}
-
-
-
-
-* color image, floating range
-
-
- .. math::
-
- src(x',y')_r- \texttt{lo\_diff} _r<=src(x,y)_r<=src(x',y')_r+ \texttt{up\_diff} _r
-
-
-
-
- .. math::
-
- src(x',y')_g- \texttt{lo\_diff} _g<=src(x,y)_g<=src(x',y')_g+ \texttt{up\_diff} _g
-
-
-
-
- .. math::
-
- src(x',y')_b- \texttt{lo\_diff} _b<=src(x,y)_b<=src(x',y')_b+ \texttt{up\_diff} _b
-
-
-
-
-* color image, fixed range
-
-
- .. math::
-
- src(seed.x,seed.y)_r- \texttt{lo\_diff} _r<=src(x,y)_r<=src(seed.x,seed.y)_r+ \texttt{up\_diff} _r
-
-
-
-
- .. math::
-
- src(seed.x,seed.y)_g- \texttt{lo\_diff} _g<=src(x,y)_g<=src(seed.x,seed.y)_g+ \texttt{up\_diff} _g
-
-
-
-
- .. math::
-
- src(seed.x,seed.y)_b- \texttt{lo\_diff} _b<=src(x,y)_b<=src(seed.x,seed.y)_b+ \texttt{up\_diff} _b
-
-
-
-
-where
-:math:`src(x',y')`
-is the value of one of pixel neighbors. That is, to be added to the connected component, a pixel's color/brightness should be close enough to the:
-
-
-
-
-*
- color/brightness of one of its neighbors that are already referred to the connected component in the case of floating range
-
-
-
-*
- color/brightness of the seed point in the case of fixed range.
-
-
-
-.. index:: Inpaint
-
-.. _Inpaint:
-
-Inpaint
--------
-
-`id=0.0263619127935 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Inpaint>`__
-
-
-.. function:: Inpaint(src,mask,dst,inpaintRadius,flags) -> None
-
- Inpaints the selected region in the image.
-
-
-
-
-
-
- :param src: The input 8-bit 1-channel or 3-channel image.
-
- :type src: :class:`CvArr`
-
-
- :param mask: The inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted.
-
- :type mask: :class:`CvArr`
-
-
- :param dst: The output image of the same format and the same size as input.
-
- :type dst: :class:`CvArr`
-
-
- :param inpaintRadius: The radius of circlular neighborhood of each point inpainted that is considered by the algorithm.
-
- :type inpaintRadius: float
-
-
- :param flags: The inpainting method, one of the following:
-
- * **CV_INPAINT_NS** Navier-Stokes based method.
-
- * **CV_INPAINT_TELEA** The method by Alexandru Telea Telea04
-
-
-
- :type flags: int
-
-
-
-The function reconstructs the selected image area from the pixel near the area boundary. The function may be used to remove dust and scratches from a scanned photo, or to remove undesirable objects from still images or video.
-
-
-.. index:: Integral
-
-.. _Integral:
-
-Integral
---------
-
-`id=0.623787344698 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Integral>`__
-
-
-.. function:: Integral(image,sum,sqsum=NULL,tiltedSum=NULL)-> None
-
- Calculates the integral of an image.
-
-
-
-
-
-
- :param image: The source image, :math:`W\times H` , 8-bit or floating-point (32f or 64f)
-
- :type image: :class:`CvArr`
-
-
- :param sum: The integral image, :math:`(W+1)\times (H+1)` , 32-bit integer or double precision floating-point (64f)
-
- :type sum: :class:`CvArr`
-
-
- :param sqsum: The integral image for squared pixel values, :math:`(W+1)\times (H+1)` , double precision floating-point (64f)
-
- :type sqsum: :class:`CvArr`
-
-
- :param tiltedSum: The integral for the image rotated by 45 degrees, :math:`(W+1)\times (H+1)` , the same data type as ``sum``
-
- :type tiltedSum: :class:`CvArr`
-
-
-
-The function calculates one or more integral images for the source image as following:
-
-
-
-.. math::
-
- \texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)
-
-
-
-
-.. math::
-
- \texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2
-
-
-
-
-.. math::
-
- \texttt{tiltedSum} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)
-
-
-Using these integral images, one may calculate sum, mean and standard deviation over a specific up-right or rotated rectangular region of the image in a constant time, for example:
-
-
-
-.. math::
-
- \sum _{x_1<=x<x_2, \, y_1<=y<y_2} = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,x_1)
-
-
-It makes possible to do a fast blurring or fast block correlation with variable window size, for example. In the case of multi-channel images, sums for each channel are accumulated independently.
-
-
-
-.. index:: PyrMeanShiftFiltering
-
-.. _PyrMeanShiftFiltering:
-
-PyrMeanShiftFiltering
----------------------
-
-`id=0.193607300873 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/PyrMeanShiftFiltering>`__
-
-
-.. function:: PyrMeanShiftFiltering(src,dst,sp,sr,max_level=1,termcrit=(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1))-> None
-
- Does meanshift image segmentation
-
-
-
-
-
-
- :param src: The source 8-bit, 3-channel image.
-
- :type src: :class:`CvArr`
-
-
- :param dst: The destination image of the same format and the same size as the source.
-
- :type dst: :class:`CvArr`
-
-
- :param sp: The spatial window radius.
-
- :type sp: float
-
-
- :param sr: The color window radius.
-
- :type sr: float
-
-
- :param max_level: Maximum level of the pyramid for the segmentation.
-
- :type max_level: int
-
-
- :param termcrit: Termination criteria: when to stop meanshift iterations.
-
- :type termcrit: :class:`CvTermCriteria`
-
-
-
-The function implements the filtering
-stage of meanshift segmentation, that is, the output of the function is
-the filtered "posterized" image with color gradients and fine-grain
-texture flattened. At every pixel
-:math:`(X,Y)`
-of the input image (or
-down-sized input image, see below) the function executes meanshift
-iterations, that is, the pixel
-:math:`(X,Y)`
-neighborhood in the joint
-space-color hyperspace is considered:
-
-
-
-.. math::
-
- (x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}
-
-
-where
-``(R,G,B)``
-and
-``(r,g,b)``
-are the vectors of color components at
-``(X,Y)``
-and
-``(x,y)``
-, respectively (though, the algorithm does not depend on the color space used, so any 3-component color space can be used instead). Over the neighborhood the average spatial value
-``(X',Y')``
-and average color vector
-``(R',G',B')``
-are found and they act as the neighborhood center on the next iteration:
-
-:math:`(X,Y)~(X',Y'), (R,G,B)~(R',G',B').`
-After the iterations over, the color components of the initial pixel (that is, the pixel from where the iterations started) are set to the final value (average color at the last iteration):
-
-:math:`I(X,Y) <- (R*,G*,B*)`
-Then
-:math:`\texttt{max\_level}>0`
-, the gaussian pyramid of
-:math:`\texttt{max\_level}+1`
-levels is built, and the above procedure is run
-on the smallest layer. After that, the results are propagated to the
-larger layer and the iterations are run again only on those pixels where
-the layer colors differ much (
-:math:`>\texttt{sr}`
-) from the lower-resolution
-layer, that is, the boundaries of the color regions are clarified. Note,
-that the results will be actually different from the ones obtained by
-running the meanshift procedure on the whole original image (i.e. when
-:math:`\texttt{max\_level}==0`
-).
-
-
-.. index:: PyrSegmentation
-
-.. _PyrSegmentation:
-
-PyrSegmentation
----------------
-
-`id=0.0663769417357 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/PyrSegmentation>`__
-
-
-.. function:: PyrSegmentation(src,dst,storage,level,threshold1,threshold2)-> comp
-
- Implements image segmentation by pyramids.
-
-
-
-
-
-
- :param src: The source image
-
- :type src: :class:`IplImage`
-
-
- :param dst: The destination image
-
- :type dst: :class:`IplImage`
-
-
- :param storage: Storage; stores the resulting sequence of connected components
-
- :type storage: :class:`CvMemStorage`
-
-
- :param comp: Pointer to the output sequence of the segmented components
-
- :type comp: :class:`CvSeq`
-
-
- :param level: Maximum level of the pyramid for the segmentation
-
- :type level: int
-
-
- :param threshold1: Error threshold for establishing the links
-
- :type threshold1: float
-
-
- :param threshold2: Error threshold for the segments clustering
-
- :type threshold2: float
-
-
-
-The function implements image segmentation by pyramids. The pyramid builds up to the level
-``level``
-. The links between any pixel
-``a``
-on level
-``i``
-and its candidate father pixel
-``b``
-on the adjacent level are established if
-:math:`p(c(a),c(b))<threshold1`
-.
-After the connected components are defined, they are joined into several clusters.
-Any two segments A and B belong to the same cluster, if
-:math:`p(c(A),c(B))<threshold2`
-.
-If the input image has only one channel, then
-:math:`p(c^1,c^2)=|c^1-c^2|`
-.
-If the input image has three channels (red, green and blue), then
-
-
-.. math::
-
- p(c^1,c^2) = 0.30 (c^1_r - c^2_r) +
- 0.59 (c^1_g - c^2_g) +
- 0.11 (c^1_b - c^2_b).
-
-
-There may be more than one connected component per a cluster. The images
-``src``
-and
-``dst``
-should be 8-bit single-channel or 3-channel images or equal size.
-
-
-.. index:: Threshold
-
-.. _Threshold:
-
-Threshold
----------
-
-`id=0.201828299143 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Threshold>`__
-
-
-.. function:: Threshold(src,dst,threshold,maxValue,thresholdType)-> None
-
- Applies a fixed-level threshold to array elements.
-
-
-
-
-
-
- :param src: Source array (single-channel, 8-bit or 32-bit floating point)
-
- :type src: :class:`CvArr`
-
-
- :param dst: Destination array; must be either the same type as ``src`` or 8-bit
-
- :type dst: :class:`CvArr`
-
-
- :param threshold: Threshold value
-
- :type threshold: float
-
-
- :param maxValue: Maximum value to use with ``CV_THRESH_BINARY`` and ``CV_THRESH_BINARY_INV`` thresholding types
-
- :type maxValue: float
-
-
- :param thresholdType: Thresholding type (see the discussion)
-
- :type thresholdType: int
-
-
-
-The function applies fixed-level thresholding
-to a single-channel array. The function is typically used to get a
-bi-level (binary) image out of a grayscale image (
-:ref:`CmpS`
-could
-be also used for this purpose) or for removing a noise, i.e. filtering
-out pixels with too small or too large values. There are several
-types of thresholding that the function supports that are determined by
-``thresholdType``
-:
-
-
-
-
- * **CV_THRESH_BINARY**
-
- .. math::
-
- \texttt{dst} (x,y) = \fork{\texttt{maxValue}}{if $\texttt{src}(x,y) > \texttt{threshold}$}{0}{otherwise}
-
-
-
-
- * **CV_THRESH_BINARY_INV**
-
- .. math::
-
- \texttt{dst} (x,y) = \fork{0}{if $\texttt{src}(x,y) > \texttt{threshold}$}{\texttt{maxValue}}{otherwise}
-
-
-
-
- * **CV_THRESH_TRUNC**
-
- .. math::
-
- \texttt{dst} (x,y) = \fork{\texttt{threshold}}{if $\texttt{src}(x,y) > \texttt{threshold}$}{\texttt{src}(x,y)}{otherwise}
-
-
-
-
- * **CV_THRESH_TOZERO**
-
- .. math::
-
- \texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{if $\texttt{src}(x,y) > \texttt{threshold}$}{0}{otherwise}
-
-
-
-
- * **CV_THRESH_TOZERO_INV**
-
- .. math::
-
- \texttt{dst} (x,y) = \fork{0}{if $\texttt{src}(x,y) > \texttt{threshold}$}{\texttt{src}(x,y)}{otherwise}
-
-
-
-
-
-Also, the special value
-``CV_THRESH_OTSU``
-may be combined with
-one of the above values. In this case the function determines the optimal threshold
-value using Otsu's algorithm and uses it instead of the specified
-``thresh``
-.
-The function returns the computed threshold value.
-Currently, Otsu's method is implemented only for 8-bit images.
-
-
-
-.. image:: ../pics/threshold.png
-
-
-
+++ /dev/null
-Motion Analysis and Object Tracking
-===================================
-
-.. highlight:: python
-
-
-
-.. index:: Acc
-
-.. _Acc:
-
-Acc
----
-
-`id=0.629029815041 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Acc>`__
-
-
-.. function:: Acc(image,sum,mask=NULL)-> None
-
- Adds a frame to an accumulator.
-
-
-
-
-
-
- :param image: Input image, 1- or 3-channel, 8-bit or 32-bit floating point. (each channel of multi-channel image is processed independently)
-
- :type image: :class:`CvArr`
-
-
- :param sum: Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point
-
- :type sum: :class:`CvArr`
-
-
- :param mask: Optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function adds the whole image
-``image``
-or its selected region to the accumulator
-``sum``
-:
-
-
-
-.. math::
-
- \texttt{sum} (x,y) \leftarrow \texttt{sum} (x,y) + \texttt{image} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0
-
-
-
-.. index:: MultiplyAcc
-
-.. _MultiplyAcc:
-
-MultiplyAcc
------------
-
-`id=0.767428702085 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MultiplyAcc>`__
-
-
-.. function:: MultiplyAcc(image1,image2,acc,mask=NULL)-> None
-
- Adds the product of two input images to the accumulator.
-
-
-
-
-
-
- :param image1: First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)
-
- :type image1: :class:`CvArr`
-
-
- :param image2: Second input image, the same format as the first one
-
- :type image2: :class:`CvArr`
-
-
- :param acc: Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point
-
- :type acc: :class:`CvArr`
-
-
- :param mask: Optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function adds the product of 2 images or their selected regions to the accumulator
-``acc``
-:
-
-
-
-.. math::
-
- \texttt{acc} (x,y) \leftarrow \texttt{acc} (x,y) + \texttt{image1} (x,y) \cdot \texttt{image2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0
-
-
-
-.. index:: RunningAvg
-
-.. _RunningAvg:
-
-RunningAvg
-----------
-
-`id=0.136357383909 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/RunningAvg>`__
-
-
-.. function:: RunningAvg(image,acc,alpha,mask=NULL)-> None
-
- Updates the running average.
-
-
-
-
-
-
- :param image: Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)
-
- :type image: :class:`CvArr`
-
-
- :param acc: Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point
-
- :type acc: :class:`CvArr`
-
-
- :param alpha: Weight of input image
-
- :type alpha: float
-
-
- :param mask: Optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function calculates the weighted sum of the input image
-``image``
-and the accumulator
-``acc``
-so that
-``acc``
-becomes a running average of frame sequence:
-
-
-
-.. math::
-
- \texttt{acc} (x,y) \leftarrow (1- \alpha ) \cdot \texttt{acc} (x,y) + \alpha \cdot \texttt{image} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0
-
-
-where
-:math:`\alpha`
-regulates the update speed (how fast the accumulator forgets about previous frames).
-
-
-.. index:: SquareAcc
-
-.. _SquareAcc:
-
-SquareAcc
----------
-
-`id=0.606012635939 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/SquareAcc>`__
-
-
-.. function:: SquareAcc(image,sqsum,mask=NULL)-> None
-
- Adds the square of the source image to the accumulator.
-
-
-
-
-
-
- :param image: Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)
-
- :type image: :class:`CvArr`
-
-
- :param sqsum: Accumulator with the same number of channels as input image, 32-bit or 64-bit floating-point
-
- :type sqsum: :class:`CvArr`
-
-
- :param mask: Optional operation mask
-
- :type mask: :class:`CvArr`
-
-
-
-The function adds the input image
-``image``
-or its selected region, raised to power 2, to the accumulator
-``sqsum``
-:
-
-
-
-.. math::
-
- \texttt{sqsum} (x,y) \leftarrow \texttt{sqsum} (x,y) + \texttt{image} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0
-
-
+++ /dev/null
-Object Detection
-================
-
-.. highlight:: python
-
-
-
-.. index:: MatchTemplate
-
-.. _MatchTemplate:
-
-MatchTemplate
--------------
-
-`id=0.180820664163 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MatchTemplate>`__
-
-
-.. function:: MatchTemplate(image,templ,result,method)-> None
-
- Compares a template against overlapped image regions.
-
-
-
-
-
-
- :param image: Image where the search is running; should be 8-bit or 32-bit floating-point
-
- :type image: :class:`CvArr`
-
-
- :param templ: Searched template; must be not greater than the source image and the same data type as the image
-
- :type templ: :class:`CvArr`
-
-
- :param result: A map of comparison results; single-channel 32-bit floating-point.
- If ``image`` is :math:`W \times H` and ``templ`` is :math:`w \times h` then ``result`` must be :math:`(W-w+1) \times (H-h+1)`
-
- :type result: :class:`CvArr`
-
-
- :param method: Specifies the way the template must be compared with the image regions (see below)
-
- :type method: int
-
-
-
-The function is similar to
-:ref:`CalcBackProjectPatch`
-. It slides through
-``image``
-, compares the
-overlapped patches of size
-:math:`w \times h`
-against
-``templ``
-using the specified method and stores the comparison results to
-``result``
-. Here are the formulas for the different comparison
-methods one may use (
-:math:`I`
-denotes
-``image``
-,
-:math:`T`
-``template``
-,
-:math:`R`
-``result``
-). The summation is done over template and/or the
-image patch:
-:math:`x' = 0...w-1, y' = 0...h-1`
-
-
-
-
-* method=CV\_TM\_SQDIFF
-
-
- .. math::
-
- R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2
-
-
-
-
-* method=CV\_TM\_SQDIFF\_NORMED
-
-
- .. math::
-
- R(x,y)= \frac{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-
-
-
-
-* method=CV\_TM\_CCORR
-
-
- .. math::
-
- R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y'))
-
-
-
-
-* method=CV\_TM\_CCORR\_NORMED
-
-
- .. math::
-
- R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
-
-
-
-
-* method=CV\_TM\_CCOEFF
-
-
- .. math::
-
- R(x,y)= \sum _{x',y'} (T'(x',y') \cdot I(x+x',y+y'))
-
-
- where
-
-
- .. math::
-
- \begin{array}{l} T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum _{x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array}
-
-
-
-
-* method=CV\_TM\_CCOEFF\_NORMED
-
-
- .. math::
-
- R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }
-
-
-
-
-After the function finishes the comparison, the best matches can be found as global minimums (
-``CV_TM_SQDIFF``
-) or maximums (
-``CV_TM_CCORR``
-and
-``CV_TM_CCOEFF``
-) using the
-:ref:`MinMaxLoc`
-function. In the case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels (and separate mean values are used for each channel).
-
+++ /dev/null
-Planar Subdivisions
-===================
-
-.. highlight:: python
-
-
-
-.. index:: CvSubdiv2D
-
-.. _CvSubdiv2D:
-
-CvSubdiv2D
-----------
-
-`id=0.403332162742 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvSubdiv2D>`__
-
-.. class:: CvSubdiv2D
-
-
-
-Planar subdivision.
-
-
-
-
-
- .. attribute:: edges
-
-
-
- A :ref:`CvSet` of :ref:`CvSubdiv2DEdge`
-
-
-
-Planar subdivision is the subdivision of a plane into a set of
-non-overlapped regions (facets) that cover the whole plane. The above
-structure describes a subdivision built on a 2d point set, where the points
-are linked together and form a planar graph, which, together with a few
-edges connecting the exterior subdivision points (namely, convex hull points)
-with infinity, subdivides a plane into facets by its edges.
-
-For every subdivision there exists a dual subdivision in which facets and
-points (subdivision vertices) swap their roles, that is, a facet is
-treated as a vertex (called a virtual point below) of the dual subdivision and
-the original subdivision vertices become facets. On the picture below
-original subdivision is marked with solid lines and dual subdivision
-with dotted lines.
-
-
-
-.. image:: ../pics/subdiv.png
-
-
-
-OpenCV subdivides a plane into triangles using Delaunay's
-algorithm. Subdivision is built iteratively starting from a dummy
-triangle that includes all the subdivision points for sure. In this
-case the dual subdivision is a Voronoi diagram of the input 2d point set. The
-subdivisions can be used for the 3d piece-wise transformation of a plane,
-morphing, fast location of points on the plane, building special graphs
-(such as NNG,RNG) and so forth.
-
-
-.. index:: CvSubdiv2DPoint
-
-.. _CvSubdiv2DPoint:
-
-CvSubdiv2DPoint
----------------
-
-`id=0.753986010152 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvSubdiv2DPoint>`__
-
-.. class:: CvSubdiv2DPoint
-
-
-
-Point of original or dual subdivision.
-
-
-
-
-
- .. attribute:: first
-
-
-
- A connected :ref:`CvSubdiv2DEdge`
-
-
-
- .. attribute:: pt
-
-
-
- Position, as a :ref:`CvPoint2D32f`
-
-
-
-
-.. index:: CalcSubdivVoronoi2D
-
-.. _CalcSubdivVoronoi2D:
-
-CalcSubdivVoronoi2D
--------------------
-
-`id=0.119097157929 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcSubdivVoronoi2D>`__
-
-
-.. function:: CalcSubdivVoronoi2D(subdiv)-> None
-
- Calculates the coordinates of Voronoi diagram cells.
-
-
-
-
-
-
- :param subdiv: Delaunay subdivision, in which all the points are already added
-
- :type subdiv: :class:`CvSubdiv2D`
-
-
-
-The function calculates the coordinates
-of virtual points. All virtual points corresponding to some vertex of the
-original subdivision form (when connected together) a boundary of the Voronoi
-cell at that point.
-
-
-.. index:: ClearSubdivVoronoi2D
-
-.. _ClearSubdivVoronoi2D:
-
-ClearSubdivVoronoi2D
---------------------
-
-`id=0.158437620754 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ClearSubdivVoronoi2D>`__
-
-
-.. function:: ClearSubdivVoronoi2D(subdiv)-> None
-
- Removes all virtual points.
-
-
-
-
-
-
- :param subdiv: Delaunay subdivision
-
- :type subdiv: :class:`CvSubdiv2D`
-
-
-
-The function removes all of the virtual points. It
-is called internally in
-:ref:`CalcSubdivVoronoi2D`
-if the subdivision
-was modified after previous call to the function.
-
-
-
-.. index:: CreateSubdivDelaunay2D
-
-.. _CreateSubdivDelaunay2D:
-
-CreateSubdivDelaunay2D
-----------------------
-
-`id=0.918020754539 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CreateSubdivDelaunay2D>`__
-
-
-.. function:: CreateSubdivDelaunay2D(rect,storage)-> delaunay_triangulation
-
- Creates an empty Delaunay triangulation.
-
-
-
-
-
-
- :param rect: Rectangle that includes all of the 2d points that are to be added to the subdivision
-
- :type rect: :class:`CvRect`
-
-
- :param storage: Container for subdivision
-
- :type storage: :class:`CvMemStorage`
-
-
-
-The function creates an empty Delaunay
-subdivision, where 2d points can be added using the function
-:ref:`SubdivDelaunay2DInsert`
-. All of the points to be added must be within
-the specified rectangle, otherwise a runtime error will be raised.
-
-Note that the triangulation is a single large triangle that covers the given rectangle. Hence the three vertices of this triangle are outside the rectangle
-``rect``
-.
-
-
-.. index:: FindNearestPoint2D
-
-.. _FindNearestPoint2D:
-
-FindNearestPoint2D
-------------------
-
-`id=0.679601866055 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FindNearestPoint2D>`__
-
-
-.. function:: FindNearestPoint2D(subdiv,pt)-> point
-
- Finds the closest subdivision vertex to the given point.
-
-
-
-
-
-
- :param subdiv: Delaunay or another subdivision
-
- :type subdiv: :class:`CvSubdiv2D`
-
-
- :param pt: Input point
-
- :type pt: :class:`CvPoint2D32f`
-
-
-
-The function is another function that
-locates the input point within the subdivision. It finds the subdivision vertex that
-is the closest to the input point. It is not necessarily one of vertices
-of the facet containing the input point, though the facet (located using
-:ref:`Subdiv2DLocate`
-) is used as a starting
-point. The function returns a pointer to the found subdivision vertex.
-
-
-.. index:: Subdiv2DEdgeDst
-
-.. _Subdiv2DEdgeDst:
-
-Subdiv2DEdgeDst
----------------
-
-`id=0.723258652692 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Subdiv2DEdgeDst>`__
-
-
-.. function:: Subdiv2DEdgeDst(edge)-> point
-
- Returns the edge destination.
-
-
-
-
-
-
- :param edge: Subdivision edge (not a quad-edge)
-
- :type edge: :class:`CvSubdiv2DEdge`
-
-
-
-The function returns the edge destination. The
-returned pointer may be NULL if the edge is from dual subdivision and
-the virtual point coordinates are not calculated yet. The virtual points
-can be calculated using the function
-:ref:`CalcSubdivVoronoi2D`
-.
-
-
-.. index:: Subdiv2DGetEdge
-
-.. _Subdiv2DGetEdge:
-
-Subdiv2DGetEdge
----------------
-
-`id=0.506587189348 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Subdiv2DGetEdge>`__
-
-
-.. function:: Subdiv2DGetEdge(edge,type)-> CvSubdiv2DEdge
-
- Returns one of the edges related to the given edge.
-
-
-
-
-
-
- :param edge: Subdivision edge (not a quad-edge)
-
- :type edge: :class:`CvSubdiv2DEdge`
-
-
- :param type: Specifies which of the related edges to return, one of the following:
-
- :type type: :class:`CvNextEdgeType`
-
-
-
-
- * **CV_NEXT_AROUND_ORG** next around the edge origin ( ``eOnext`` on the picture below if ``e`` is the input edge)
-
-
- * **CV_NEXT_AROUND_DST** next around the edge vertex ( ``eDnext`` )
-
-
- * **CV_PREV_AROUND_ORG** previous around the edge origin (reversed ``eRnext`` )
-
-
- * **CV_PREV_AROUND_DST** previous around the edge destination (reversed ``eLnext`` )
-
-
- * **CV_NEXT_AROUND_LEFT** next around the left facet ( ``eLnext`` )
-
-
- * **CV_NEXT_AROUND_RIGHT** next around the right facet ( ``eRnext`` )
-
-
- * **CV_PREV_AROUND_LEFT** previous around the left facet (reversed ``eOnext`` )
-
-
- * **CV_PREV_AROUND_RIGHT** previous around the right facet (reversed ``eDnext`` )
-
-
-
-
-
-
-
-.. image:: ../pics/quadedge.png
-
-
-
-The function returns one of the edges related to the input edge.
-
-
-.. index:: Subdiv2DNextEdge
-
-.. _Subdiv2DNextEdge:
-
-Subdiv2DNextEdge
-----------------
-
-`id=0.406592929731 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Subdiv2DNextEdge>`__
-
-
-.. function:: Subdiv2DNextEdge(edge)-> CvSubdiv2DEdge
-
- Returns next edge around the edge origin
-
-
-
-
-
-
- :param edge: Subdivision edge (not a quad-edge)
-
- :type edge: :class:`CvSubdiv2DEdge`
-
-
-
-
-
-.. image:: ../pics/quadedge.png
-
-
-
-The function returns the next edge around the edge origin:
-``eOnext``
-on the picture above if
-``e``
-is the input edge)
-
-
-.. index:: Subdiv2DLocate
-
-.. _Subdiv2DLocate:
-
-Subdiv2DLocate
---------------
-
-`id=0.614412184993 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Subdiv2DLocate>`__
-
-
-.. function:: Subdiv2DLocate(subdiv, pt) -> (loc, where)
-
- Returns the location of a point within a Delaunay triangulation.
-
-
-
-
-
-
- :param subdiv: Delaunay or another subdivision
-
- :type subdiv: :class:`CvSubdiv2D`
-
-
- :param pt: The point to locate
-
- :type pt: :class:`CvPoint2D32f`
-
-
- :param loc: The location of the point within the triangulation
-
- :type loc: int
-
-
- :param where: The edge or vertex. See below.
-
- :type where: :class:`CvSubdiv2DEdge`, :class:`CvSubdiv2DPoint`
-
-
-
-The function locates the input point within the subdivision. There are 5 cases:
-
-
-
-
-
-*
- The point falls into some facet.
- ``loc``
- is
- ``CV_PTLOC_INSIDE``
- and
- ``where``
- is one of edges of the facet.
-
-
-
-*
- The point falls onto the edge.
- ``loc``
- is
- ``CV_PTLOC_ON_EDGE``
- and
- ``where``
- is the edge.
-
-
-
-*
- The point coincides with one of the subdivision vertices.
- ``loc``
- is
- ``CV_PTLOC_VERTEX``
- and
- ``where``
- is the vertex.
-
-
-
-*
- The point is outside the subdivsion reference rectangle.
- ``loc``
- is
- ``CV_PTLOC_OUTSIDE_RECT``
- and
- ``where``
- is None.
-
-
-
-*
- One of input arguments is invalid. The function raises an exception.
-
-
-
-.. index:: Subdiv2DRotateEdge
-
-.. _Subdiv2DRotateEdge:
-
-Subdiv2DRotateEdge
-------------------
-
-`id=0.775095566923 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Subdiv2DRotateEdge>`__
-
-
-.. function:: Subdiv2DRotateEdge(edge,rotate)-> CvSubdiv2DEdge
-
- Returns another edge of the same quad-edge.
-
-
-
-
-
-
- :param edge: Subdivision edge (not a quad-edge)
-
- :type edge: :class:`CvSubdiv2DEdge`
-
-
- :param rotate: Specifies which of the edges of the same quad-edge as the input one to return, one of the following:
-
-
- * **0** the input edge ( ``e`` on the picture below if ``e`` is the input edge)
-
-
- * **1** the rotated edge ( ``eRot`` )
-
-
- * **2** the reversed edge (reversed ``e`` (in green))
-
-
- * **3** the reversed rotated edge (reversed ``eRot`` (in green))
-
-
-
- :type rotate: int
-
-
-
-
-
-.. image:: ../pics/quadedge.png
-
-
-
-The function returns one of the edges of the same quad-edge as the input edge.
-
-
-.. index:: SubdivDelaunay2DInsert
-
-.. _SubdivDelaunay2DInsert:
-
-SubdivDelaunay2DInsert
-----------------------
-
-`id=0.291010420302 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/SubdivDelaunay2DInsert>`__
-
-
-.. function:: SubdivDelaunay2DInsert(subdiv,pt)-> point
-
- Inserts a single point into a Delaunay triangulation.
-
-
-
-
-
-
- :param subdiv: Delaunay subdivision created by the function :ref:`CreateSubdivDelaunay2D`
-
- :type subdiv: :class:`CvSubdiv2D`
-
-
- :param pt: Inserted point
-
- :type pt: :class:`CvPoint2D32f`
-
-
-
-The function inserts a single point into a subdivision and modifies the subdivision topology appropriately. If a point with the same coordinates exists already, no new point is added. The function returns a pointer to the allocated point. No virtual point coordinates are calculated at this stage.
-
+++ /dev/null
-Structural Analysis and Shape Descriptors
-=========================================
-
-.. highlight:: python
-
-
-
-.. index:: ApproxChains
-
-.. _ApproxChains:
-
-ApproxChains
-------------
-
-`id=0.891722904536 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ApproxChains>`__
-
-
-.. function:: ApproxChains(src_seq,storage,method=CV_CHAIN_APPROX_SIMPLE,parameter=0,minimal_perimeter=0,recursive=0)-> chains
-
- Approximates Freeman chain(s) with a polygonal curve.
-
-
-
-
-
-
- :param src_seq: Pointer to the chain that can refer to other chains
-
- :type src_seq: :class:`CvSeq`
-
-
- :param storage: Storage location for the resulting polylines
-
- :type storage: :class:`CvMemStorage`
-
-
- :param method: Approximation method (see the description of the function :ref:`FindContours` )
-
- :type method: int
-
-
- :param parameter: Method parameter (not used now)
-
- :type parameter: float
-
-
- :param minimal_perimeter: Approximates only those contours whose perimeters are not less than ``minimal_perimeter`` . Other chains are removed from the resulting structure
-
- :type minimal_perimeter: int
-
-
- :param recursive: If not 0, the function approximates all chains that access can be obtained to from ``src_seq`` by using the ``h_next`` or ``v_next links`` . If 0, the single chain is approximated
-
- :type recursive: int
-
-
-
-This is a stand-alone approximation routine. The function
-``cvApproxChains``
-works exactly in the same way as
-:ref:`FindContours`
-with the corresponding approximation flag. The function returns pointer to the first resultant contour. Other approximated contours, if any, can be accessed via the
-``v_next``
-or
-``h_next``
-fields of the returned structure.
-
-
-.. index:: ApproxPoly
-
-.. _ApproxPoly:
-
-ApproxPoly
-----------
-
-`id=0.511872225874 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ApproxPoly>`__
-
-
-.. function::
-ApproxPoly(src_seq, storage, method, parameter=0, parameter2=0) -> sequence
-
-
- Approximates polygonal curve(s) with the specified precision.
-
-
-
-
-
-
- :param src_seq: Sequence of an array of points
-
- :type src_seq: :class:`CvArr` or :class:`CvSeq`
-
-
- :param storage: Container for the approximated contours. If it is NULL, the input sequences' storage is used
-
- :type storage: :class:`CvMemStorage`
-
-
- :param method: Approximation method; only ``CV_POLY_APPROX_DP`` is supported, that corresponds to the Douglas-Peucker algorithm
-
- :type method: int
-
-
- :param parameter: Method-specific parameter; in the case of ``CV_POLY_APPROX_DP`` it is a desired approximation accuracy
-
- :type parameter: float
-
-
- :param parameter2: If case if ``src_seq`` is a sequence, the parameter determines whether the single sequence should be approximated or all sequences on the same level or below ``src_seq`` (see :ref:`FindContours` for description of hierarchical contour structures). If ``src_seq`` is an array CvMat* of points, the parameter specifies whether the curve is closed ( ``parameter2`` !=0) or not ( ``parameter2`` =0)
-
- :type parameter2: int
-
-
-
-The function approximates one or more curves and
-returns the approximation result[s]. In the case of multiple curves,
-the resultant tree will have the same structure as the input one (1:1
-correspondence).
-
-
-.. index:: ArcLength
-
-.. _ArcLength:
-
-ArcLength
----------
-
-`id=0.00865407229522 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ArcLength>`__
-
-
-.. function:: ArcLength(curve,slice=CV_WHOLE_SEQ,isClosed=-1)-> double
-
- Calculates the contour perimeter or the curve length.
-
-
-
-
-
-
- :param curve: Sequence or array of the curve points
-
- :type curve: :class:`CvArr` or :class:`CvSeq`
-
-
- :param slice: Starting and ending points of the curve, by default, the whole curve length is calculated
-
- :type slice: :class:`CvSlice`
-
-
- :param isClosed: Indicates whether the curve is closed or not. There are 3 cases:
-
-
-
- * :math:`\texttt{isClosed}=0` the curve is assumed to be unclosed.
-
-
- * :math:`\texttt{isClosed}>0` the curve is assumed to be closed.
-
-
- * :math:`\texttt{isClosed}<0` if curve is sequence, the flag ``CV_SEQ_FLAG_CLOSED`` of ``((CvSeq*)curve)->flags`` is checked to determine if the curve is closed or not, otherwise (curve is represented by array (CvMat*) of points) it is assumed to be unclosed.
-
-
- :type isClosed: int
-
-
-
-The function calculates the length or curve as the sum of lengths of segments between subsequent points
-
-
-.. index:: BoundingRect
-
-.. _BoundingRect:
-
-BoundingRect
-------------
-
-`id=0.0890624819294 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/BoundingRect>`__
-
-
-.. function:: BoundingRect(points,update=0)-> CvRect
-
- Calculates the up-right bounding rectangle of a point set.
-
-
-
-
-
-
- :param points: 2D point set, either a sequence or vector ( ``CvMat`` ) of points
-
- :type points: :class:`CvArr` or :class:`CvSeq`
-
-
- :param update: The update flag. See below.
-
- :type update: int
-
-
-
-The function returns the up-right bounding rectangle for a 2d point set.
-Here is the list of possible combination of the flag values and type of
-``points``
-:
-
-
-.. table::
-
- ====== ========================= =======================================================================================================
- update points action \
- ====== ========================= =======================================================================================================
- 0 ``CvContour*`` the bounding rectangle is not calculated, but it is taken from ``rect`` field of the contour header. \
- 1 ``CvContour*`` the bounding rectangle is calculated and written to ``rect`` field of the contour header. \
- 0 ``CvSeq*`` or ``CvMat*`` the bounding rectangle is calculated and returned. \
- 1 ``CvSeq*`` or ``CvMat*`` runtime error is raised. \
- ====== ========================= =======================================================================================================
-
-
-.. index:: BoxPoints
-
-.. _BoxPoints:
-
-BoxPoints
----------
-
-`id=0.833111863214 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/BoxPoints>`__
-
-
-.. function:: BoxPoints(box)-> points
-
- Finds the box vertices.
-
-
-
-
-
-
- :param box: Box
-
- :type box: :class:`CvBox2D`
-
-
- :param points: Array of vertices
-
- :type points: :class:`CvPoint2D32f_4`
-
-
-
-The function calculates the vertices of the input 2d box.
-
-
-.. index:: CalcPGH
-
-.. _CalcPGH:
-
-CalcPGH
--------
-
-`id=0.492952101193 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcPGH>`__
-
-
-.. function:: CalcPGH(contour,hist)-> None
-
- Calculates a pair-wise geometrical histogram for a contour.
-
-
-
-
-
-
- :param contour: Input contour. Currently, only integer point coordinates are allowed
-
-
- :param hist: Calculated histogram; must be two-dimensional
-
-
-
-The function calculates a
-2D pair-wise geometrical histogram (PGH), described in
-:ref:`Iivarinen97`
-for the contour. The algorithm considers every pair of contour
-edges. The angle between the edges and the minimum/maximum distances
-are determined for every pair. To do this each of the edges in turn
-is taken as the base, while the function loops through all the other
-edges. When the base edge and any other edge are considered, the minimum
-and maximum distances from the points on the non-base edge and line of
-the base edge are selected. The angle between the edges defines the row
-of the histogram in which all the bins that correspond to the distance
-between the calculated minimum and maximum distances are incremented
-(that is, the histogram is transposed relatively to the
-:ref:`Iivarninen97`
-definition). The histogram can be used for contour matching.
-
-
-.. index:: CalcEMD2
-
-.. _CalcEMD2:
-
-CalcEMD2
---------
-
-`id=0.390300478738 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CalcEMD2>`__
-
-
-.. function:: CalcEMD2(signature1, signature2, distance_type, distance_func = None, cost_matrix=None, flow=None, lower_bound=None, userdata = None) -> float
-
- Computes the "minimal work" distance between two weighted point configurations.
-
-
-
-
-
-
- :param signature1: First signature, a :math:`\texttt{size1}\times \texttt{dims}+1` floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used
-
- :type signature1: :class:`CvArr`
-
-
- :param signature2: Second signature of the same format as ``signature1`` , though the number of rows may be different. The total weights may be different, in this case an extra "dummy" point is added to either ``signature1`` or ``signature2``
-
- :type signature2: :class:`CvArr`
-
-
- :param distance_type: Metrics used; ``CV_DIST_L1, CV_DIST_L2`` , and ``CV_DIST_C`` stand for one of the standard metrics; ``CV_DIST_USER`` means that a user-defined function ``distance_func`` or pre-calculated ``cost_matrix`` is used
-
- :type distance_type: int
-
-
- :param distance_func: The user-supplied distance function. It takes coordinates of two points ``pt0`` and ``pt1`` , and returns the distance between the points, with sigature ``
- func(pt0, pt1, userdata) -> float``
-
- :type distance_func: :class:`PyCallableObject`
-
-
- :param cost_matrix: The user-defined :math:`\texttt{size1}\times \texttt{size2}` cost matrix. At least one of ``cost_matrix`` and ``distance_func`` must be NULL. Also, if a cost matrix is used, lower boundary (see below) can not be calculated, because it needs a metric function
-
- :type cost_matrix: :class:`CvArr`
-
-
- :param flow: The resultant :math:`\texttt{size1} \times \texttt{size2}` flow matrix: :math:`\texttt{flow}_{i,j}` is a flow from :math:`i` th point of ``signature1`` to :math:`j` th point of ``signature2``
-
- :type flow: :class:`CvArr`
-
-
- :param lower_bound: Optional input/output parameter: lower boundary of distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (i.e. the signature matrices have a single column). The user **must** initialize ``*lower_bound`` . If the calculated distance between mass centers is greater or equal to ``*lower_bound`` (it means that the signatures are far enough) the function does not calculate EMD. In any case ``*lower_bound`` is set to the calculated distance between mass centers on return. Thus, if user wants to calculate both distance between mass centers and EMD, ``*lower_bound`` should be set to 0
-
- :type lower_bound: float
-
-
- :param userdata: Pointer to optional data that is passed into the user-defined distance function
-
- :type userdata: object
-
-
-
-The function computes the earth mover distance and/or
-a lower boundary of the distance between the two weighted point
-configurations. One of the applications described in
-:ref:`RubnerSept98`
-is
-multi-dimensional histogram comparison for image retrieval. EMD is a a
-transportation problem that is solved using some modification of a simplex
-algorithm, thus the complexity is exponential in the worst case, though, on average
-it is much faster. In the case of a real metric the lower boundary
-can be calculated even faster (using linear-time algorithm) and it can
-be used to determine roughly whether the two signatures are far enough
-so that they cannot relate to the same object.
-
-
-.. index:: CheckContourConvexity
-
-.. _CheckContourConvexity:
-
-CheckContourConvexity
----------------------
-
-`id=0.472970769213 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CheckContourConvexity>`__
-
-
-.. function:: CheckContourConvexity(contour)-> int
-
- Tests contour convexity.
-
-
-
-
-
-
- :param contour: Tested contour (sequence or array of points)
-
- :type contour: :class:`CvArr` or :class:`CvSeq`
-
-
-
-The function tests whether the input contour is convex or not. The contour must be simple, without self-intersections.
-
-
-.. index:: CvConvexityDefect
-
-.. _CvConvexityDefect:
-
-CvConvexityDefect
------------------
-
-`id=0.484949869638 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CvConvexityDefect>`__
-
-.. class:: CvConvexityDefect
-
-
-
-A single contour convexity defect, represented by a tuple
-``(start, end, depthpoint, depth)``
-.
-
-
-
-
-
- .. attribute:: start
-
-
-
- (x, y) point of the contour where the defect begins
-
-
-
- .. attribute:: end
-
-
-
- (x, y) point of the contour where the defect ends
-
-
-
- .. attribute:: depthpoint
-
-
-
- (x, y) point farthest from the convex hull point within the defect
-
-
-
- .. attribute:: depth
-
-
-
- distance between the farthest point and the convex hull
-
-
-
-
-
-.. image:: ../pics/defects.png
-
-
-
-
-.. index:: ContourArea
-
-.. _ContourArea:
-
-ContourArea
------------
-
-`id=0.958766756024 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ContourArea>`__
-
-
-.. function:: ContourArea(contour,slice=CV_WHOLE_SEQ)-> double
-
- Calculates the area of a whole contour or a contour section.
-
-
-
-
-
-
- :param contour: Contour (sequence or array of vertices)
-
- :type contour: :class:`CvArr` or :class:`CvSeq`
-
-
- :param slice: Starting and ending points of the contour section of interest, by default, the area of the whole contour is calculated
-
- :type slice: :class:`CvSlice`
-
-
-
-The function calculates the area of a whole contour
-or a contour section. In the latter case the total area bounded by the
-contour arc and the chord connecting the 2 selected points is calculated
-as shown on the picture below:
-
-
-
-.. image:: ../pics/contoursecarea.png
-
-
-
-Orientation of the contour affects the area sign, thus the function may return a
-*negative*
-result. Use the
-``fabs()``
-function from C runtime to get the absolute value of the area.
-
-
-.. index:: ContourFromContourTree
-
-.. _ContourFromContourTree:
-
-ContourFromContourTree
-----------------------
-
-`id=0.162786680111 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ContourFromContourTree>`__
-
-
-.. function:: ContourFromContourTree(tree,storage,criteria)-> contour
-
- Restores a contour from the tree.
-
-
-
-
-
-
- :param tree: Contour tree
-
-
- :param storage: Container for the reconstructed contour
-
-
- :param criteria: Criteria, where to stop reconstruction
-
-
-
-The function restores the contour from its binary tree representation. The parameter
-``criteria``
-determines the accuracy and/or the number of tree levels used for reconstruction, so it is possible to build an approximated contour. The function returns the reconstructed contour.
-
-
-.. index:: ConvexHull2
-
-.. _ConvexHull2:
-
-ConvexHull2
------------
-
-`id=0.277941655963 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ConvexHull2>`__
-
-
-.. function:: ConvexHull2(points,storage,orientation=CV_CLOCKWISE,return_points=0)-> convex_hull
-
- Finds the convex hull of a point set.
-
-
-
-
-
-
- :param points: Sequence or array of 2D points with 32-bit integer or floating-point coordinates
-
- :type points: :class:`CvArr` or :class:`CvSeq`
-
-
- :param storage: The destination array (CvMat*) or memory storage (CvMemStorage*) that will store the convex hull. If it is an array, it should be 1d and have the same number of elements as the input array/sequence. On output the header is modified as to truncate the array down to the hull size. If ``storage`` is NULL then the convex hull will be stored in the same storage as the input sequence
-
- :type storage: :class:`CvMemStorage`
-
-
- :param orientation: Desired orientation of convex hull: ``CV_CLOCKWISE`` or ``CV_COUNTER_CLOCKWISE``
-
- :type orientation: int
-
-
- :param return_points: If non-zero, the points themselves will be stored in the hull instead of indices if ``storage`` is an array, or pointers if ``storage`` is memory storage
-
- :type return_points: int
-
-
-
-The function finds the convex hull of a 2D point set using Sklansky's algorithm. If
-``storage``
-is memory storage, the function creates a sequence containing the hull points or pointers to them, depending on
-``return_points``
-value and returns the sequence on output. If
-``storage``
-is a CvMat, the function returns NULL.
-
-
-.. index:: ConvexityDefects
-
-.. _ConvexityDefects:
-
-ConvexityDefects
-----------------
-
-`id=0.819226332619 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/ConvexityDefects>`__
-
-
-.. function:: ConvexityDefects(contour,convexhull,storage)-> convexity_defects
-
- Finds the convexity defects of a contour.
-
-
-
-
-
-
- :param contour: Input contour
-
- :type contour: :class:`CvArr` or :class:`CvSeq`
-
-
- :param convexhull: Convex hull obtained using :ref:`ConvexHull2` that should contain pointers or indices to the contour points, not the hull points themselves (the ``return_points`` parameter in :ref:`ConvexHull2` should be 0)
-
- :type convexhull: :class:`CvSeq`
-
-
- :param storage: Container for the output sequence of convexity defects. If it is NULL, the contour or hull (in that order) storage is used
-
- :type storage: :class:`CvMemStorage`
-
-
-
-The function finds all convexity defects of the input contour and returns a sequence of the CvConvexityDefect structures.
-
-
-.. index:: CreateContourTree
-
-.. _CreateContourTree:
-
-CreateContourTree
------------------
-
-`id=0.249344062216 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/CreateContourTree>`__
-
-
-.. function:: CreateContourTree(contour,storage,threshold)-> contour_tree
-
- Creates a hierarchical representation of a contour.
-
-
-
-
-
-
- :param contour: Input contour
-
-
- :param storage: Container for output tree
-
-
- :param threshold: Approximation accuracy
-
-
-
-The function creates a binary tree representation for the input
-``contour``
-and returns the pointer to its root. If the parameter
-``threshold``
-is less than or equal to 0, the function creates a full binary tree representation. If the threshold is greater than 0, the function creates a representation with the precision
-``threshold``
-: if the vertices with the interceptive area of its base line are less than
-``threshold``
-, the tree should not be built any further. The function returns the created tree.
-
-
-.. index:: FindContours
-
-.. _FindContours:
-
-FindContours
-------------
-
-`id=0.577796431347 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FindContours>`__
-
-
-.. function:: FindContours(image, storage, mode=CV_RETR_LIST, method=CV_CHAIN_APPROX_SIMPLE, offset=(0,0)) -> cvseq
-
- Finds the contours in a binary image.
-
-
-
-
-
-
- :param image: The source, an 8-bit single channel image. Non-zero pixels are treated as 1's, zero pixels remain 0's - the image is treated as ``binary`` . To get such a binary image from grayscale, one may use :ref:`Threshold` , :ref:`AdaptiveThreshold` or :ref:`Canny` . The function modifies the source image's content
-
- :type image: :class:`CvArr`
-
-
- :param storage: Container of the retrieved contours
-
- :type storage: :class:`CvMemStorage`
-
-
- :param mode: Retrieval mode
-
-
- * **CV_RETR_EXTERNAL** retrives only the extreme outer contours
-
-
- * **CV_RETR_LIST** retrieves all of the contours and puts them in the list
-
-
- * **CV_RETR_CCOMP** retrieves all of the contours and organizes them into a two-level hierarchy: on the top level are the external boundaries of the components, on the second level are the boundaries of the holes
-
-
- * **CV_RETR_TREE** retrieves all of the contours and reconstructs the full hierarchy of nested contours
-
-
-
- :type mode: int
-
-
- :param method: Approximation method (for all the modes, except ``CV_LINK_RUNS`` , which uses built-in approximation)
-
-
- * **CV_CHAIN_CODE** outputs contours in the Freeman chain code. All other methods output polygons (sequences of vertices)
-
-
- * **CV_CHAIN_APPROX_NONE** translates all of the points from the chain code into points
-
-
- * **CV_CHAIN_APPROX_SIMPLE** compresses horizontal, vertical, and diagonal segments and leaves only their end points
-
-
- * **CV_CHAIN_APPROX_TC89_L1,CV_CHAIN_APPROX_TC89_KCOS** applies one of the flavors of the Teh-Chin chain approximation algorithm.
-
-
- * **CV_LINK_RUNS** uses a completely different contour retrieval algorithm by linking horizontal segments of 1's. Only the ``CV_RETR_LIST`` retrieval mode can be used with this method.
-
-
-
- :type method: int
-
-
- :param offset: Offset, by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context
-
- :type offset: :class:`CvPoint`
-
-
-
-The function retrieves contours from the binary image using the algorithm
-Suzuki85
-. The contours are a useful tool for shape analysis and
-object detection and recognition.
-
-The function retrieves contours from the
-binary image and returns the number of retrieved contours. The
-pointer
-``first_contour``
-is filled by the function. It will
-contain a pointer to the first outermost contour or
-``NULL``
-if no
-contours are detected (if the image is completely black). Other
-contours may be reached from
-``first_contour``
-using the
-``h_next``
-and
-``v_next``
-links. The sample in the
-:ref:`DrawContours`
-discussion shows how to use contours for
-connected component detection. Contours can be also used for shape
-analysis and object recognition - see
-``squares.py``
-in the OpenCV sample directory.
-
-**Note:**
-the source
-``image``
-is modified by this function.
-
-
-.. index:: FitEllipse2
-
-.. _FitEllipse2:
-
-FitEllipse2
------------
-
-`id=0.461296656973 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FitEllipse2>`__
-
-
-.. function:: FitEllipse2(points)-> Box2D
-
- Fits an ellipse around a set of 2D points.
-
-
-
-
-
-
- :param points: Sequence or array of points
-
- :type points: :class:`CvArr`
-
-
-
-The function calculates the ellipse that fits best
-(in least-squares sense) around a set of 2D points. The meaning of the
-returned structure fields is similar to those in
-:ref:`Ellipse`
-except
-that
-``size``
-stores the full lengths of the ellipse axises,
-not half-lengths.
-
-
-.. index:: FitLine
-
-.. _FitLine:
-
-FitLine
--------
-
-`id=0.681153539505 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/FitLine>`__
-
-
-.. function:: FitLine(points, dist_type, param, reps, aeps) -> line
-
- Fits a line to a 2D or 3D point set.
-
-
-
-
-
-
- :param points: Sequence or array of 2D or 3D points with 32-bit integer or floating-point coordinates
-
- :type points: :class:`CvArr`
-
-
- :param dist_type: The distance used for fitting (see the discussion)
-
- :type dist_type: int
-
-
- :param param: Numerical parameter ( ``C`` ) for some types of distances, if 0 then some optimal value is chosen
-
- :type param: float
-
-
- :param reps: Sufficient accuracy for the radius (distance between the coordinate origin and the line). 0.01 is a good default value.
-
- :type reps: float
-
-
- :param aeps: Sufficient accuracy for the angle. 0.01 is a good default value.
-
- :type aeps: float
-
-
- :param line: The output line parameters. In the case of a 2d fitting,
- it is a tuple of 4 floats ``(vx, vy, x0, y0)`` where ``(vx, vy)`` is a normalized vector collinear to the
- line and ``(x0, y0)`` is some point on the line. in the case of a
- 3D fitting it is a tuple of 6 floats ``(vx, vy, vz, x0, y0, z0)``
- where ``(vx, vy, vz)`` is a normalized vector collinear to the line
- and ``(x0, y0, z0)`` is some point on the line
-
- :type line: object
-
-
-
-The function fits a line to a 2D or 3D point set by minimizing
-:math:`\sum_i \rho(r_i)`
-where
-:math:`r_i`
-is the distance between the
-:math:`i`
-th point and the line and
-:math:`\rho(r)`
-is a distance function, one of:
-
-
-
-
-
-* dist\_type=CV\_DIST\_L2
-
-
- .. math::
-
- \rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}
-
-
-
-
-* dist\_type=CV\_DIST\_L1
-
-
- .. math::
-
- \rho (r) = r
-
-
-
-
-* dist\_type=CV\_DIST\_L12
-
-
- .. math::
-
- \rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)
-
-
-
-
-* dist\_type=CV\_DIST\_FAIR
-
-
- .. math::
-
- \rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998
-
-
-
-
-* dist\_type=CV\_DIST\_WELSCH
-
-
- .. math::
-
- \rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846
-
-
-
-
-* dist\_type=CV\_DIST\_HUBER
-
-
- .. math::
-
- \rho (r) = \fork{r^2/2}{if $r < C$}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345
-
-
-
-
-
-.. index:: GetCentralMoment
-
-.. _GetCentralMoment:
-
-GetCentralMoment
-----------------
-
-`id=0.28222157071 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetCentralMoment>`__
-
-
-.. function:: GetCentralMoment(moments, x_order, y_order) -> double
-
- Retrieves the central moment from the moment state structure.
-
-
-
-
-
-
- :param moments: Pointer to the moment state structure
-
- :type moments: :class:`CvMoments`
-
-
- :param x_order: x order of the retrieved moment, :math:`\texttt{x\_order} >= 0`
-
- :type x_order: int
-
-
- :param y_order: y order of the retrieved moment, :math:`\texttt{y\_order} >= 0` and :math:`\texttt{x\_order} + \texttt{y\_order} <= 3`
-
- :type y_order: int
-
-
-
-The function retrieves the central moment, which in the case of image moments is defined as:
-
-
-
-.. math::
-
- \mu _{x \_ order, \, y \_ order} = \sum _{x,y} (I(x,y) \cdot (x-x_c)^{x \_ order} \cdot (y-y_c)^{y \_ order})
-
-
-where
-:math:`x_c,y_c`
-are the coordinates of the gravity center:
-
-
-
-.. math::
-
- x_c= \frac{M_{10}}{M_{00}} , y_c= \frac{M_{01}}{M_{00}}
-
-
-
-.. index:: GetHuMoments
-
-.. _GetHuMoments:
-
-GetHuMoments
-------------
-
-`id=0.855980556214 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetHuMoments>`__
-
-
-.. function:: GetHuMoments(moments) -> hu
-
- Calculates the seven Hu invariants.
-
-
-
-
-
-
- :param moments: The input moments, computed with :ref:`Moments`
-
- :type moments: :class:`CvMoments`
-
-
- :param hu: The output Hu invariants
-
- :type hu: object
-
-
-
-The function calculates the seven Hu invariants, see
-http://en.wikipedia.org/wiki/Image_moment
-, that are defined as:
-
-
-
-.. math::
-
- \begin{array}{l} hu_1= \eta _{20}+ \eta _{02} \\ hu_2=( \eta _{20}- \eta _{02})^{2}+4 \eta _{11}^{2} \\ hu_3=( \eta _{30}-3 \eta _{12})^{2}+ (3 \eta _{21}- \eta _{03})^{2} \\ hu_4=( \eta _{30}+ \eta _{12})^{2}+ ( \eta _{21}+ \eta _{03})^{2} \\ hu_5=( \eta _{30}-3 \eta _{12})( \eta _{30}+ \eta _{12})[( \eta _{30}+ \eta _{12})^{2}-3( \eta _{21}+ \eta _{03})^{2}]+(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ hu_6=( \eta _{20}- \eta _{02})[( \eta _{30}+ \eta _{12})^{2}- ( \eta _{21}+ \eta _{03})^{2}]+4 \eta _{11}( \eta _{30}+ \eta _{12})( \eta _{21}+ \eta _{03}) \\ hu_7=(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}]-( \eta _{30}-3 \eta _{12})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ \end{array}
-
-
-where
-:math:`\eta_{ji}`
-denote the normalized central moments.
-
-These values are proved to be invariant to the image scale, rotation, and reflection except the seventh one, whose sign is changed by reflection. Of course, this invariance was proved with the assumption of infinite image resolution. In case of a raster images the computed Hu invariants for the original and transformed images will be a bit different.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> original = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
- >>> print cv.GetHuMoments(cv.Moments(original))
- (0.0010620951868446141, 1.7962726159653835e-07, 1.4932744974469421e-11, 4.4832441315737963e-12, -1.0819359198251739e-23, -9.5726503811945833e-16, -3.5050592804744648e-23)
- >>> flipped = cv.CloneMat(original)
- >>> cv.Flip(original, flipped)
- >>> print cv.GetHuMoments(cv.Moments(flipped))
- (0.0010620951868446141, 1.796272615965384e-07, 1.4932744974469935e-11, 4.4832441315740249e-12, -1.0819359198259393e-23, -9.572650381193327e-16, 3.5050592804745877e-23)
-
-
-..
-
-
-.. index:: GetNormalizedCentralMoment
-
-.. _GetNormalizedCentralMoment:
-
-GetNormalizedCentralMoment
---------------------------
-
-`id=0.725127020324 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetNormalizedCentralMoment>`__
-
-
-.. function:: GetNormalizedCentralMoment(moments, x_order, y_order) -> double
-
- Retrieves the normalized central moment from the moment state structure.
-
-
-
-
-
-
- :param moments: Pointer to the moment state structure
-
- :type moments: :class:`CvMoments`
-
-
- :param x_order: x order of the retrieved moment, :math:`\texttt{x\_order} >= 0`
-
- :type x_order: int
-
-
- :param y_order: y order of the retrieved moment, :math:`\texttt{y\_order} >= 0` and :math:`\texttt{x\_order} + \texttt{y\_order} <= 3`
-
- :type y_order: int
-
-
-
-The function retrieves the normalized central moment:
-
-
-
-.. math::
-
- \eta _{x \_ order, \, y \_ order} = \frac{\mu_{x\_order, \, y\_order}}{M_{00}^{(y\_order+x\_order)/2+1}}
-
-
-
-.. index:: GetSpatialMoment
-
-.. _GetSpatialMoment:
-
-GetSpatialMoment
-----------------
-
-`id=0.191749557246 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/GetSpatialMoment>`__
-
-
-.. function:: GetSpatialMoment(moments, x_order, y_order) -> double
-
- Retrieves the spatial moment from the moment state structure.
-
-
-
-
-
-
- :param moments: The moment state, calculated by :ref:`Moments`
-
- :type moments: :class:`CvMoments`
-
-
- :param x_order: x order of the retrieved moment, :math:`\texttt{x\_order} >= 0`
-
- :type x_order: int
-
-
- :param y_order: y order of the retrieved moment, :math:`\texttt{y\_order} >= 0` and :math:`\texttt{x\_order} + \texttt{y\_order} <= 3`
-
- :type y_order: int
-
-
-
-The function retrieves the spatial moment, which in the case of image moments is defined as:
-
-
-
-.. math::
-
- M_{x \_ order, \, y \_ order} = \sum _{x,y} (I(x,y) \cdot x^{x \_ order} \cdot y^{y \_ order})
-
-
-where
-:math:`I(x,y)`
-is the intensity of the pixel
-:math:`(x, y)`
-.
-
-
-.. index:: MatchContourTrees
-
-.. _MatchContourTrees:
-
-MatchContourTrees
------------------
-
-`id=0.480547577878 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MatchContourTrees>`__
-
-
-.. function:: MatchContourTrees(tree1,tree2,method,threshold)-> double
-
- Compares two contours using their tree representations.
-
-
-
-
-
-
- :param tree1: First contour tree
-
-
- :param tree2: Second contour tree
-
-
- :param method: Similarity measure, only ``CV_CONTOUR_TREES_MATCH_I1`` is supported
-
-
- :param threshold: Similarity threshold
-
-
-
-The function calculates the value of the matching measure for two contour trees. The similarity measure is calculated level by level from the binary tree roots. If at a certain level the difference between contours becomes less than
-``threshold``
-, the reconstruction process is interrupted and the current difference is returned.
-
-
-.. index:: MatchShapes
-
-.. _MatchShapes:
-
-MatchShapes
------------
-
-`id=0.317335085559 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MatchShapes>`__
-
-
-.. function:: MatchShapes(object1,object2,method,parameter=0)-> None
-
- Compares two shapes.
-
-
-
-
-
-
- :param object1: First contour or grayscale image
-
- :type object1: :class:`CvSeq`
-
-
- :param object2: Second contour or grayscale image
-
- :type object2: :class:`CvSeq`
-
-
- :param method: Comparison method;
- ``CV_CONTOUR_MATCH_I1`` ,
- ``CV_CONTOURS_MATCH_I2``
- or
- ``CV_CONTOURS_MATCH_I3``
-
- :type method: int
-
-
- :param parameter: Method-specific parameter (is not used now)
-
- :type parameter: float
-
-
-
-The function compares two shapes. The 3 implemented methods all use Hu moments (see
-:ref:`GetHuMoments`
-) (
-:math:`A`
-is
-``object1``
-,
-:math:`B`
-is
-``object2``
-):
-
-
-
-
-
-* method=CV\_CONTOUR\_MATCH\_I1
-
-
- .. math::
-
- I_1(A,B) = \sum _{i=1...7} \left | \frac{1}{m^A_i} - \frac{1}{m^B_i} \right |
-
-
-
-
-* method=CV\_CONTOUR\_MATCH\_I2
-
-
- .. math::
-
- I_2(A,B) = \sum _{i=1...7} \left | m^A_i - m^B_i \right |
-
-
-
-
-* method=CV\_CONTOUR\_MATCH\_I3
-
-
- .. math::
-
- I_3(A,B) = \sum _{i=1...7} \frac{ \left| m^A_i - m^B_i \right| }{ \left| m^A_i \right| }
-
-
-
-
-where
-
-
-
-.. math::
-
- \begin{array}{l} m^A_i = sign(h^A_i) \cdot \log{h^A_i} m^B_i = sign(h^B_i) \cdot \log{h^B_i} \end{array}
-
-
-and
-:math:`h^A_i, h^B_i`
-are the Hu moments of
-:math:`A`
-and
-:math:`B`
-respectively.
-
-
-
-.. index:: MinAreaRect2
-
-.. _MinAreaRect2:
-
-MinAreaRect2
-------------
-
-`id=0.271581100753 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MinAreaRect2>`__
-
-
-.. function:: MinAreaRect2(points,storage=NULL)-> CvBox2D
-
- Finds the circumscribed rectangle of minimal area for a given 2D point set.
-
-
-
-
-
-
- :param points: Sequence or array of points
-
- :type points: :class:`CvArr` or :class:`CvSeq`
-
-
- :param storage: Optional temporary memory storage
-
- :type storage: :class:`CvMemStorage`
-
-
-
-The function finds a circumscribed rectangle of the minimal area for a 2D point set by building a convex hull for the set and applying the rotating calipers technique to the hull.
-
-Picture. Minimal-area bounding rectangle for contour
-
-
-
-.. image:: ../pics/minareabox.png
-
-
-
-
-.. index:: MinEnclosingCircle
-
-.. _MinEnclosingCircle:
-
-MinEnclosingCircle
-------------------
-
-`id=0.696424733079 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/MinEnclosingCircle>`__
-
-
-.. function:: MinEnclosingCircle(points)-> (int,center,radius)
-
- Finds the circumscribed circle of minimal area for a given 2D point set.
-
-
-
-
-
-
- :param points: Sequence or array of 2D points
-
- :type points: :class:`CvArr` or :class:`CvSeq`
-
-
- :param center: Output parameter; the center of the enclosing circle
-
- :type center: :class:`CvPoint2D32f`
-
-
- :param radius: Output parameter; the radius of the enclosing circle
-
- :type radius: float
-
-
-
-The function finds the minimal circumscribed
-circle for a 2D point set using an iterative algorithm. It returns nonzero
-if the resultant circle contains all the input points and zero otherwise
-(i.e. the algorithm failed).
-
-
-.. index:: Moments
-
-.. _Moments:
-
-Moments
--------
-
-`id=0.590982994221 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/Moments>`__
-
-
-.. function:: Moments(arr, binary = 0) -> moments
-
- Calculates all of the moments up to the third order of a polygon or rasterized shape.
-
-
-
-
-
-
- :param arr: Image (1-channel or 3-channel with COI set) or polygon (CvSeq of points or a vector of points)
-
- :type arr: :class:`CvArr` or :class:`CvSeq`
-
-
- :param moments: Pointer to returned moment's state structure
-
- :type moments: :class:`CvMoments`
-
-
- :param binary: (For images only) If the flag is non-zero, all of the zero pixel values are treated as zeroes, and all of the others are treated as 1's
-
- :type binary: int
-
-
-
-The function calculates spatial and central moments up to the third order and writes them to
-``moments``
-. The moments may then be used then to calculate the gravity center of the shape, its area, main axises and various shape characeteristics including 7 Hu invariants.
-
-
-.. index:: PointPolygonTest
-
-.. _PointPolygonTest:
-
-PointPolygonTest
-----------------
-
-`id=0.315610322671 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/imgproc/PointPolygonTest>`__
-
-
-.. function:: PointPolygonTest(contour,pt,measure_dist)-> double
-
- Point in contour test.
-
-
-
-
-
-
- :param contour: Input contour
-
- :type contour: :class:`CvArr` or :class:`CvSeq`
-
-
- :param pt: The point tested against the contour
-
- :type pt: :class:`CvPoint2D32f`
-
-
- :param measure_dist: If it is non-zero, the function estimates the distance from the point to the nearest contour edge
-
- :type measure_dist: int
-
-
-
-The function determines whether the
-point is inside a contour, outside, or lies on an edge (or coinsides
-with a vertex). It returns positive, negative or zero value,
-correspondingly. When
-:math:`\texttt{measure\_dist} =0`
-, the return value
-is +1, -1 and 0, respectively. When
-:math:`\texttt{measure\_dist} \ne 0`
-,
-it is a signed distance between the point and the nearest contour
-edge.
-
-Here is the sample output of the function, where each image pixel is tested against the contour.
-
-
-
-.. image:: ../pics/pointpolygon.png
-
-
-
+++ /dev/null
-************
-Introduction
-************
-
-
-Starting with release 2.0, OpenCV has a new Python interface. This replaces the previous
-`SWIG-based Python interface <http://opencv.willowgarage.com/wiki/SwigPythonInterface>`_
-.
-
-Some highlights of the new bindings:
-
-
-
-
-
-* single import of all of OpenCV using ``import cv``
-
-
-* OpenCV functions no longer have the "cv" prefix
-
-
-* simple types like CvRect and CvScalar use Python tuples
-
-
-* sharing of Image storage, so image transport between OpenCV and other systems (e.g. numpy and ROS) is very efficient
-
-
-* complete documentation for the Python functions
-
-
-This cookbook section contains a few illustrative examples of OpenCV Python code.
-
-
-.. toctree::
- :maxdepth: 2
-
- cookbook
+++ /dev/null
-***************************
-objdetect. Object Detection
-***************************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- objdetect_cascade_classification
+++ /dev/null
-Cascade Classification
-======================
-
-.. highlight:: python
-
-
-
-Haar Feature-based Cascade Classifier for Object Detection
-----------------------------------------------------------
-
-
-The object detector described below has been initially proposed by Paul Viola
-:ref:`Viola01`
-and improved by Rainer Lienhart
-:ref:`Lienhart02`
-. First, a classifier (namely a
-*cascade of boosted classifiers working with haar-like features*
-) is trained with a few hundred sample views of a particular object (i.e., a face or a car), called positive examples, that are scaled to the same size (say, 20x20), and negative examples - arbitrary images of the same size.
-
-After a classifier is trained, it can be applied to a region of interest
-(of the same size as used during the training) in an input image. The
-classifier outputs a "1" if the region is likely to show the object
-(i.e., face/car), and "0" otherwise. To search for the object in the
-whole image one can move the search window across the image and check
-every location using the classifier. The classifier is designed so that
-it can be easily "resized" in order to be able to find the objects of
-interest at different sizes, which is more efficient than resizing the
-image itself. So, to find an object of an unknown size in the image the
-scan procedure should be done several times at different scales.
-
-The word "cascade" in the classifier name means that the resultant
-classifier consists of several simpler classifiers (
-*stages*
-) that
-are applied subsequently to a region of interest until at some stage the
-candidate is rejected or all the stages are passed. The word "boosted"
-means that the classifiers at every stage of the cascade are complex
-themselves and they are built out of basic classifiers using one of four
-different
-``boosting``
-techniques (weighted voting). Currently
-Discrete Adaboost, Real Adaboost, Gentle Adaboost and Logitboost are
-supported. The basic classifiers are decision-tree classifiers with at
-least 2 leaves. Haar-like features are the input to the basic classifers,
-and are calculated as described below. The current algorithm uses the
-following Haar-like features:
-
-
-
-.. image:: ../pics/haarfeatures.png
-
-
-
-The feature used in a particular classifier is specified by its shape (1a, 2b etc.), position within the region of interest and the scale (this scale is not the same as the scale used at the detection stage, though these two scales are multiplied). For example, in the case of the third line feature (2c) the response is calculated as the difference between the sum of image pixels under the rectangle covering the whole feature (including the two white stripes and the black stripe in the middle) and the sum of the image pixels under the black stripe multiplied by 3 in order to compensate for the differences in the size of areas. The sums of pixel values over a rectangular regions are calculated rapidly using integral images (see below and the
-:ref:`Integral`
-description).
-
-A simple demonstration of face detection, which draws a rectangle around each detected face:
-
-
-
-
-::
-
-
-
-
- hc = cv.Load("haarcascade_frontalface_default.xml")
- img = cv.LoadImage("faces.jpg", 0)
- faces = cv.HaarDetectObjects(img, hc, cv.CreateMemStorage())
- for (x,y,w,h),n in faces:
- cv.Rectangle(img, (x,y), (x+w,y+h), 255)
- cv.SaveImage("faces_detected.jpg", img)
-
-
-
-..
-
-
-.. index:: HaarDetectObjects
-
-.. _HaarDetectObjects:
-
-HaarDetectObjects
------------------
-
-`id=0.467753723618 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/objdetect/HaarDetectObjects>`__
-
-
-.. function:: HaarDetectObjects(image,cascade,storage,scaleFactor=1.1,minNeighbors=3,flags=0,minSize=(0,0))-> detected_objects
-
- Detects objects in the image.
-
-
-
-
-
-
- :param image: Image to detect objects in
-
- :type image: :class:`CvArr`
-
-
- :param cascade: Haar classifier cascade in internal representation
-
- :type cascade: :class:`CvHaarClassifierCascade`
-
-
- :param storage: Memory storage to store the resultant sequence of the object candidate rectangles
-
- :type storage: :class:`CvMemStorage`
-
-
- :param scaleFactor: The factor by which the search window is scaled between the subsequent scans, 1.1 means increasing window by 10 %
-
-
- :param minNeighbors: Minimum number (minus 1) of neighbor rectangles that makes up an object. All the groups of a smaller number of rectangles than ``min_neighbors`` -1 are rejected. If ``minNeighbors`` is 0, the function does not any grouping at all and returns all the detected candidate rectangles, which may be useful if the user wants to apply a customized grouping procedure
-
-
- :param flags: Mode of operation. Currently the only flag that may be specified is ``CV_HAAR_DO_CANNY_PRUNING`` . If it is set, the function uses Canny edge detector to reject some image regions that contain too few or too much edges and thus can not contain the searched object. The particular threshold values are tuned for face detection and in this case the pruning speeds up the processing
-
- :type flags: int
-
-
- :param minSize: Minimum window size. By default, it is set to the size of samples the classifier has been trained on ( :math:`\sim 20\times 20` for face detection)
-
-
- :param maxSize: Maximum window size to use. By default, it is set to the size of the image.
-
-
-
-The function finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles. The function scans the image several times at different scales (see
-:ref:`SetImagesForHaarClassifierCascade`
-). Each time it considers overlapping regions in the image and applies the classifiers to the regions using
-:ref:`RunHaarClassifierCascade`
-. It may also apply some heuristics to reduce number of analyzed regions, such as Canny prunning. After it has proceeded and collected the candidate rectangles (regions that passed the classifier cascade), it groups them and returns a sequence of average rectangles for each large enough group. The default parameters (
-``scale_factor``
-=1.1,
-``min_neighbors``
-=3,
-``flags``
-=0) are tuned for accurate yet slow object detection. For a faster operation on real video images the settings are:
-``scale_factor``
-=1.2,
-``min_neighbors``
-=2,
-``flags``
-=
-``CV_HAAR_DO_CANNY_PRUNING``
-,
-``min_size``
-=
-*minimum possible face size*
-(for example,
-:math:`\sim`
-1/4 to 1/16 of the image area in the case of video conferencing).
-
-The function returns a list of tuples,
-``(rect, neighbors)``
-, where rect is a
-:ref:`CvRect`
-specifying the object's extents
-and neighbors is a number of neighbors.
-
-
-
-
-.. doctest::
-
-
-
- >>> import cv
- >>> image = cv.LoadImageM("lena.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
- >>> cascade = cv.Load("../../data/haarcascades/haarcascade_frontalface_alt.xml")
- >>> print cv.HaarDetectObjects(image, cascade, cv.CreateMemStorage(0), 1.2, 2, 0, (20, 20))
- [((217, 203, 169, 169), 24)]
-
-
-..
-
+++ /dev/null
-################
-Python Reference
-################
-
-.. highlight:: python
-
-.. toctree::
- :maxdepth: 2
-
- introduction
- core
- imgproc
- features2d
- objdetect
- video
- highgui
- calib3d
+++ /dev/null
-*********************
-video. Video Analysis
-*********************
-
-
-
-.. toctree::
- :maxdepth: 2
-
- video_motion_analysis_and_object_tracking
+++ /dev/null
-Motion Analysis and Object Tracking
-===================================
-
-.. highlight:: python
-
-
-
-.. index:: CalcGlobalOrientation
-
-.. _CalcGlobalOrientation:
-
-CalcGlobalOrientation
----------------------
-
-`id=0.671861796406 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcGlobalOrientation>`__
-
-
-.. function:: CalcGlobalOrientation(orientation,mask,mhi,timestamp,duration)-> float
-
- Calculates the global motion orientation of some selected region.
-
-
-
-
-
-
- :param orientation: Motion gradient orientation image; calculated by the function :ref:`CalcMotionGradient`
-
- :type orientation: :class:`CvArr`
-
-
- :param mask: Mask image. It may be a conjunction of a valid gradient mask, obtained with :ref:`CalcMotionGradient` and the mask of the region, whose direction needs to be calculated
-
- :type mask: :class:`CvArr`
-
-
- :param mhi: Motion history image
-
- :type mhi: :class:`CvArr`
-
-
- :param timestamp: Current time in milliseconds or other units, it is better to store time passed to :ref:`UpdateMotionHistory` before and reuse it here, because running :ref:`UpdateMotionHistory` and :ref:`CalcMotionGradient` on large images may take some time
-
- :type timestamp: float
-
-
- :param duration: Maximal duration of motion track in milliseconds, the same as :ref:`UpdateMotionHistory`
-
- :type duration: float
-
-
-
-The function calculates the general
-motion direction in the selected region and returns the angle between
-0 degrees and 360 degrees . At first the function builds the orientation histogram
-and finds the basic orientation as a coordinate of the histogram
-maximum. After that the function calculates the shift relative to the
-basic orientation as a weighted sum of all of the orientation vectors: the more
-recent the motion, the greater the weight. The resultant angle is
-a circular sum of the basic orientation and the shift.
-
-
-.. index:: CalcMotionGradient
-
-.. _CalcMotionGradient:
-
-CalcMotionGradient
-------------------
-
-`id=0.734160644258 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcMotionGradient>`__
-
-
-.. function:: CalcMotionGradient(mhi,mask,orientation,delta1,delta2,apertureSize=3)-> None
-
- Calculates the gradient orientation of a motion history image.
-
-
-
-
-
-
- :param mhi: Motion history image
-
- :type mhi: :class:`CvArr`
-
-
- :param mask: Mask image; marks pixels where the motion gradient data is correct; output parameter
-
- :type mask: :class:`CvArr`
-
-
- :param orientation: Motion gradient orientation image; contains angles from 0 to ~360 degrees
-
- :type orientation: :class:`CvArr`
-
-
- :param delta1: See below
-
- :type delta1: float
-
-
- :param delta2: See below
-
- :type delta2: float
-
-
- :param apertureSize: Aperture size of derivative operators used by the function: CV _ SCHARR, 1, 3, 5 or 7 (see :ref:`Sobel` )
-
- :type apertureSize: int
-
-
-
-The function calculates the derivatives
-:math:`Dx`
-and
-:math:`Dy`
-of
-``mhi``
-and then calculates gradient orientation as:
-
-
-
-.. math::
-
- \texttt{orientation} (x,y)= \arctan{\frac{Dy(x,y)}{Dx(x,y)}}
-
-
-where both
-:math:`Dx(x,y)`
-and
-:math:`Dy(x,y)`
-signs are taken into account (as in the
-:ref:`CartToPolar`
-function). After that
-``mask``
-is filled to indicate where the orientation is valid (see the
-``delta1``
-and
-``delta2``
-description).
-
-The function finds the minimum (
-:math:`m(x,y)`
-) and maximum (
-:math:`M(x,y)`
-) mhi values over each pixel
-:math:`(x,y)`
-neighborhood and assumes the gradient is valid only if
-
-
-.. math::
-
- \min ( \texttt{delta1} , \texttt{delta2} ) \le M(x,y)-m(x,y) \le \max ( \texttt{delta1} , \texttt{delta2} ).
-
-
-
-.. index:: CalcOpticalFlowBM
-
-.. _CalcOpticalFlowBM:
-
-CalcOpticalFlowBM
------------------
-
-`id=0.167052327583 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcOpticalFlowBM>`__
-
-
-.. function:: CalcOpticalFlowBM(prev,curr,blockSize,shiftSize,max_range,usePrevious,velx,vely)-> None
-
- Calculates the optical flow for two images by using the block matching method.
-
-
-
-
-
-
- :param prev: First image, 8-bit, single-channel
-
- :type prev: :class:`CvArr`
-
-
- :param curr: Second image, 8-bit, single-channel
-
- :type curr: :class:`CvArr`
-
-
- :param blockSize: Size of basic blocks that are compared
-
- :type blockSize: :class:`CvSize`
-
-
- :param shiftSize: Block coordinate increments
-
- :type shiftSize: :class:`CvSize`
-
-
- :param max_range: Size of the scanned neighborhood in pixels around the block
-
- :type max_range: :class:`CvSize`
-
-
- :param usePrevious: Uses the previous (input) velocity field
-
- :type usePrevious: int
-
-
- :param velx: Horizontal component of the optical flow of
-
- .. math::
-
- \left \lfloor \frac{\texttt{prev->width} - \texttt{blockSize.width}}{\texttt{shiftSize.width}} \right \rfloor \times \left \lfloor \frac{\texttt{prev->height} - \texttt{blockSize.height}}{\texttt{shiftSize.height}} \right \rfloor
-
- size, 32-bit floating-point, single-channel
-
- :type velx: :class:`CvArr`
-
-
- :param vely: Vertical component of the optical flow of the same size ``velx`` , 32-bit floating-point, single-channel
-
- :type vely: :class:`CvArr`
-
-
-
-The function calculates the optical
-flow for overlapped blocks
-:math:`\texttt{blockSize.width} \times \texttt{blockSize.height}`
-pixels each, thus the velocity
-fields are smaller than the original images. For every block in
-``prev``
-the functions tries to find a similar block in
-``curr``
-in some neighborhood of the original block or shifted by (velx(x0,y0),vely(x0,y0)) block as has been calculated by previous
-function call (if
-``usePrevious=1``
-)
-
-
-.. index:: CalcOpticalFlowHS
-
-.. _CalcOpticalFlowHS:
-
-CalcOpticalFlowHS
------------------
-
-`id=0.932788904949 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcOpticalFlowHS>`__
-
-
-.. function:: CalcOpticalFlowHS(prev,curr,usePrevious,velx,vely,lambda,criteria)-> None
-
- Calculates the optical flow for two images.
-
-
-
-
-
-
- :param prev: First image, 8-bit, single-channel
-
- :type prev: :class:`CvArr`
-
-
- :param curr: Second image, 8-bit, single-channel
-
- :type curr: :class:`CvArr`
-
-
- :param usePrevious: Uses the previous (input) velocity field
-
- :type usePrevious: int
-
-
- :param velx: Horizontal component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
-
- :type velx: :class:`CvArr`
-
-
- :param vely: Vertical component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
-
- :type vely: :class:`CvArr`
-
-
- :param lambda: Lagrangian multiplier
-
- :type lambda: float
-
-
- :param criteria: Criteria of termination of velocity computing
-
- :type criteria: :class:`CvTermCriteria`
-
-
-
-The function computes the flow for every pixel of the first input image using the Horn and Schunck algorithm
-Horn81
-.
-
-
-.. index:: CalcOpticalFlowLK
-
-.. _CalcOpticalFlowLK:
-
-CalcOpticalFlowLK
------------------
-
-`id=0.849649850841 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcOpticalFlowLK>`__
-
-
-.. function:: CalcOpticalFlowLK(prev,curr,winSize,velx,vely)-> None
-
- Calculates the optical flow for two images.
-
-
-
-
-
-
- :param prev: First image, 8-bit, single-channel
-
- :type prev: :class:`CvArr`
-
-
- :param curr: Second image, 8-bit, single-channel
-
- :type curr: :class:`CvArr`
-
-
- :param winSize: Size of the averaging window used for grouping pixels
-
- :type winSize: :class:`CvSize`
-
-
- :param velx: Horizontal component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
-
- :type velx: :class:`CvArr`
-
-
- :param vely: Vertical component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
-
- :type vely: :class:`CvArr`
-
-
-
-The function computes the flow for every pixel of the first input image using the Lucas and Kanade algorithm
-Lucas81
-.
-
-
-.. index:: CalcOpticalFlowPyrLK
-
-.. _CalcOpticalFlowPyrLK:
-
-CalcOpticalFlowPyrLK
---------------------
-
-`id=0.333066207955 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CalcOpticalFlowPyrLK>`__
-
-
-.. function:: CalcOpticalFlowPyrLK( prev, curr, prevPyr, currPyr, prevFeatures, winSize, level, criteria, flags, guesses = None) -> (currFeatures, status, track_error)
-
- Calculates the optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
-
-
-
-
-
-
- :param prev: First frame, at time ``t``
-
- :type prev: :class:`CvArr`
-
-
- :param curr: Second frame, at time ``t + dt``
-
- :type curr: :class:`CvArr`
-
-
- :param prevPyr: Buffer for the pyramid for the first frame. If the pointer is not ``NULL`` , the buffer must have a sufficient size to store the pyramid from level ``1`` to level ``level`` ; the total size of ``(image_width+8)*image_height/3`` bytes is sufficient
-
- :type prevPyr: :class:`CvArr`
-
-
- :param currPyr: Similar to ``prevPyr`` , used for the second frame
-
- :type currPyr: :class:`CvArr`
-
-
- :param prevFeatures: Array of points for which the flow needs to be found
-
- :type prevFeatures: :class:`CvPoint2D32f`
-
-
- :param currFeatures: Array of 2D points containing the calculated new positions of the input features in the second image
-
- :type currFeatures: :class:`CvPoint2D32f`
-
-
- :param winSize: Size of the search window of each pyramid level
-
- :type winSize: :class:`CvSize`
-
-
- :param level: Maximal pyramid level number. If ``0`` , pyramids are not used (single level), if ``1`` , two levels are used, etc
-
- :type level: int
-
-
- :param status: Array. Every element of the array is set to ``1`` if the flow for the corresponding feature has been found, ``0`` otherwise
-
- :type status: str
-
-
- :param track_error: Array of double numbers containing the difference between patches around the original and moved points. Optional parameter; can be ``NULL``
-
- :type track_error: float
-
-
- :param criteria: Specifies when the iteration process of finding the flow for each point on each pyramid level should be stopped
-
- :type criteria: :class:`CvTermCriteria`
-
-
- :param flags: Miscellaneous flags:
-
-
- * **CV_LKFLOWPyr_A_READY** pyramid for the first frame is precalculated before the call
-
-
- * **CV_LKFLOWPyr_B_READY** pyramid for the second frame is precalculated before the call
-
-
-
-
- :type flags: int
-
-
- :param guesses: optional array of estimated coordinates of features in second frame, with same length as ``prevFeatures``
-
- :type guesses: :class:`CvPoint2D32f`
-
-
-
-The function implements the sparse iterative version of the Lucas-Kanade optical flow in pyramids
-Bouguet00
-. It calculates the coordinates of the feature points on the current video
-frame given their coordinates on the previous frame. The function finds
-the coordinates with sub-pixel accuracy.
-
-Both parameters
-``prevPyr``
-and
-``currPyr``
-comply with the
-following rules: if the image pointer is 0, the function allocates the
-buffer internally, calculates the pyramid, and releases the buffer after
-processing. Otherwise, the function calculates the pyramid and stores
-it in the buffer unless the flag
-``CV_LKFLOWPyr_A[B]_READY``
-is set. The image should be large enough to fit the Gaussian pyramid
-data. After the function call both pyramids are calculated and the
-readiness flag for the corresponding image can be set in the next call
-(i.e., typically, for all the image pairs except the very first one
-``CV_LKFLOWPyr_A_READY``
-is set).
-
-
-
-.. index:: CamShift
-
-.. _CamShift:
-
-CamShift
---------
-
-`id=0.228709757227 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CamShift>`__
-
-
-.. function:: CamShift(prob_image,window,criteria)-> (int, comp, box)
-
- Finds the object center, size, and orientation.
-
-
-
-
-
-
- :param prob_image: Back projection of object histogram (see :ref:`CalcBackProject` )
-
- :type prob_image: :class:`CvArr`
-
-
- :param window: Initial search window
-
- :type window: :class:`CvRect`
-
-
- :param criteria: Criteria applied to determine when the window search should be finished
-
- :type criteria: :class:`CvTermCriteria`
-
-
- :param comp: Resultant structure that contains the converged search window coordinates ( ``comp->rect`` field) and the sum of all of the pixels inside the window ( ``comp->area`` field)
-
- :type comp: :class:`CvConnectedComp`
-
-
- :param box: Circumscribed box for the object.
-
- :type box: :class:`CvBox2D`
-
-
-
-The function implements the CAMSHIFT object tracking algrorithm
-Bradski98
-.
-First, it finds an object center using
-:ref:`MeanShift`
-and, after that, calculates the object size and orientation. The function returns number of iterations made within
-:ref:`MeanShift`
-.
-
-The
-``CamShiftTracker``
-class declared in cv.hpp implements the color object tracker that uses the function.
-
-
-.. index:: CvKalman
-
-.. _CvKalman:
-
-CvKalman
---------
-
-`id=0.911390647458 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CvKalman>`__
-
-.. class:: CvKalman
-
-
-
-Kalman filter state.
-
-
-
-
-
- .. attribute:: MP
-
-
-
- number of measurement vector dimensions
-
-
-
- .. attribute:: DP
-
-
-
- number of state vector dimensions
-
-
-
- .. attribute:: CP
-
-
-
- number of control vector dimensions
-
-
-
- .. attribute:: state_pre
-
-
-
- predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
-
-
-
- .. attribute:: state_post
-
-
-
- corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
-
-
-
- .. attribute:: transition_matrix
-
-
-
- state transition matrix (A)
-
-
-
- .. attribute:: control_matrix
-
-
-
- control matrix (B) (it is not used if there is no control)
-
-
-
- .. attribute:: measurement_matrix
-
-
-
- measurement matrix (H)
-
-
-
- .. attribute:: process_noise_cov
-
-
-
- process noise covariance matrix (Q)
-
-
-
- .. attribute:: measurement_noise_cov
-
-
-
- measurement noise covariance matrix (R)
-
-
-
- .. attribute:: error_cov_pre
-
-
-
- priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q
-
-
-
- .. attribute:: gain
-
-
-
- Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
-
-
-
- .. attribute:: error_cov_post
-
-
-
- posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
-
-
-
-The structure
-``CvKalman``
-is used to keep the Kalman filter
-state. It is created by the
-:ref:`CreateKalman`
-function, updated
-by the
-:ref:`KalmanPredict`
-and
-:ref:`KalmanCorrect`
-functions
-. Normally, the
-structure is used for the standard Kalman filter (notation and the
-formulas below are borrowed from the excellent Kalman tutorial
-Welch95
-)
-
-
-
-.. math::
-
- \begin{array}{l} x_k=A \cdot x_{k-1}+B \cdot u_k+w_k \\ z_k=H \cdot x_k+v_k \end{array}
-
-
-where:
-
-
-
-.. math::
-
- \begin{array}{l l} x_k \; (x_{k-1})& \text{state of the system at the moment \emph{k} (\emph{k-1})} \\ z_k & \text{measurement of the system state at the moment \emph{k}} \\ u_k & \text{external control applied at the moment \emph{k}} \end{array}
-
-
-:math:`w_k`
-and
-:math:`v_k`
-are normally-distributed process and measurement noise, respectively:
-
-
-
-.. math::
-
- \begin{array}{l} p(w) \sim N(0,Q) \\ p(v) \sim N(0,R) \end{array}
-
-
-that is,
-
-:math:`Q`
-process noise covariance matrix, constant or variable,
-
-:math:`R`
-measurement noise covariance matrix, constant or variable
-
-In the case of the standard Kalman filter, all of the matrices: A, B, H, Q and R are initialized once after the
-:ref:`CvKalman`
-structure is allocated via
-:ref:`CreateKalman`
-. However, the same structure and the same functions may be used to simulate the extended Kalman filter by linearizing the extended Kalman filter equation in the current system state neighborhood, in this case A, B, H (and, probably, Q and R) should be updated on every step.
-
-
-.. index:: CreateKalman
-
-.. _CreateKalman:
-
-CreateKalman
-------------
-
-`id=0.636220879554 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/CreateKalman>`__
-
-
-.. function:: CreateKalman(dynam_params, measure_params, control_params=0) -> CvKalman
-
- Allocates the Kalman filter structure.
-
-
-
-
-
-
- :param dynam_params: dimensionality of the state vector
-
- :type dynam_params: int
-
-
- :param measure_params: dimensionality of the measurement vector
-
- :type measure_params: int
-
-
- :param control_params: dimensionality of the control vector
-
- :type control_params: int
-
-
-
-The function allocates
-:ref:`CvKalman`
-and all its matrices and initializes them somehow.
-
-
-
-.. index:: KalmanCorrect
-
-.. _KalmanCorrect:
-
-KalmanCorrect
--------------
-
-`id=0.175175296579 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/KalmanCorrect>`__
-
-
-.. function:: KalmanCorrect(kalman, measurement) -> cvmat
-
- Adjusts the model state.
-
-
-
-
-
-
- :param kalman: Kalman filter object returned by :ref:`CreateKalman`
-
- :type kalman: :class:`CvKalman`
-
-
- :param measurement: CvMat containing the measurement vector
-
- :type measurement: :class:`CvMat`
-
-
-
-The function adjusts the stochastic model state on the basis of the given measurement of the model state:
-
-
-
-.. math::
-
- \begin{array}{l} K_k=P'_k \cdot H^T \cdot (H \cdot P'_k \cdot H^T+R)^{-1} \\ x_k=x'_k+K_k \cdot (z_k-H \cdot x'_k) \\ P_k=(I-K_k \cdot H) \cdot P'_k \end{array}
-
-
-where
-
-
-.. table::
-
- =========== ===============================================
- :math:`z_k` given measurement ( ``mesurement`` parameter) \
- =========== ===============================================
- :math:`K_k` Kalman "gain" matrix. \
- =========== ===============================================
-
-The function stores the adjusted state at
-``kalman->state_post``
-and returns it on output.
-
-
-.. index:: KalmanPredict
-
-.. _KalmanPredict:
-
-KalmanPredict
--------------
-
-`id=0.930945319496 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/KalmanPredict>`__
-
-
-.. function:: KalmanPredict(kalman, control=None) -> cvmat
-
- Estimates the subsequent model state.
-
-
-
-
-
-
- :param kalman: Kalman filter object returned by :ref:`CreateKalman`
-
- :type kalman: :class:`CvKalman`
-
-
- :param control: Control vector :math:`u_k` , should be NULL iff there is no external control ( ``control_params`` =0)
-
- :type control: :class:`CvMat`
-
-
-
-The function estimates the subsequent stochastic model state by its current state and stores it at
-``kalman->state_pre``
-:
-
-
-
-.. math::
-
- \begin{array}{l} x'_k=A x_{k-1} + B u_k \\ P'_k=A P_{k-1} A^T + Q \end{array}
-
-
-where
-
-
-.. table::
-
- =============== ====================================================================================================================================================================
- :math:`x'_k` is predicted state ``kalman->state_pre`` , \
- =============== ====================================================================================================================================================================
- :math:`x_{k-1}` is corrected state on the previous step ``kalman->state_post`` (should be initialized somehow in the beginning, zero vector by default), \
- :math:`u_k` is external control ( ``control`` parameter), \
- :math:`P'_k` is priori error covariance matrix ``kalman->error_cov_pre`` \
- :math:`P_{k-1}` is posteriori error covariance matrix on the previous step ``kalman->error_cov_post`` (should be initialized somehow in the beginning, identity matrix by default),
- =============== ====================================================================================================================================================================
-
-The function returns the estimated state.
-
-
-KalmanUpdateByMeasurement
--------------------------
-
-
-Synonym for
-:ref:`KalmanCorrect`
-
-KalmanUpdateByTime
-------------------
-
-
-Synonym for
-:ref:`KalmanPredict`
-
-.. index:: MeanShift
-
-.. _MeanShift:
-
-MeanShift
----------
-
-`id=0.555115149553 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/MeanShift>`__
-
-
-.. function:: MeanShift(prob_image,window,criteria)-> comp
-
- Finds the object center on back projection.
-
-
-
-
-
-
- :param prob_image: Back projection of the object histogram (see :ref:`CalcBackProject` )
-
- :type prob_image: :class:`CvArr`
-
-
- :param window: Initial search window
-
- :type window: :class:`CvRect`
-
-
- :param criteria: Criteria applied to determine when the window search should be finished
-
- :type criteria: :class:`CvTermCriteria`
-
-
- :param comp: Resultant structure that contains the converged search window coordinates ( ``comp->rect`` field) and the sum of all of the pixels inside the window ( ``comp->area`` field)
-
- :type comp: :class:`CvConnectedComp`
-
-
-
-The function iterates to find the object center
-given its back projection and initial position of search window. The
-iterations are made until the search window center moves by less than
-the given value and/or until the function has done the maximum number
-of iterations. The function returns the number of iterations made.
-
-
-.. index:: SegmentMotion
-
-.. _SegmentMotion:
-
-SegmentMotion
--------------
-
-`id=0.698315173881 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/SegmentMotion>`__
-
-
-.. function:: SegmentMotion(mhi,seg_mask,storage,timestamp,seg_thresh)-> None
-
- Segments a whole motion into separate moving parts.
-
-
-
-
-
-
- :param mhi: Motion history image
-
- :type mhi: :class:`CvArr`
-
-
- :param seg_mask: Image where the mask found should be stored, single-channel, 32-bit floating-point
-
- :type seg_mask: :class:`CvArr`
-
-
- :param storage: Memory storage that will contain a sequence of motion connected components
-
- :type storage: :class:`CvMemStorage`
-
-
- :param timestamp: Current time in milliseconds or other units
-
- :type timestamp: float
-
-
- :param seg_thresh: Segmentation threshold; recommended to be equal to the interval between motion history "steps" or greater
-
- :type seg_thresh: float
-
-
-
-The function finds all of the motion segments and
-marks them in
-``seg_mask``
-with individual values (1,2,...). It
-also returns a sequence of
-:ref:`CvConnectedComp`
-structures, one for each motion component. After that the
-motion direction for every component can be calculated with
-:ref:`CalcGlobalOrientation`
-using the extracted mask of the particular
-component
-:ref:`Cmp`
-.
-
-
-.. index:: SnakeImage
-
-.. _SnakeImage:
-
-SnakeImage
-----------
-
-`id=0.218492276516 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/SnakeImage>`__
-
-
-.. function:: SnakeImage(image,points,alpha,beta,gamma,win,criteria,calc_gradient=1)-> new_points
-
- Changes the contour position to minimize its energy.
-
-
-
-
-
-
- :param image: The source image or external energy field
-
- :type image: :class:`IplImage`
-
-
- :param points: Contour points (snake)
-
- :type points: :class:`CvPoints`
-
-
- :param alpha: Weight[s] of continuity energy, single float or
- a list of floats, one for each contour point
-
- :type alpha: sequence of float
-
-
- :param beta: Weight[s] of curvature energy, similar to ``alpha``
-
- :type beta: sequence of float
-
-
- :param gamma: Weight[s] of image energy, similar to ``alpha``
-
- :type gamma: sequence of float
-
-
- :param win: Size of neighborhood of every point used to search the minimum, both ``win.width`` and ``win.height`` must be odd
-
- :type win: :class:`CvSize`
-
-
- :param criteria: Termination criteria
-
- :type criteria: :class:`CvTermCriteria`
-
-
- :param calc_gradient: Gradient flag; if not 0, the function calculates the gradient magnitude for every image pixel and consideres it as the energy field, otherwise the input image itself is considered
-
- :type calc_gradient: int
-
-
-
-The function updates the snake in order to minimize its
-total energy that is a sum of internal energy that depends on the contour
-shape (the smoother contour is, the smaller internal energy is) and
-external energy that depends on the energy field and reaches minimum at
-the local energy extremums that correspond to the image edges in the case
-of using an image gradient.
-
-The parameter
-``criteria.epsilon``
-is used to define the minimal
-number of points that must be moved during any iteration to keep the
-iteration process running.
-
-If at some iteration the number of moved points is less
-than
-``criteria.epsilon``
-or the function performed
-``criteria.max_iter``
-iterations, the function terminates.
-
-The function returns the updated list of points.
-
-.. index:: UpdateMotionHistory
-
-.. _UpdateMotionHistory:
-
-UpdateMotionHistory
--------------------
-
-`id=0.316306086975 Comments from the Wiki <http://opencv.willowgarage.com/wiki/documentation/py/video/UpdateMotionHistory>`__
-
-
-.. function:: UpdateMotionHistory(silhouette,mhi,timestamp,duration)-> None
-
- Updates the motion history image by a moving silhouette.
-
-
-
-
-
-
- :param silhouette: Silhouette mask that has non-zero pixels where the motion occurs
-
- :type silhouette: :class:`CvArr`
-
-
- :param mhi: Motion history image, that is updated by the function (single-channel, 32-bit floating-point)
-
- :type mhi: :class:`CvArr`
-
-
- :param timestamp: Current time in milliseconds or other units
-
- :type timestamp: float
-
-
- :param duration: Maximal duration of the motion track in the same units as ``timestamp``
-
- :type duration: float
-
-
-
-The function updates the motion history image as following:
-
-
-
-.. math::
-
- \texttt{mhi} (x,y)= \forkthree{\texttt{timestamp}}{if $\texttt{silhouette}(x,y) \ne 0$}{0}{if $\texttt{silhouette}(x,y) = 0$ and $\texttt{mhi} < (\texttt{timestamp} - \texttt{duration})$}{\texttt{mhi}(x,y)}{otherwise}
-
-
-That is, MHI pixels where motion occurs are set to the current timestamp, while the pixels where motion happened far ago are cleared.
-
projects / profile / ivi / opencv.git / commitdiff