:param objectPoints:In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. The outer vector contains as many elements as the number of the pattern views. If the same calibration pattern is shown in each view and it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns, or even different patterns in different views. Then, the vectors will be different. The points are 3D, but since they are in a pattern coordinate system, then, if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0.
In the old interface all the vectors of object points from different views are concatenated together.
:param imagePoints:In the new interface it is a vector of vectors of the projections of calibration pattern points. ``imagePoints.size()`` and ``objectPoints.size()`` and ``imagePoints[i].size()`` must be equal to ``objectPoints[i].size()`` for each ``i``.
In the old interface all the vectors of object points from different views are concatenated together.
:param pointCounts:In the old interface this is a vector of integers, containing as many elements, as the number of views of the calibration pattern. Each element is the number of points in each view. Usually, all the elements are the same and equal to the number of feature points on the calibration pattern.
:param imageSize:Size of the image used only to initialize the intrinsic camera matrix.
@ -186,7 +186,7 @@ The function returns the final re-projection error.
:ocv:func:`findChessboardCorners`,
:ocv:func:`solvePnP`,
:ocv:func:`initCameraMatrix2D`,
:ocv:func:`initCameraMatrix2D`,
:ocv:func:`stereoCalibrate`,
:ocv:func:`undistort`
@ -201,7 +201,7 @@ Computes useful camera characteristics from the camera matrix.
:param points:Input points. :math:`N \times 1` or :math:`1 \times N` matrix of type ``CV_32FC2`` or ``vector<Point2f>`` .
:param whichImage:Index of the image (1 or 2) that contains the ``points`` .
:param F:Fundamental matrix that can be estimated using :ocv:func:`findFundamentalMat` or :ocv:func:`stereoRectify` .
:param lines:Output vector of the epipolar lines corresponding to the points in the other image. Each line :math:`ax + by + c=0` is encoded by 3 numbers :math:`(a, b, c)` .
For every point in one of the two images of a stereo pair, the function finds the equation of the
The function converts 2D or 3D points from/to homogeneous coordinates by calling either :ocv:func:`convertPointsToHomogeneous` or :ocv:func:`convertPointsFromHomogeneous`.
The function converts 2D or 3D points from/to homogeneous coordinates by calling either :ocv:func:`convertPointsToHomogeneous` or :ocv:func:`convertPointsFromHomogeneous`.
..note:: The function is obsolete. Use one of the previous two functions instead.
@ -429,7 +429,7 @@ Finds the positions of internal corners of the chessboard.
:param patternSize:Number of inner corners per a chessboard row and column ``( patternSize = cvSize(points_per_row,points_per_colum) = cvSize(columns,rows) )``.
:param corners:Output array of detected corners.
:param corners:Output array of detected corners.
:param flags:Various operation flags that can be zero or a combination of the following values:
@ -485,14 +485,14 @@ Finds the centers in the grid of circles.
:param patternSize:Number of circles per a grid row and column ``( patternSize = Size(points_per_row, points_per_colum) )`` .
:param centers:Output array of detected centers.
:param centers:Output array of detected centers.
:param flags:Various operation flags that can be one of the following values:
* **CALIB_CB_SYMMETRIC_GRID** Use symmetric pattern of circles.
* **CALIB_CB_ASYMMETRIC_GRID** Use asymmetric pattern of circles.
* **CALIB_CB_CLUSTERING** Use a special algorithm for grid detection. It is more robust to perspective distortions but much more sensitive to background clutter.
:param blobDetector:FeatureDetector that finds blobs like dark circles on light background
@ -527,7 +527,7 @@ Finds an object pose from 3D-2D point correspondences.
:param objectPoints:Array of object points in the object coordinate space, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points. ``vector<Point3f>`` can be also passed here.
@ -535,7 +535,7 @@ Finds an object pose from 3D-2D point correspondences.
:param imagePoints:Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. ``vector<Point2f>`` can be also passed here.
:param cameraMatrix:Input camera matrix :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}` .
:param distCoeffs:Input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5, or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param rvec:Output rotation vector (see :ocv:func:`Rodrigues` ) that, together with ``tvec`` , brings points from the model coordinate system to the camera coordinate system.
@ -545,11 +545,11 @@ Finds an object pose from 3D-2D point correspondences.
:param useExtrinsicGuess:If true (1), the function uses the provided ``rvec`` and ``tvec`` values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them.
:param flags:Method for solving a PnP problem:
* **CV_ITERATIVE** Iterative method is based on Levenberg-Marquardt optimization. In this case the function finds such a pose that minimizes reprojection error, that is the sum of squared distances between the observed projections ``imagePoints`` and the projected (using :ocv:func:`projectPoints` ) ``objectPoints`` .
* **CV_P3P** Method is based on the paper of X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang "Complete Solution Classification for the Perspective-Three-Point Problem". In this case the function requires exactly four object and image points.
* **CV_EPNP** Method has been introduced by F.Moreno-Noguer, V.Lepetit and P.Fua in the paper "EPnP: Efficient Perspective-n-Point Camera Pose Estimation".
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.
@ -567,7 +567,7 @@ Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
:param imagePoints:Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. ``vector<Point2f>`` can be also passed here.
:param cameraMatrix:Input camera matrix :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}` .
:param distCoeffs:Input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5, or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param rvec:Output rotation vector (see :ocv:func:`Rodrigues` ) that, together with ``tvec`` , brings points from the model coordinate system to the camera coordinate system.
@ -576,12 +576,12 @@ Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
:param useExtrinsicGuess:If true (1), the function uses the provided ``rvec`` and ``tvec`` values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them.
:param iterationsCount:Number of iterations.
:param iterationsCount:Number of iterations.
:param reprojectionError:Inlier threshold value used by the RANSAC procedure. The parameter value is the maximum allowed distance between the observed and computed point projections to consider it an inlier.
:param minInliersCount:Number of inliers. If the algorithm at some stage finds more inliers than ``minInliersCount`` , it finishes.
:param inliers:Output vector that contains indices of inliers in ``objectPoints`` and ``imagePoints`` .
:param flags:Method for solving a PnP problem (see :ocv:func:`solvePnP` ).
@ -605,14 +605,14 @@ Calculates a fundamental matrix from the corresponding points in two images.
:param points1:Array of ``N`` points from the first image. The point coordinates should be floating-point (single or double precision).
:param points2:Array of the second image points of the same size and format as ``points1`` .
:param method:Method for computing a 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`
:param param1:Parameter used for RANSAC. It is the maximum distance from a point to an 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.
:param param2:Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
@ -772,15 +772,15 @@ Filters off small noise blobs (speckles) in the disparity map
:param img:The input 16-bit signed disparity image
:param newVal:The disparity value used to paint-off the speckles
:param maxSpeckleSize:The maximum speckle size to consider it a speckle. Larger blobs are not affected by the algorithm
:param maxDiff:Maximum difference between neighbor disparity pixels to put them into the same blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point disparity map, where disparity values are multiplied by 16, this scale factor should be taken into account when specifying this parameter value.
:param buf:The optional temporary buffer to avoid memory allocation within the function.
getOptimalNewCameraMatrix
-----------------------------
@ -809,7 +809,7 @@ Returns the new camera matrix based on the free scaling parameter.
:param validPixROI:Optional output rectangle that outlines all-good-pixels region in the undistorted image. See ``roi1, roi2`` description in :ocv:func:`stereoRectify` .
:param centerPrincipalPoint:Optional flag that indicates whether in the new camera matrix the principal point should be at the image center or not. By default, the principal point is chosen to best fit a subset of the source image (determined by ``alpha``) to the corrected image.
The function computes and returns
the optimal new camera matrix based on the free scaling parameter. By varying this parameter, you 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 is likely to 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 ``newImageSize`` should be passed to
:ocv:func:`initUndistortRectifyMap` to produce the maps for
@ -830,15 +830,15 @@ Finds an initial camera matrix from 3D-2D point correspondences.
:param objectPoints:Vector of vectors of the calibration pattern points in the calibration pattern coordinate space. In the old interface all the per-view vectors are concatenated. See :ocv:func:`calibrateCamera` for details.
:param imagePoints:Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated.
:param imagePoints:Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated.
:param pointCounts:The integer vector of point counters for each view.
:param imageSize:Image size in pixels used to initialize the principal point.
:param aspectRatio:If it is zero or negative, both :math:`f_x` and :math:`f_y` are estimated independently. Otherwise, :math:`f_x = f_y * \texttt{aspectRatio}` .
The function estimates and returns an initial camera matrix for the camera calibration process.
Currently, the function only supports planar calibration patterns, which are patterns where each object point has z-coordinate =0.
@ -857,7 +857,7 @@ Computes partial derivatives of the matrix product for each multiplied matrix.
The function computes partial derivatives of the elements of the matrix product
@ -880,11 +880,11 @@ Projects 3D points to an image plane.
:param objectPoints:Array of object points, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel (or ``vector<Point3f>`` ), where N is the number of points in the view.
:param rvec:Rotation vector. See :ocv:func:`Rodrigues` for details.
:param distCoeffs:Input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5, or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param imagePoints:Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or ``vector<Point2f>`` .
@ -900,8 +900,8 @@ 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
:ocv:func:`calibrateCamera`,
:ocv:func:`solvePnP`, and
:ocv:func:`calibrateCamera`,
:ocv:func:`solvePnP`, and
:ocv:func:`stereoCalibrate` . The
function itself can also be used to compute a re-projection error given the
current intrinsic and extrinsic parameters.
@ -927,11 +927,11 @@ Reprojects a disparity image to 3D space.
:param _3dImage:Output 3-channel floating-point image of the same size as ``disparity`` . Each element of ``_3dImage(x,y)`` contains 3D coordinates of the point ``(x,y)`` computed from the disparity map.
:param Q::math:`4 \times 4` perspective transformation matrix that can be obtained with :ocv:func:`stereoRectify`.
:param handleMissingValues:Indicates, whether the function should handle missing values (i.e. points where the disparity was not computed). If ``handleMissingValues=true``, then pixels with the minimal disparity that corresponds to the outliers (see :ocv:funcx:`StereoBM::operator()` ) are transformed to 3D points with a very large Z value (currently set to 10000).
:param ddepth:The optional output array depth. If it is ``-1``, the output image will have ``CV_32F`` depth. ``ddepth`` can also be set to ``CV_16S``, ``CV_32S`` or ``CV_32F``.
The function transforms a single-channel disparity map to a 3-channel image representing a 3D surface. That is, for each pixel ``(x,y)`` andthe corresponding disparity ``d=disparity(x,y)`` , it computes:
..math::
@ -1044,7 +1044,7 @@ Class for computing stereo correspondence using the block matching algorithm. ::
};
The class is a C++ wrapper for the associated functions. In particular, :ocv:funcx:`StereoBM::operator()` is the wrapper for
:param preset:specifies the whole set of algorithm parameters, one of:
* BASIC_PRESET - parameters suitable for general cameras
* FISH_EYE_PRESET - parameters suitable for wide-angle cameras
* BASIC_PRESET - parameters suitable for general cameras
* FISH_EYE_PRESET - parameters suitable for wide-angle cameras
* NARROW_PRESET - parameters suitable for narrow-angle cameras
After constructing the class, you can override any parameters set by the preset.
:param ndisparities:the disparity search range. For each pixel algorithm will find the best disparity from 0 (default minimum disparity) to ``ndisparities``. The search range can then be shifted by changing the minimum disparity.
:param SADWindowSize:the linear size of the blocks compared by the algorithm. The size should be odd (as the block is centered at the current pixel). Larger block size implies smoother, though less accurate disparity map. Smaller block size gives more detailed disparity map, but there is higher chance for algorithm to find a wrong correspondence.
The constructors initialize ``StereoBM`` state. You can then call ``StereoBM::operator()`` to compute disparity for a specific stereo pair.
..note:: In the C API you need to deallocate ``CvStereoBM`` state when it is not needed anymore using ``cvReleaseStereoBMState(&stereobm)``.
@ -1093,9 +1093,9 @@ Computes disparity using the BM algorithm for a rectified stereo pair.
:param right:Right image of the same size and the same type as the left one.
:param disp:Output disparity map. It has the same size as the input images. When ``disptype==CV_16S``, the map is a 16-bit signed single-channel image, containing disparity values scaled by 16. To get the true disparity values from such fixed-point representation, you will need to divide each ``disp`` element by 16. If ``disptype==CV_32F``, the disparity map will already contain the real disparity values on output.
:param disptype:Type of the output disparity map, ``CV_16S`` (default) or ``CV_32F``.
:param state:The pre-initialized ``CvStereoBMState`` structure in the case of the old API.
The method executes the BM algorithm on a rectified stereo pair. See the ``stereo_match.cpp`` OpenCV sample on how to prepare images and call the method. Note that the method is not constant, thus you should not use the same ``StereoBM`` instance from within different threads simultaneously.
@ -1165,7 +1165,7 @@ StereoSGBM::StereoSGBM
:param SADWindowSize:Matched block size. It must be an odd number ``>=1`` . Normally, it should be somewhere in the ``3..11`` range.
:param P1:The first parameter controlling the disparity smoothness. See below.
:param P2:The second parameter controlling the disparity smoothness. The larger the values are, the smoother the disparity is. ``P1`` is the penalty on the disparity change by plus or minus 1 between neighbor pixels. ``P2`` is the penalty on the disparity change by more than 1 between neighbor pixels. The algorithm requires ``P2 > P1`` . See ``stereo_match.cpp`` sample where some reasonably good ``P1`` and ``P2`` values are shown (like ``8*number_of_image_channels*SADWindowSize*SADWindowSize`` and ``32*number_of_image_channels*SADWindowSize*SADWindowSize`` , respectively).
:param disp12MaxDiff:Maximum allowed difference (in integer pixel units) in the left-right disparity check. Set it to a non-positive value to disable the check.
@ -1199,7 +1199,7 @@ StereoSGBM::operator ()
:param disp:Output disparity map. It is a 16-bit signed single-channel image of the same size as the input image. It contains disparity values scaled by 16. So, to get the floating-point disparity map, you need to divide each ``disp`` element by 16.
The method executes the SGBM algorithm on a rectified stereo pair. See ``stereo_match.cpp`` OpenCV sample on how to prepare images and call the method.
The method executes the SGBM algorithm on a rectified stereo pair. See ``stereo_match.cpp`` OpenCV sample on how to prepare images and call the method.
..note:: The method is not constant, so you should not use the same ``StereoSGBM`` instance from different threads simultaneously.
@ -1214,27 +1214,27 @@ Class for computing stereo correspondence using the variational matching algorit
@ -1242,9 +1242,9 @@ Class for computing stereo correspondence using the variational matching algorit
The class implements the modified S. G. Kosov algorithm [Publication] that differs from the original one as follows:
* The automatic initialization of method's parameters is added.
* The method of Smart Iteration Distribution (SID) is implemented.
* The support of Multi-Level Adaptation Technique (MLAT) is not included.
* The method of dynamic adaptation of method's parameters is not included.
@ -1259,39 +1259,39 @@ StereoVar::StereoVar
The constructor
:param levels:The number of pyramid layers, including the initial image. levels=1 means that no extra layers are created and only the original images are used. This parameter is ignored if flag USE_AUTO_PARAMS is set.
:param pyrScale:Specifies the image scale (<1) to build the pyramids for each image. pyrScale=0.5 means the classical pyramid, where each next layer is twice smaller than the previous. (This parameter is ignored if flag USE_AUTO_PARAMS is set).
:param nIt:The number of iterations the algorithm does at each pyramid level. (If the flag USE_SMART_ID is set, the number of iterations will be redistributed in such a way, that more iterations will be done on more coarser levels.)
:param minDisp:Minimum possible disparity value. Could be negative in case the left and right input images change places.
:param maxDisp:Maximum possible disparity value.
:param maxDisp:Maximum possible disparity value.
:param poly_n:Size of the pixel neighbourhood used to find polynomial expansion in each pixel. The larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field. Typically, poly_n = 3, 5 or 7
:param poly_sigma:Standard deviation of the Gaussian that is used to smooth derivatives that are used as a basis for the polynomial expansion. For poly_n=5 you can set poly_sigma=1.1 , for poly_n=7 a good value would be poly_sigma=1.5
:param fi:The smoothness parameter, ot the weight coefficient for the smoothness term.
:param lambda:The threshold parameter for edge-preserving smoothness. (This parameter is ignored if PENALIZATION_CHARBONNIER or PENALIZATION_PERONA_MALIK is used.)
:param penalization:Possible values: PENALIZATION_TICHONOV - linear smoothness; PENALIZATION_CHARBONNIER - non-linear edge preserving smoothness; PENALIZATION_PERONA_MALIK - non-linear edge-enhancing smoothness. (This parameter is ignored if flag USE_AUTO_PARAMS is set).
:param cycle:Type of the multigrid cycle. Possible values: CYCLE_O and CYCLE_V for null- and v-cycles respectively. (This parameter is ignored if flag USE_AUTO_PARAMS is set).
:param flags:The operation flags; can be a combination of the following:
* USE_INITIAL_DISPARITY: Use the input flow as the initial flow approximation.
* USE_EQUALIZE_HIST: Use the histogram equalization in the pre-processing phase.
* USE_SMART_ID: Use the smart iteration distribution (SID).
* USE_AUTO_PARAMS: Allow the method to initialize the main parameters.
* USE_MEDIAN_FILTERING: Use the median filer of the solution in the post processing phase.
The first constructor initializes ``StereoVar`` with all the default parameters. So, you only have to set ``StereoVar::maxDisp`` and / or ``StereoVar::minDisp`` at minimum. The second constructor enables you to set each parameter to a custom value.
@ -1307,9 +1307,9 @@ StereoVar::operator ()
:param right:Right image of the same size and the same type as the left one.
:param disp:Output disparity map. It is a 8-bit signed single-channel image of the same size as the input image.
:param disp:Output disparity map. It is a 8-bit signed single-channel image of the same size as the input image.
The method executes the variational algorithm on a rectified stereo pair. See ``stereo_match.cpp`` OpenCV sample on how to prepare images and call the method.
The method executes the variational algorithm on a rectified stereo pair. See ``stereo_match.cpp`` OpenCV sample on how to prepare images and call the method.
**Note**:
@ -1367,7 +1367,7 @@ Calibrates the stereo camera.
* **CV_CALIB_FIX_ASPECT_RATIO** Optimize :math:`f^{(j)}_y` . Fix the ratio :math:`f^{(j)}_x/f^{(j)}_y` .
* **CV_CALIB_SAME_FOCAL_LENGTH** Enforce :math:`f^{(0)}_x=f^{(1)}_x` and :math:`f^{(0)}_y=f^{(1)}_y` .
* **CV_CALIB_ZERO_TANGENT_DIST** Set tangential distortion coefficients for each camera to zeros and fix 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.
@ -1417,11 +1417,11 @@ Computes rectification transforms for each head of a calibrated stereo camera.
@ -1447,7 +1447,7 @@ Computes rectification transforms for each head of a calibrated stereo camera.
:param newImageSize:New image resolution after rectification. The same size should be passed to :ocv:func:`initUndistortRectifyMap` (see the ``stereo_calib.cpp`` sample in OpenCV samples directory). When (0,0) is passed (default), it is set to the original ``imageSize`` . Setting it to larger value can help you preserve details in the original image, especially when there is a big radial distortion.
:param roi1:
:param roi2:Optional output rectangles inside the rectified images where all the pixels are valid. If ``alpha=0`` , the ROIs cover the whole images. Otherwise, they are likely to 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, this makes all the epipolar lines parallel and thus simplifies the dense stereo correspondence problem. The function takes the matrices computed by
@ -1506,7 +1506,7 @@ Computes a rectification transform for an uncalibrated stereo camera.
:param points1:Array of feature points in the first image.
:param points2:The corresponding points in the second image. The same formats as in :ocv:func:`findFundamentalMat` are supported.
:param F:Input fundamental matrix. It can be computed from the same set of point pairs using :ocv:func:`findFundamentalMat` .
@ -1514,7 +1514,7 @@ Computes a rectification transform for an uncalibrated stereo camera.
:param imageSize:Size of the image.
:param H1:Output rectification homography matrix for the first image.
:param H2:Output rectification homography matrix for the second image.
:param threshold:Optional threshold used to filter out the outliers. If the parameter is greater than zero, all the point pairs that do not comply with the epipolar geometry (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.
A storage for various OpenCV dynamic data structures, such as ``CvSeq``, ``CvSet`` etc.
..ocv:member:: CvMemBlock* bottom
the first memory block in the double-linked list of blocks
..ocv:member:: CvMemBlock* top
the current partially allocated memory block in the list of blocks
..ocv:member:: CvMemStorage* parent
the parent storage (if any) from which the new memory blocks are borrowed.
..ocv:member:: int free_space
number of free bytes in the ``top`` block
..ocv:member:: int block_size
the total size of the memory blocks
Memory storage is a low-level structure used to store dynamically growing data structures such as sequences, contours, graphs, subdivisions, etc. It is organized as a list of memory blocks of equal size -
Memory storage is a low-level structure used to store dynamically growing data structures such as sequences, contours, graphs, subdivisions, etc. It is organized as a list of memory blocks of equal size -
``bottom`` field is the beginning of the list of blocks and ``top`` is the currently used block, but not necessarily the last block of the list. All blocks between ``bottom`` and ``top``, not including the
latter, are considered fully occupied; all blocks between ``top`` and the last block, not including ``top``, are considered free and ``top`` itself is partly ocupied - ``free_space`` contains the number of free bytes left in the end of ``top``.
A new memory buffer that may be allocated explicitly by :ocv:cfunc:`MemStorageAlloc` function or implicitly by higher-level functions, such as :ocv:cfunc:`SeqPush`, :ocv:cfunc:`GraphAddEdge` etc.
A new memory buffer that may be allocated explicitly by :ocv:cfunc:`MemStorageAlloc` function or implicitly by higher-level functions, such as :ocv:cfunc:`SeqPush`, :ocv:cfunc:`GraphAddEdge` etc.
The buffer is put in the end of already allocated space in the ``top`` memory block, if there is enough free space. After allocation, ``free_space`` is decreased by the size of the allocated buffer plus some padding to keep the proper alignment. When the allocated buffer does not fit into the available portion of
The buffer is put in the end of already allocated space in the ``top`` memory block, if there is enough free space. After allocation, ``free_space`` is decreased by the size of the allocated buffer plus some padding to keep the proper alignment. When the allocated buffer does not fit into the available portion of
``top``, the next storage block from the list is taken as ``top`` and ``free_space`` is reset to the whole block size prior to the allocation.
If there are no more free blocks, a new block is allocated (or borrowed from the parent, see :ocv:cfunc:`CreateChildMemStorage`) and added to the end of list. Thus, the storage behaves as a stack with ``bottom`` indicating bottom of the stack and the pair (``top``, ``free_space``)
indicating top of the stack. The stack top may be saved via :ocv:cfunc:`SaveMemStoragePos`, restored via
indicating top of the stack. The stack top may be saved via :ocv:cfunc:`SaveMemStoragePos`, restored via
:ocv:cfunc:`RestoreMemStoragePos`, or reset via :ocv:cfunc:`ClearMemStorage`.
CvMemBlock
@ -67,37 +67,37 @@ CvSeq
Dynamically growing sequence.
..ocv:member:: int flags
sequence flags, including the sequence signature (CV_SEQ_MAGIC_VAL or CV_SET_MAGIC_VAL), type of the elements and some other information about the sequence.
..ocv:member:: int header_size
size of the sequence header. It should be sizeof(CvSeq) at minimum. See :ocv:cfunc:`CreateSeq`.
..ocv:member:: CvSeq* h_prev
..ocv:member:: CvSeq* h_next
..ocv:member:: CvSeq* v_prev
..ocv:member:: CvSeq* v_next
pointers to another sequences in a sequence tree. Sequence trees are used to store hierarchical contour structures, retrieved by :ocv:cfunc:`FindContours`
..ocv:member:: int total
the number of sequence elements
..ocv:member:: int elem_size
size of each sequence element in bytes
..ocv:member:: CvMemStorage* storage
memory storage where the sequence resides. It can be a NULL pointer.
..ocv:member:: CvSeqBlock* first
pointer to the first data block
The structure ``CvSeq`` is a base for all of OpenCV dynamic data structures.
The structure ``CvSeq`` is a base for all of OpenCV dynamic data structures.
There are two types of sequences - dense and sparse. The base type for dense
sequences is :ocv:struct:`CvSeq` and such sequences are used to represent
growable 1d arrays - vectors, stacks, queues, and deques. They have no gaps
@ -115,13 +115,13 @@ CvSlice
A sequence slice. In C++ interface the class :ocv:class:`Range` should be used instead.
..ocv:member:: int start_index
inclusive start index of the sequence slice
..ocv:member:: int end_index
exclusive end index of the sequence slice
There are helper functions to construct the slice and to compute its length:
..ocv:cfunction:: CvSlice cvSlice( int start, int end )
@ -165,7 +165,7 @@ CvGraph
-------
..ocv:struct:: CvGraph
The structure ``CvGraph`` is a base for graphs used in OpenCV 1.x. It inherits from
The structure ``CvGraph`` is a base for graphs used in OpenCV 1.x. It inherits from
:ocv:struct:`CvSet`, that is, it is considered as a set of vertices. Besides, it contains another set as a member, a set of graph edges. Graphs in OpenCV are represented using adjacency lists format.
@ -324,7 +324,7 @@ CreateGraphScanner
Creates structure for depth-first graph traversal.
..ocv:cfunction:: CvGraphScanner* cvCreateGraphScanner( CvGraph* graph, CvGraphVtx* vtx=NULL, int mask=CV_GRAPH_ALL_ITEMS )
:param graph:Graph
@ -332,23 +332,23 @@ Creates structure for depth-first graph traversal.
:param mask:Event mask indicating which events are of interest to the user (where :ocv:cfunc:`NextGraphItem` function returns control to the user) It can be ``CV_GRAPH_ALL_ITEMS`` (all events are of interest) or a combination of the following flags:
* **CV_GRAPH_VERTEX** stop at the graph vertices visited for the first time
* **CV_GRAPH_TREE_EDGE** stop at tree edges ( ``tree edge`` is the edge connecting the last visited vertex and the vertex to be visited next)
* **CV_GRAPH_BACK_EDGE** stop at back edges ( ``back edge`` is an edge connecting the last visited vertex with some of its ancestors in the search tree)
* **CV_GRAPH_FORWARD_EDGE** stop at forward edges ( ``forward edge`` is an edge conecting the last visited vertex with some of its descendants in the search tree. The forward edges are only possible during oriented graph traversal)
* **CV_GRAPH_CROSS_EDGE** stop at cross edges ( ``cross edge`` is an edge connecting different search trees or branches of the same tree. The ``cross edges`` are only possible during oriented graph traversal)
* **CV_GRAPH_ANY_EDGE** stop at any edge ( ``tree, back, forward`` , and ``cross edges`` )
* **CV_GRAPH_NEW_TREE** stop in the beginning of every new search tree. When the traversal procedure visits all vertices and edges reachable from the initial vertex (the visited vertices together with tree edges make up a tree), it searches for some unvisited vertex in the graph and resumes the traversal process from that vertex. Before starting a new tree (including the very first tree when ``cvNextGraphItem`` is called for the first time) it generates a ``CV_GRAPH_NEW_TREE`` event. For unoriented graphs, each search tree corresponds to a connected component of the graph.
* **CV_GRAPH_VERTEX** stop at the graph vertices visited for the first time
* **CV_GRAPH_TREE_EDGE** stop at tree edges ( ``tree edge`` is the edge connecting the last visited vertex and the vertex to be visited next)
* **CV_GRAPH_BACK_EDGE** stop at back edges ( ``back edge`` is an edge connecting the last visited vertex with some of its ancestors in the search tree)
* **CV_GRAPH_FORWARD_EDGE** stop at forward edges ( ``forward edge`` is an edge conecting the last visited vertex with some of its descendants in the search tree. The forward edges are only possible during oriented graph traversal)
* **CV_GRAPH_CROSS_EDGE** stop at cross edges ( ``cross edge`` is an edge connecting different search trees or branches of the same tree. The ``cross edges`` are only possible during oriented graph traversal)
* **CV_GRAPH_ANY_EDGE** stop at any edge ( ``tree, back, forward`` , and ``cross edges`` )
* **CV_GRAPH_NEW_TREE** stop in the beginning of every new search tree. When the traversal procedure visits all vertices and edges reachable from the initial vertex (the visited vertices together with tree edges make up a tree), it searches for some unvisited vertex in the graph and resumes the traversal process from that vertex. Before starting a new tree (including the very first tree when ``cvNextGraphItem`` is called for the first time) it generates a ``CV_GRAPH_NEW_TREE`` event. For unoriented graphs, each search tree corresponds to a connected component of the graph.
* **CV_GRAPH_BACKTRACKING** stop at every already visited vertex during backtracking - returning to already visited vertexes of the traversal tree.
The function creates a structure for depth-first graph traversal/search. The initialized structure is used in the
The function creates a structure for depth-first graph traversal/search. The initialized structure is used in the
:ocv:cfunc:`NextGraphItem`
function - the incremental traversal procedure.
@ -358,11 +358,11 @@ Creates memory storage.
..ocv:cfunction:: CvMemStorage* cvCreateMemStorage( int blockSize=0 )
: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.
The function creates an empty memory storage. See
The function creates an empty memory storage. See
:ocv:struct:`CvMemStorage`
description.
@ -371,7 +371,7 @@ CreateSeq
Creates a sequence.
..ocv:cfunction:: CvSeq* cvCreateSeq( int seqFlags, int headerSize, int elemSize, CvMemStorage* storage)
:param seqFlags:Flags of the created sequence. If the sequence is not passed to any function working with a specific type of sequences, the sequence value may be set to 0, otherwise the appropriate type must be selected from the list of predefined sequence types.
@ -384,21 +384,21 @@ Creates a sequence.
The function creates a sequence and returns
the pointer to it. The function allocates the sequence header in
the storage block as one continuous chunk and sets the structure
fields
fields
``flags``
,
,
``elemSize``
,
,
``headerSize``
, and
``storage``
to passed values, sets
to passed values, sets
``delta_elems``
to the
default value (that may be reassigned using the
default value (that may be reassigned using the
:ocv:cfunc:`SetSeqBlockSize`
function), and clears other header fields, including the space following
the first
the first
``sizeof(CvSeq)``
bytes.
@ -416,7 +416,7 @@ Creates an empty set.
:param storage:Container for the set
The function creates an empty set with a specified header size and element size, and returns the pointer to the set. This function is just a thin layer on top of
The function creates an empty set with a specified header size and element size, and returns the pointer to the set. This function is just a thin layer on top of
:ocv:cfunc:`CreateSeq`.
CvtSeqToArray
@ -445,9 +445,9 @@ The function finishes the writing process and
returns the pointer to the written sequence. The function also truncates
the last incomplete sequence block to return the remaining part of the
block to memory storage. After that, the sequence can be read and
modified safely. See
modified safely. See
:ocv:cfunc:`StartWriteSeq`
and
and
:ocv:cfunc:`StartAppendToSeq`
FindGraphEdge
@ -461,7 +461,7 @@ Finds an edge in a graph.
:param start_idx:Index of the starting vertex of the edge
:param end_idx:Index of the ending vertex of the edge. For an unoriented graph, the order of the vertex parameters does not matter.
::
#define cvGraphFindEdge cvFindGraphEdge
@ -481,7 +481,7 @@ Finds an edge in a graph by using its pointer.
:param startVtx:Pointer to the starting vertex of the edge
:param endVtx:Pointer to the ending vertex of the edge. For an unoriented graph, the order of the vertex parameters does not matter.
::
#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
@ -528,7 +528,7 @@ Returns a pointer to a sequence element according to its index.
:param seq:Sequence
:param index:Index of element
::
#define CV_GET_SEQ_ELEM( TYPE, seq, index ) (TYPE*)cvGetSeqElem( (CvSeq*)(seq), (index) )
@ -544,22 +544,22 @@ the one before last, etc. If the sequence is most likely to consist of
a single sequence block or the desired element is likely to be located
in the first block, then the macro
``CV_GET_SEQ_ELEM( elemType, seq, index )``
should be used, where the parameter
should be used, where the parameter
``elemType``
is the
type of sequence elements (
type of sequence elements (
:ocv:struct:`CvPoint`
for example), the parameter
``seq``
is a sequence, and the parameter
is a sequence, and the parameter
``index``
is the index
of the desired element. The macro checks first whether the desired element
belongs to the first block of the sequence and returns it if it does;
otherwise the macro calls the main function
otherwise the macro calls the main function
``GetSeqElem``
. Negative
indices always cause the
indices always cause the
:ocv:cfunc:`GetSeqElem`
call. The function has O(1)
time complexity assuming that the number of blocks is much smaller than the
@ -573,7 +573,7 @@ Returns the current reader position.
:param reader:Reader state
The function returns the current reader position (within 0 ...
The function returns the current reader position (within 0 ...
``reader->seq->total``
- 1).
@ -587,7 +587,7 @@ Finds a set element by its index.
:param index:Index of the set element within a sequence
The function finds a set element by its index. The function returns the pointer to it or 0 if the index is invalid or the corresponding node is free. The function supports negative indices as it uses
The function finds a set element by its index. The function returns the pointer to it or 0 if the index is invalid or the corresponding node is free. The function supports negative indices as it uses
:ocv:cfunc:`GetSeqElem`
to locate the node.
@ -736,11 +736,11 @@ The function returns the number of edges incident to the specified vertex, both
..
The macro
The macro
``CV_NEXT_GRAPH_EDGE( edge, vertex )``
returns the edge incident to
returns the edge incident to
``vertex``
that follows after
that follows after
``edge``
.
@ -851,7 +851,7 @@ Allocates a text string in a storage block.
:param ptr:The string
:param len:Length of the string (not counting the ending ``NUL`` ) . If the parameter is negative, the function computes the length.
::
typedef struct CvString
@ -877,34 +877,34 @@ Executes one or more steps of the graph traversal procedure.
The function traverses through the graph
until an event of interest to the user (that is, an event, specified
in the
in the
``mask``
in the
in the
:ocv:cfunc:`CreateGraphScanner`
call) is met or the
traversal is completed. In the first case, it returns one of the events
listed in the description of the
listed in the description of the
``mask``
parameter above and with
the next call it resumes the traversal. In the latter case, it returns
``CV_GRAPH_OVER``
(-1). When the event is
(-1). When the event is
``CV_GRAPH_VERTEX``
,
``CV_GRAPH_BACKTRACKING``
, or
, or
``CV_GRAPH_NEW_TREE``
,
the currently observed vertex is stored in
the currently observed vertex is stored in
``scanner-:math:`>`vtx``
. And if the
event is edge-related, the edge itself is stored at
event is edge-related, the edge itself is stored at
``scanner-:math:`>`edge``
,
the previously visited vertex - at
the previously visited vertex - at
``scanner-:math:`>`vtx``
and the other ending
vertex of the edge - at
vertex of the edge - at
``scanner-:math:`>`dst``
.
@ -918,7 +918,7 @@ Returns the currently observed node and moves the iterator toward the next node.
The function returns the currently observed node and then updates the
iterator - moving it toward the next node. In other words, the function
behavior is similar to the
behavior is similar to the
``*p++``
expression on a typical C
pointer or C++ collection iterator. The function returns NULL if there
@ -934,7 +934,7 @@ Returns the currently observed node and moves the iterator toward the previous n
The function returns the currently observed node and then updates
the iterator - moving it toward the previous node. In other words,
the function behavior is similar to the
the function behavior is similar to the
``*p--``
expression on a
typical C pointer or C++ collection iterator. The function returns NULL
@ -960,8 +960,8 @@ Releases memory storage.
The function deallocates all storage memory
blocks or returns them to the parent, if any. Then it deallocates the
storage header and clears the pointer to the storage. All child storage
associated with a given parent storage block must be released before the
storage header and clears the pointer to the storage. All child storage
associated with a given parent storage block must be released before the
The function restores the position of the storage top from the parameter
The function restores the position of the storage top from the parameter
``pos``
. This function and the function
. This function and the function
``cvClearMemStorage``
are the only methods to release memory occupied in memory blocks. Note again that there is no way to free memory in the middle of an occupied portion of a storage block.
@ -991,7 +991,7 @@ Saves memory storage position.
:param pos:The output position of the storage top
The function saves the current position
of the storage top to the parameter
of the storage top to the parameter
``pos``
. The function
``cvRestoreMemStoragePos``
@ -1023,7 +1023,7 @@ Inserts an element in the middle of a sequence.
:param element:Inserted element
The function shifts the sequence elements from the inserted position to the nearest end of the sequence and copies the
The function shifts the sequence elements from the inserted position to the nearest end of the sequence and copies the
``element``
content there if the pointer is not NULL. The function returns a pointer to the inserted element.
@ -1033,13 +1033,13 @@ Inserts an array in the middle of a sequence.
:param element:Optional parameter . If the pointer is not zero, the function copies the removed element to this location.
:param seq:Sequence
:param element:Optional parameter . If the pointer is not zero, the function copies the removed element to this location.
The function removes an element from a sequence. The function reports an error if the sequence is already empty. The function has O(1) complexity.
SeqPopFront
@ -1091,10 +1091,10 @@ Removes several elements from either end of a sequence.
:param count:Number of elements to pop
:param in_front:The flags specifying which end of the modified sequence.
* **CV_BACK** the elements are added to the end of the sequence
:param in_front:The flags specifying which end of the modified sequence.
* **CV_BACK** the elements are added to the end of the sequence
* **CV_FRONT** the elements are added to the beginning of the sequence
The function removes several elements from either end of the sequence. If the number of the elements to be removed exceeds the total number of elements in the sequence, the function removes as many elements as possible.
@ -1109,7 +1109,7 @@ Adds an element to the end of a sequence.
:param element:Added element
The function adds an element to the end of a sequence and returns a pointer to the allocated element. If the input
The function adds an element to the end of a sequence and returns a pointer to the allocated element. If the input
``element``
is NULL, the function simply allocates a space for one more element.
@ -1128,14 +1128,14 @@ The following code demonstrates how to create a new sequence using this function
int* added = (int*)cvSeqPush( seq, &i );
printf( "
}
...
/* release memory storage in the end */
cvReleaseMemStorage( &storage );
..
The function has O(1) complexity, but there is a faster method for writing large sequences (see
The function has O(1) complexity, but there is a faster method for writing large sequences (see
:ocv:cfunc:`StartWriteSeq`
and related functions).
@ -1149,7 +1149,7 @@ Adds an element to the beginning of a sequence.
:param element:Added element
The function is similar to
The function is similar to
:ocv:cfunc:`SeqPush`
but it adds the new element to the beginning of the sequence. The function has O(1) complexity.
@ -1165,10 +1165,10 @@ Pushes several elements to either end of a sequence.
:param count:Number of elements to push
:param in_front:The flags specifying which end of the modified sequence.
* **CV_BACK** the elements are added to the end of the sequence
:param in_front:The flags specifying which end of the modified sequence.
* **CV_BACK** the elements are added to the end of the sequence
* **CV_FRONT** the elements are added to the beginning of the sequence
The function adds several elements to either
@ -1266,7 +1266,7 @@ Sorts sequence element using the specified comparison function.
:param func:The comparison function that returns a negative, zero, or positive value depending on the relationships among the elements (see the above declaration and the example below) - a similar function is used by ``qsort`` from C runline except that in the latter, ``userdata`` is not used
:param userdata:The user parameter passed to the compasion function; helps to avoid global variables in some cases
::
/* a < b ? -1 : a > b ? 1 : 0 */
@ -1287,30 +1287,30 @@ The function sorts the sequence in-place using the specified criteria. Below is
:param _response:keypoint detector response on the keypoint (that is, strength of the keypoint)
:param _octave:pyramid octave in which the keypoint has been detected
:param _class_id:object id
@ -309,7 +309,7 @@ Wrapping class for feature detection using the
protected:
...
};
DenseFeatureDetector
--------------------
@ -317,18 +317,18 @@ DenseFeatureDetector
Class for generation of image features which are distributed densely and regularly over the image. ::
class DenseFeatureDetector : public FeatureDetector
{
public:
DenseFeatureDetector( float initFeatureScale=1.f, int featureScaleLevels=1,
class DenseFeatureDetector : public FeatureDetector
{
public:
DenseFeatureDetector( float initFeatureScale=1.f, int featureScaleLevels=1,
float featureScaleMul=0.1f,
int initXyStep=6, int initImgBound=0,
bool varyXyStepWithScale=true,
bool varyImgBoundWithScale=false );
protected:
protected:
...
};
The detector generates several levels (in the amount of ``featureScaleLevels``) of features. Features of each level are located in the nodes of a regular grid over the image (excluding the image boundary of given size). The level parameters (a feature scale, a node size, a size of boundary) are multiplied by ``featureScaleMul`` with level index growing depending on input flags, viz.:
* Feature scale is multiplied always.
@ -380,11 +380,11 @@ Class for extracting blobs from an image. ::
The class implements a simple algorithm for extracting blobs from an image:
#. Convert the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds.
#. Convert the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds.
#. Extract connected components from every binary image by :ocv:func:`findContours` and calculate their centers.
#. Extract connected components from every binary image by :ocv:func:`findContours` and calculate their centers.
#. Group centers from several binary images by their coordinates. Close centers form one group that corresponds to one blob, which is controlled by the ``minDistBetweenBlobs`` parameter.
#. Group centers from several binary images by their coordinates. Close centers form one group that corresponds to one blob, which is controlled by the ``minDistBetweenBlobs`` parameter.
#. From the groups, estimate final centers of blobs and their radiuses and return as locations and sizes of keypoints.
@ -468,7 +468,7 @@ panorama series.
``DynamicAdaptedFeatureDetector`` uses another detector, such as FAST or SURF, to do the dirty work,
with the help of ``AdjusterAdapter`` .
If the detected number of features is not large enough,
``AdjusterAdapter`` adjusts the detection parameters so that the next detection
``AdjusterAdapter`` adjusts the detection parameters so that the next detection
results in a bigger or smaller number of features. This is repeated until either the number of desired features are found
or the parameters are maxed out.
@ -500,14 +500,14 @@ The constructor
:param max_features:Maximum desired number of features.
:param max_iters:Maximum number of times to try adjusting the feature detector parameters. For :ocv:class:`FastAdjuster` , this number can be high, but with ``Star`` or ``Surf`` many iterations can be time-comsuming. At each iteration the detector is rerun.
:param max_iters:Maximum number of times to try adjusting the feature detector parameters. For :ocv:class:`FastAdjuster` , this number can be high, but with ``Star`` or ``Surf`` many iterations can be time-comsuming. At each iteration the detector is rerun.
AdjusterAdapter
---------------
..ocv:class:: AdjusterAdapter
Class providing an interface for adjusting parameters of a feature detector. This interface is used by :ocv:class:`DynamicAdaptedFeatureDetector` . It is a wrapper for :ocv:class:`FeatureDetector` that enables adjusting parameters after feature detection. ::
class AdjusterAdapter: public FeatureDetector
{
public:
@ -562,7 +562,7 @@ Example: ::
AdjusterAdapter::good
-------------------------
Returns false if the detector parameters cannot be adjusted any more.
Returns false if the detector parameters cannot be adjusted any more.
@ -10,7 +10,7 @@ The implemented stitching pipeline is very similar to the one proposed in [BL07]
..image:: StitchingPipeline.jpg
References
----------
==========
..[BL07] M. Brown and D. Lowe. Automatic Panoramic Image Stitching using Invariant Features. International Journal of Computer Vision, 74(1), pages 59-73, 2007.
@ -204,6 +204,7 @@ Implementation of the camera parameters refinement algorithm which minimizes sum
detail::BundleAdjusterRay
-------------------------
..ocv:class:: detail::BundleAdjusterRay
Implementation of the camera parameters refinement algorithm which minimizes sum of the distances between the rays passing through the camera center and a feature. ::
Andrey Kamaev
13 years ago