C API
[Image processing]

Freeman chain reader state.

Connected component structure.

Convexity defect.

Font structure.

Hu invariants.

Spatial and central moments.

Filters used in pyramid decomposition.

Definition at line 88 of file imgproc/types_c.h.

Special filters.

Definition at line 94 of file imgproc/types_c.h.

Constants for color conversion.

Definition at line 101 of file imgproc/types_c.h.

Sub-pixel interpolation methods.

Definition at line 357 of file imgproc/types_c.h.

...

and other image warping flags

Definition at line 367 of file imgproc/types_c.h.

Morphological operations.

Definition at line 385 of file imgproc/types_c.h.

Template matching methods.

Definition at line 431 of file imgproc/types_c.h.

Contour retrieval modes.

Definition at line 444 of file imgproc/types_c.h.

Contour approximation methods.

Definition at line 454 of file imgproc/types_c.h.

Contour approximation algorithms.

Definition at line 489 of file imgproc/types_c.h.

Shape orientation.

Definition at line 510 of file imgproc/types_c.h.

Histogram comparison methods.

Definition at line 528 of file imgproc/types_c.h.

Mask size for distance transform.

Definition at line 540 of file imgproc/types_c.h.

Content of output label array: connected components or pixels.

Definition at line 548 of file imgproc/types_c.h.

Distance types for Distance Transform and M-estimators.

Enumerator:

CV_DIST_USER	User defined distance.
CV_DIST_L1	distance = |x1-x2| + |y1-y2|
CV_DIST_L2	the simple euclidean distance
CV_DIST_C	distance = max(|x1-x2|,|y1-y2|)
CV_DIST_L12	L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
CV_DIST_FAIR	distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
CV_DIST_WELSCH	distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
CV_DIST_HUBER	distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345

Definition at line 555 of file imgproc/types_c.h.

Threshold types.

Enumerator:

CV_THRESH_BINARY	value = value > threshold ? max_value : 0
CV_THRESH_BINARY_INV	value = value > threshold ? 0 : max_value
CV_THRESH_TRUNC	value = value > threshold ? threshold : value
CV_THRESH_TOZERO	value = value > threshold ? value : 0
CV_THRESH_TOZERO_INV	value = value > threshold ? 0 : value
CV_THRESH_OTSU	use Otsu algorithm to choose the optimal threshold value; combine the flag with one of the above CV_THRESH_* values
CV_THRESH_TRIANGLE	use Triangle algorithm to choose the optimal threshold value; combine the flag with one of the above CV_THRESH_* values, but not with CV_THRESH_OTSU

Definition at line 569 of file imgproc/types_c.h.

Adaptive threshold methods.

Definition at line 585 of file imgproc/types_c.h.

FloodFill flags.

Definition at line 592 of file imgproc/types_c.h.

Canny edge detector flags.

Definition at line 600 of file imgproc/types_c.h.

Variants of a Hough transform.

Definition at line 606 of file imgproc/types_c.h.

Shapes of a structuring element for morphological operations.

See also:

cv::MorphShapes, cv::getStructuringElement

Enumerator:

CV_SHAPE_CUSTOM

custom structuring element

Definition at line 376 of file imgproc/types_c.h.

Shape matching methods.

denotes object1, denotes object2

and are the Hu moments of and , respectively.

Enumerator:

CV_CONTOURS_MATCH_I1
CV_CONTOURS_MATCH_I2
CV_CONTOURS_MATCH_I3

Definition at line 502 of file imgproc/types_c.h.

Image smooth methods.

Enumerator:

CV_BLUR_NO_SCALE	linear convolution with 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 integral
CV_BLUR	linear convolution with box kernel (all 1's) with subsequent scaling by
CV_GAUSSIAN	linear convolution with a Gaussian kernel
CV_MEDIAN	median filter with a square aperture
CV_BILATERAL	bilateral filter with a square aperture, color sigma= sigma1 and spatial sigma= sigma2. If size1=0, the aperture square side is set to cvRound(sigma2\*1.5)\*2+1. See cv::bilateralFilter

Definition at line 68 of file imgproc/types_c.h.

Deallocates an image header.

Draws contour outlines or filled interiors on the image.

Calculates bounding box of text stroke (useful for alignment)

Renders text stroke with specified font and color at specified location.

Initializes font structure (OpenCV 1.x API).

Draws one or more polygonal curves.

Fills an area bounded by one or more arbitrary polygons.

Fills convex or monotonous polygon.

Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector.

Draws a circle with specified center and radius.

Draws a rectangle specified by a CvRect structure.

Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)

Draws 4-connected, 8-connected or antialiased line segment connecting two points.

Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)

Finds a sparse set of points within the selected region that seem to be easy to track.

Adjust corner position using some sort of gradient search.

Harris corner detector:

Calculates minimal eigenvalue for 2x2 gradient covariation matrix at every image pixel.

Calculates eigen values and vectors of 2x2 gradient covariation matrix at every image pixel.

Calculates constraint image for corner detection.

Runs canny edge detector.

Fills the connected component until the color difference gets large enough.

Applies adaptive threshold to grayscale image.

Applies distance transform to binary image.

equalizes histogram of 8-bit single-channel image

Divides one histogram by another.

Locates a template within an image by using a histogram comparison.

Calculates back project.

Calculates array histogram.

Calculates bayesian probabilistic histograms (each or src and dst is an array of _number_ histograms.

Copies a histogram.

Thresholds the histogram.

Normalizes the histogram.

Finds the minimum and maximum histogram bins.

Clears the histogram.

Releases the histogram.

Sets the bounds of the histogram bins.

Finds coordinates of the box vertices.

Initializes Freeman chain reader.

Substitutes the last retrieved contour with the new one.

Measures similarity between template and overlapped windows in the source image and fills the resultant image with the measurements.

Retrieves quadrangle from the input array.

Retrieves the rectangular image region with specified center from the input array.

Calculates 7 Hu's invariants from precalculated spatial and central moments.

Calculates all spatial and central moments up to the 3rd order.

Performs complex morphological transformation.

dilates input image (applies maximum filter) one or more times.

erodes input image (applies minimum filter) one or more times.

releases structuring element

Computes the original (undistorted) feature coordinates from the observed (distorted) coordinates.

Computes undistortion+rectification map for a head of stereo camera.

Computes transformation map from intrinsic camera parameters that can used by cvRemap.

Transforms the input image to compensate lens distortion.

Performs forward or inverse linear-polar image transform.

Performs forward or inverse log-polar image transform.

Converts mapx & mapy from floating-point to integer formats for cvRemap.

Performs generic geometric transformation using the specified coordinate maps.

Warps image with perspective (projective) transform.

Warps image with affine transform.

Resizes image (input array is resized to fit the destination array)

Converts input array pixels from one color space to another.

Calculates the image Laplacian: (d2/dx + d2/dy)I.

Calculates an image derivative using generalized Sobel.

Segments image using seed "markers".

Filters image using meanshift algorithm.

Releases pyramid.

Up-samples image and smoothes the result with gaussian kernel.

Smoothes the input image with gaussian kernel and then down-samples it.

Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y)

Convolves an image with the kernel.

Smooths the image in one of several ways.

Copies source 2D array inside of the larger destination array and makes a border of the specified type (IPL_BORDER_*) around the copied area.

Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha.

Adds a product of two images to accumulator.

Adds squared image to accumulator.

Sets error status and performs some additonal actions (displaying message box, writing message to stderr, terminating application etc.) depending on the current error mode.

Sets error status silently.

Saves an object to a file.

Releases an object.

Unregisters the type.

Registers a new type.

Writes a file node to another file storage.

Reads multiple numbers.

Initializes file node sequence reader.

Initializes the file node sequence reader.

Writes multiple numbers.

Starts the next stream.

Writes an object to file storage.

Writes a comment.

Writes a text string.

Writes a floating-point value.

Writes an integer value.

Finishes writing to a file node collection.

Starts writing a new structure.

Releases file storage.

Makes OpenCV use IPL functions for allocating IplImage and IplROI structures.

Removes contour from tree (together with the contour children).

Inserts sequence into tree with specified "parent" sequence.

Does look-up transformation.

Releases graph scanner.

Remove all vertices and edges from the graph.

Remove edge connecting two vertices.

Removes all the elements from the set.

Removes element from the set by its index.

Reverses order of sequence elements in-place.

Sorts sequence in-place given element comparison function.

Inserts a sequence or array into another sequence.

Removes sequence slice.

Changes sequence reader position.

Initializes sequence reader.

Updates sequence header.

Combination of cvCreateSeq and cvStartAppendToSeq.

Initializes sequence writer.

Removes all the elements from the sequence.

Removes specified sequence element.

Removes several elements from the end of sequence and optionally saves them.

Adds several new elements to the end of sequence.

Removes the first element from sequence and optioanally saves it.

Removes the last element from sequence and optionally saves it.

Changes default size (granularity) of sequence blocks.

Restore a storage "free memory" position.

Remember a storage "free memory" position.

Clears memory storage.

Releases memory storage.

Discrete Cosine Transform.

Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y))

Discrete Fourier Transform: complex->complex, real->ccs (forward), ccs->real (inverse)

Finds global minimum, maximum and their positions.

Calculates mean and standard deviation of pixel values.

Calculates covariation matrix for a set of vectors.

* Finds selected eigen values and vectors of a symmetric matrix */

Finds eigen values and vectors of a symmetric matrix.

Performs Singular Value Back Substitution (solves A*X = B): flags must be the same as in cvSVD.

Performs Singular Value Decomposition of a matrix.

Mirror array data around horizontal (flip=0), vertical (flip=1) or both(flip=-1) axises: cvFlip(src) flips images vertically and sequences horizontally (inplace)

Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part.

Tranposes matrix.

Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1)

Does perspective transform on every element of input array.

Transforms each element of source array and stores resultant vectors in destination array.

Extended matrix transform: dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T.

Calculates the cross product of two 3D vectors.

Finds all real and complex roots of a polynomial equation.

Fills an array with random numbers and updates the RNG state.

Calculates natural logarithms: dst(idx) = log(abs(src(idx))).

Does exponention: dst(idx) = exp(src(idx)).

Does powering: dst(idx) = src(idx)^power.

Does polar->cartesian coordinates conversion.

Does cartesian->polar coordinates conversion.

dst(x,y,c) = abs(src(x,y,c) - value(c))

dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))

dst(idx) = max(src(idx),value)

dst(idx) = min(src(idx),value)

dst(idx) = max(src1(idx),src2(idx))

dst(idx) = min(src1(idx),src2(idx))

dst(idx) = src1(idx) _cmp_op_ value

The comparison operation support single-channel arrays only.

dst(idx) = lower <= src(idx) < upper

dst(idx) = lower(idx) <= src(idx) < upper(idx)

dst(idx) = ~src(idx)

dst(idx) = src(idx) ^ value

dst(idx) = src1(idx) ^ src2(idx)

dst(idx) = src(idx) | value

dst(idx) = src1(idx) | src2(idx)

dst(idx) = src(idx) & value

dst(idx) = src1(idx) & src2(idx)

dst = src1 * alpha + src2 * beta + gamma

dst = src1 * scale + src2

element-wise division/inversion with scaling: dst(idx) = src1(idx) * scale / src2(idx) or dst(idx) = scale / src2(idx) if src1 == 0

dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays)

dst(mask) = value - src(mask)

dst(mask) = src1(mask) - src2(mask)

dst(mask) = src(mask) + value

dst(mask) = src1(mask) + src2(mask)

Performs linear transformation on every source array element, stores absolute value of the result: dst(x,y,c) = abs(scale*src(x,y,c)+shift).

Converts one array to another with optional linear transformation.

Copies several channels from input arrays to certain channels of output arrays.

Merges a set of single-channel arrays into the single multi-channel array or inserts one particular [color] plane to the array.

Splits a multi-channel array into the set of single-channel arrays or extracts particular [color] plane.

Clears the array.

Sets every element of an array to a given value.

Copies one array to another.

Retrieves low-level information about the array.

Assigns user data to the array header.

Releases array data.

Allocates array data.

Repeats source 2d array several times in both horizontal and vertical direction to fill destination array.

clears element of ND dense array, in case of sparse arrays it deletes the specified node

Change a specific array element.

Change the particular array element.

Deallocates sparse array.

low-level scalar <-> raw data conversion functions

Deallocates a matrix.

Resets the image ROI to include the entire image and releases the ROI structure.

Sets an image Region Of Interest (ROI) for a given rectangle.

Sets the channel of interest in an IplImage.

Deallocates the image header and the image data.

This call is an analogue of :

    if(image )
    {
        iplDeallocate(*image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI);
        *image = 0;
    }

but it does not use IPL functions by default (see the CV_TURN_ON_IPL_COMPATIBILITY macro).

Parameters:

image

Double pointer to the image header

This call is a shortened form of :

    if(*image )
    {
        cvReleaseData(*image);
        cvReleaseImageHeader(image);
    }

Parameters:

image

Double pointer to the image header

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 cvCopy or cvSplit) the channel to a separate image/matrix, process it and then copy the result back (via cvCopy or cvMerge) if needed.

Parameters:

image	A pointer to the image header
coi	The channel of interest. 0 - all channels are selected, 1 - first channel is selected, etc. Note that the channel indices become 1-based.

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.

Parameters:

image	A pointer to the image header
rect	The ROI rectangle

This produces a similar result to the following, but in addition it releases the ROI structure. :

    cvSetImageROI(image, cvRect(0, 0, image->width, image->height ));
    cvSetImageCOI(image, 0);

Parameters:

image

A pointer to the image header

The function decrements the matrix data reference counter and deallocates matrix header. If the data reference counter is 0, it also deallocates the data. :

    if(*mat )
        cvDecRefData(*mat);
    cvFree((void**)mat);

Parameters:

mat	Double pointer to the matrix

The function releases the sparse array and clears the array pointer upon exit.

Parameters:

mat	Double pointer to the array

The functions assign the new value to a particular array element. In the case of a sparse array the functions create the node if it does not exist yet.

Parameters:

arr	Input array
idx0	The first zero-based component of the element index
value	The assigned value

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

arr	Input array
idx	Array of the element indices
value	The assigned value

The functions assign a new value to a specific element of a single-channel array. If the array has multiple channels, a runtime error is raised. Note that the Set\*D 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 create the node if it does not yet exist.

Parameters:

arr	Input array
idx0	The first zero-based component of the element index
value	The assigned value

The function allocates image, matrix or multi-dimensional dense array data. Note that in the case of matrix types OpenCV allocation functions are used. In the case of IplImage they are used unless CV_TURN_ON_IPL_COMPATIBILITY() has been called before. In the latter case IPL functions are used to allocate the data.

Parameters:

arr	Array header

The function releases the array data. In the case of CvMat or CvMatND it simply calls cvDecRefData(), that is the function can not deallocate external data. See also the note to cvCreateData .

Parameters:

arr	Array header

The function assigns user data to the array header. Header should be initialized before using cvCreateMatHeader, cvCreateImageHeader, cvCreateMatNDHeader, cvInitMatHeader, cvInitImageHeader or cvInitMatNDHeader.

Parameters:

arr	Array header
data	User data
step	Full row length in bytes

The function fills output variables with low-level information about the array data. All output

parameters are optional, so some of the pointers may be set to NULL. If the array is IplImage with ROI set, the parameters of ROI are returned.

The following example shows how to get access to array elements. It computes absolute values of the array elements :

    float* data;
    int step;
    CvSize size;

    cvGetRawData(array, (uchar**)&data, &step, &size);
    step /= sizeof(data[0]);

    for(int y = 0; y < size.height; y++, data += step )
        for(int x = 0; x < size.width; x++ )
            data[x] = (float)fabs(data[x]);

Parameters:

arr	Array header
data	Output pointer to the whole image origin or ROI origin if ROI is set
step	Output full row length in bytes
roi_size	Output ROI size

The function copies selected elements from an input array to an output array:

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).

Parameters:

src	The source array
dst	The destination array
mask	Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed

The function copies the scalar value to every selected element of the destination array:

If array arr is of IplImage type, then is ROI used, but COI must not be set.

Parameters:

arr	The destination array
value	Fill value
mask	Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed

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.

Parameters:

arr	Array to be cleared

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:

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.

Parameters:

src	Source array
dst	Destination array
scale	Scale factor
shift	Value added to the scaled source array elements

destination array must have 8u type. In other cases one may use cvConvertScale + cvAbsDiffS

Destination image should be 8uC1 or 8sC1 dst(idx) = src1(idx) _cmp_op_ src2(idx)

Either of output components (magnitude or angle) is optional

Either of output components (magnitude or angle) is optional. If magnitude is missing it is assumed to be all 1's

Overflow is not handled yet. Underflow is handled. Maximal relative error is ~7e-6 for single-precision input

Logarithm of 0 gives large negative number(~-700) Maximal relative error is ~3e-7 for single-precision output

The function fills the destination array with uniformly or normally distributed random numbers.

Parameters:

rng	CvRNG state initialized by cvRNG
arr	The destination array
dist_type	Distribution type > - **CV_RAND_UNI** uniform distribution > - **CV_RAND_NORMAL** normal or Gaussian distribution
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.
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.

See also:

randu, randn, RNG::fill.

The function calculates the cross product of two 3D vectors:

or:

Parameters:

src1	The first source vector
src2	The second source vector
dst	The destination vector

Square matrices can be transposed in-place

Makes an identity matrix (mat_ij = i == j)

See also:

flags

ref core_c_NormFlags "flags"

flags

core_c_DftFlags "flags"

All the children of a parent must be released before the parent. A child storage returns all the blocks to parent when it is released

This is the only way(!!!) (besides cvRestoreMemStoragePos) to reuse memory allocated for the storage - cvClearSeq,cvClearSet ... do not free any memory. A child storage returns all the blocks to the parent when it is cleared

The default size is ~1Kbyte

The freed memory can be reused later only by the same sequence unless cvClearMemStorage or cvRestoreMemStoragePos is called

The new elements will be added to the end of sequence

May be useful to get access to some of previously written elements via cvGetSeqElem or sequence reader

The sequence can be read in forward or backward direction

It may seek to an absolute or to relative to the current position

Elements of the source array (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table

If parent is equal to frame (e.g. the most external contour), then added contour will have null pointer to parent.

Normally, the function is not called directly. Instead, a simple macro CV_TURN_ON_IPL_COMPATIBILITY() is used that calls cvSetIPLAllocators and passes there pointers to IPL allocation functions. :

    ...
    CV_TURN_ON_IPL_COMPATIBILITY()
    ...

Parameters:

create_header	pointer to a function, creating IPL image header.
allocate_data	pointer to a function, allocating IPL image data.
deallocate	pointer to a function, deallocating IPL image.
create_roi	pointer to a function, creating IPL image ROI (i.e. Region of Interest).
clone_image	pointer to a function, cloning an IPL image.

The function closes the file associated with the storage and releases all the temporary structures. It must be called after all I/O operations with the storage are finished.

Parameters:

fs	Double pointer to the released file storage

The function starts writing a compound structure (collection) that can be a sequence or a map. After all the structure fields, which can be scalars or structures, are written, cvEndWriteStruct should be called. The function can be used to group some objects or to implement the write function for a some user object (see CvTypeInfo).

Parameters:

fs	File storage
name	Name of the written structure. The structure can be accessed by this name when the storage is read.
struct_flags	A combination one of the following values: **CV_NODE_SEQ** the written structure is a sequence (see discussion of CvFileStorage ), that is, its elements do not have a name. **CV_NODE_MAP** the written structure is a map (see discussion of CvFileStorage ), that is, all its elements have names. One and only one of the two above flags must be specified **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that the structure is written as a flow (not as a block), which is more compact. It is recommended to use this flag for structures or arrays whose elements are all scalars.
type_name	Optional parameter - the object type name. In case of XML it is written as a type_id attribute of the structure opening tag. In the case of YAML it is written after a colon following the structure name (see the example in CvFileStorage description). Mainly it is used with user objects. When the storage is read, the encoded type name is used to determine the object type (see CvTypeInfo and cvFindType ).
attributes	This parameter is not used in the current implementation
fs	File storage

See also:

cvStartWriteStruct.

The function writes a single integer value (with or without a name) to the file storage.

Parameters:

fs	File storage
name	Name of the written value. Should be NULL if and only if the parent structure is a sequence.
value	The written value

The function writes a single floating-point value (with or without a name) to file storage. Special values are encoded as follows: NaN (Not A Number) as .NaN, infinity as +.Inf or -.Inf.

The following example shows how to use the low-level writing functions to store custom structures, such as termination criteria, without registering a new type. :

    void write_termcriteria( CvFileStorage* fs, const char* struct_name,
                             CvTermCriteria * termcrit )
    {
        cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0));
        cvWriteComment( fs, "termination criteria", 1 ); // just a description
        if( termcrit->type & CV_TERMCRIT_ITER )
            cvWriteInteger( fs, "max_iterations", termcrit->max_iter );
        if( termcrit->type & CV_TERMCRIT_EPS )
            cvWriteReal( fs, "accuracy", termcrit->epsilon );
        cvEndWriteStruct( fs );
    }

Parameters:

fs	File storage
name	Name of the written value. Should be NULL if and only if the parent structure is a sequence.
value	The written value

The function writes a text string to file storage.

Parameters:

fs	File storage
name	Name of the written string . Should be NULL if and only if the parent structure is a sequence.
str	The written text string
quote	If non-zero, the written string is put in quotes, regardless of whether they are required. Otherwise, if the flag is zero, quotes are used only when they are required (e.g. when the string starts with a digit or contains spaces).

The function writes a comment into file storage. The comments are skipped when the storage is read.

Parameters:

fs	File storage
comment	The written comment, single-line or multi-line
eol_comment	If non-zero, the function tries to put the comment at the end of current line. If the flag is zero, if the comment is multi-line, or if it does not fit at the end of the current line, the comment starts a new line.

The function writes an object to file storage. First, the appropriate type info is found using cvTypeOf. Then, the write method associated with the type info is called.

Attributes are used to customize the writing procedure. The standard types support the following attributes (all the dt attributes have the same format as in cvWriteRawData):

1. CvSeq
   • **header_dt** description of user fields of the sequence header that follow CvSeq, or CvChain (if the sequence is a Freeman chain) or CvContour (if the sequence is a contour or point sequence)
   • **dt** description of the sequence elements.
   • **recursive** if the attribute is present and is not equal to "0" or "false", the whole tree of sequences (contours) is stored.
2. CvGraph
   • **header_dt** description of user fields of the graph header that follows CvGraph;
   • **vertex_dt** description of user fields of graph vertices
   • **edge_dt** description of user fields of graph edges (note that the edge weight is always written, so there is no need to specify it explicitly)

Below is the code that creates the YAML file shown in the CvFileStorage description:

    #include "cxcore.h"

    int main( int argc, char** argv )
    {
        CvMat* mat = cvCreateMat( 3, 3, CV_32F );
        CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0, CV_STORAGE_WRITE );

        cvSetIdentity( mat );
        cvWrite( fs, "A", mat, cvAttrList(0,0) );

        cvReleaseFileStorage( &fs );
        cvReleaseMat( &mat );
        return 0;
    }

Parameters:

fs	File storage
name	Name of the written object. Should be NULL if and only if the parent structure is a sequence.
ptr	Pointer to the object
attributes	The attributes of the object. They are specific for each particular type (see the discussion below).

The function finishes the currently written stream and starts the next stream. In the case of XML the file with multiple streams looks like this:

 {.xml}
    <opencv_storage>
    <!-- stream #1 data -->
    </opencv_storage>
    <opencv_storage>
    <!-- stream #2 data -->
    </opencv_storage>
    ...

The YAML file will look like this:

 {.yaml}
    %YAML:1.0
    # stream #1 data
    ...
    ---
    # stream #2 data

This is useful for concatenating files or for resuming the writing process.

Parameters:

fs	File storage

The function writes an array, whose elements consist of single or multiple numbers. The function call can be replaced with a loop containing a few cvWriteInt and cvWriteReal calls, but a single call is more efficient. Note that because none of the elements have a name, they should be written to a sequence rather than a map.

Parameters:

fs	File storage
src	Pointer to the written array
len	Number of the array elements to write
dt	Specification of each array element, see format specification

The function initializes the sequence reader to read data from a file node. The initialized reader can be then passed to cvReadRawDataSlice.

Parameters:

fs	File storage
src	The file node (a sequence) to read numbers from
reader	Pointer to the sequence reader

The function reads one or more elements from the file node, representing a sequence, to a user-specified array. The total number of read sequence elements is a product of total and the number of components in each array element. For example, if dt=2if, the function will read total\*3 sequence elements. As with any sequence, some parts of the file node sequence can be skipped or read repeatedly by repositioning the reader using cvSetSeqReaderPos.

Parameters:

fs	File storage
reader	The sequence reader. Initialize it with cvStartReadRawData .
count	The number of elements to read
dst	Pointer to the destination array
dt	Specification of each array element. It has the same format as in cvWriteRawData .

The function reads elements from a file node that represents a sequence of scalars.

Parameters:

fs	File storage
src	The file node (a sequence) to read numbers from
dst	Pointer to the destination array
dt	Specification of each array element. It has the same format as in cvWriteRawData .

The function writes a copy of a file node to file storage. Possible applications of the function are merging several file storages into one and conversion between XML and YAML formats.

Parameters:

fs	Destination file storage
new_node_name	New name of the file node in the destination file storage. To keep the existing name, use cvcvGetFileNodeName
node	The written node
embed	If the written node is a collection and this parameter is not zero, no extra level of hierarchy is created. Instead, all the elements of node are written into the currently written structure. Of course, map elements can only be embedded into another map, and sequence elements can only be embedded into another sequence.

The function registers a new type, which is described by info . The function creates a copy of the structure, so the user should delete it after calling the function.

Parameters:

info	Type info structure

The function unregisters a type with a specified name. If the name is unknown, it is possible to locate the type info by an instance of the type using cvTypeOf or by iterating the type list, starting from cvFirstType, and then calling cvUnregisterType(info->typeName).

Parameters:

type_name

Name of an unregistered type

The function finds the type of a given object and calls release with the double pointer.

Parameters:

struct_ptr

Double pointer to the object

The function saves an object to a file. It provides a simple interface to cvWrite .

Parameters:

filename	File name
struct_ptr	Object to save
name	Optional object name. If it is NULL, the name will be formed from filename .
comment	Optional comment to put in the beginning of the file
attributes	Optional attributes passed to cvWrite

See also:

cv::accumulateSquare

cv::accumulateProduct

cv::accumulateWeighted

Parameters:

src	The source image
dst	The destination image
smoothtype	Type of the smoothing, see SmoothMethod_c
size1	The first parameter of the smoothing operation, the aperture width. Must be a positive odd number (1, 3, 5, ...)
size2	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 size2 is zero, it is set to size1. Otherwise it must be a positive odd number.
sigma1	In the case of a Gaussian parameter this parameter may specify Gaussian (standard deviation). If it is zero, it is calculated from the kernel size: Using standard sigma for small kernels ( to ) gives better speed. If sigma1 is not zero, while size1 and size2 are zeros, the kernel size is calculated from the sigma (to provide accurate enough operation).
sigma2	additional parameter for bilateral filtering

See also:

cv::GaussianBlur, cv::blur, cv::medianBlur, cv::bilateralFilter.

Parameters:

src	input image.
dst	output image of the same size and the same number of channels as src.
kernel	convolution kernel (or rather a correlation 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 split and process them individually.
anchor	anchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.

See also:

cv::filter2D

cv::integral

dst_width = floor(src_width/2)[+1], dst_height = floor(src_height/2)[+1]

See also:

cv::pyrDown

dst_width = src_width*2, dst_height = src_height*2

See also:

cv::pyrUp

cv::pyrMeanShiftFiltering

cv::watershed

(aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator. Scharr can be used only for the first dx or dy derivative

See also:

cv::Sobel

cv::Laplacian

cv::cvtColor

cv::resize

Note:

cvGetQuadrangleSubPix is similar to cvWarpAffine, but the outliers are extrapolated using replication border mode.

See also:

cv::warpAffine

cv::warpPerspective

cv::remap

cv::convertMaps

cv::logPolar

cv::linearPolar

cv::undistort

cv::initUndistortRectifyMap

cv::undistortPoints

cvCreateStructuringElementEx

If element pointer is NULL, 3x3 rectangular element is used

See also:

cv::erode

If element pointer is NULL, 3x3 rectangular element is used

See also:

cv::dilate

cv::morphologyEx

cv::moments

cv::HuMoments

dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2). Values of pixels with fractional coordinates are retrieved using bilinear interpolation

See also:

cv::getRectSubPix

matrixarr = ( a11 a12 | b1 ) dst(x,y) <- src(A[x y]' + b) ( a21 a22 | b2 ) (bilinear interpolation is used to retrieve pixels with fractional coordinates)

See also:

cvWarpAffine

cv::matchTemplate

(if the substitutor is null, the last retrieved contour is removed from the tree)

See also:

cvFindContours

The reader is used to iteratively get coordinates of all the chain points. If the Freeman codes should be read as is, a simple sequence reader should be used

See also:

cvApproxChains

This is a standalone function for setting bin ranges in the histogram. For a more detailed description of the parameters ranges and uniform, see the :ocvCalcHist function that can initialize the ranges as well. Ranges for the histogram bins must be set before the histogram is calculated or the backproject of the histogram is calculated.

Parameters:

hist	Histogram.
ranges	Array of bin ranges arrays. See :ocvCreateHist for details.
uniform	Uniformity flag. See :ocvCreateHist for details.

The function releases the histogram (header and the data). The pointer to the histogram is cleared by the function. If \*hist pointer is already NULL, the function does nothing.

Parameters:

hist	Double pointer to the released histogram.

The function sets all of the histogram bins to 0 in case of a dense histogram and removes all histogram bins in case of a sparse array.

Parameters:

hist	Histogram.

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 the lexicographical order) are returned. In case of several maximums or minimums, the earliest in the lexicographical order (extrema locations) is returned.

Parameters:

hist	Histogram.
min_value	Pointer to the minimum value of the histogram.
max_value	Pointer to the maximum value of the histogram.
min_idx	Pointer to the array of coordinates for the minimum.
max_idx	Pointer to the array of coordinates for the maximum.

The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to factor.

Parameters:

hist	Pointer to the histogram.
factor	Normalization factor.

The function clears histogram bins that are below the specified threshold.

Parameters:

hist	Pointer to the histogram.
threshold	Threshold level.

The function makes a copy of the histogram. If the second histogram pointer \*dst is NULL, a new histogram of the same size as src is created. Otherwise, both histograms must have equal types and sizes. Then the function copies the bin values of the source histogram to the destination histogram and sets the same bin value ranges as in src.

Parameters:

src	Source histogram.
dst	Pointer to the destination histogram.

See also:

cv::calcHist

cvCalcBackProject, cv::calcBackProject

The function calculates the back projection by comparing histograms of the source image patches with the given histogram. The function is similar to matchTemplate, but instead of comparing the raster patch with all its possible positions within the search window, the function CalcBackProjectPatch compares histograms. See the algorithm diagram below:


Parameters:

image	Source images (though, you may pass CvMat\*\* as well).
dst	Destination image.
range
hist	Histogram.
method	Comparison method passed to cvCompareHist (see the function description).
factor	Normalization factor for histograms that affects the normalization scale of the destination image. Pass 1 if not sure.

See also:

cvCalcBackProjectPatch

The function calculates the object probability density from two histograms as:

Parameters:

hist1	First histogram (the divisor).
hist2	Second histogram.
dst_hist	Destination histogram.
scale	Scale factor for the destination histogram.

See also:

cv::equalizeHist

cv::distanceTransform

The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and CV_ADAPTIVE_THRESH_GAUSSIAN_C are: neighborhood size (3, 5, 7 etc.), and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)

See also:

cv::adaptiveThreshold

cv::floodFill

cv::Canny

Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy. Applying threshold to the result gives coordinates of corners

See also:

cv::preCornerDetect

cv::cornerEigenValsAndVecs

cv::cornerMinEigenVal

Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel

See also:

cv::cornerHarris

cv::cornerSubPix

cv::goodFeaturesToTrack

cv::fitLine

cv::line

if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn

See also:

cv::rectangle

cv::rectangle

Thickness works in the same way as with cvRectangle

See also:

cv::circle

depending on _thickness_, _start_angle_ and _end_angle_ parameters. The resultant figure is rotated by _angle_. All the angles are in degrees

See also:

cv::ellipse

cv::fillConvexPoly

cv::fillPoly

cv::polylines

The function initializes the font structure that can be passed to text rendering functions.

Parameters:

font	Pointer to the font structure initialized by the function
font_face	Font name identifier. See cv::HersheyFonts and corresponding old CV_* identifiers.
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.
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.
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.
thickness	Thickness of the text strokes
line_type	Type of the strokes, see line description

See also:

cvPutText

CvFont should be initialized with cvInitFont

See also:

cvInitFont, cvGetTextSize, cvFont, cv::putText

cv::getTextSize

cv::drawContours

Adds image to accumulator.

Draws contour outlines or filled interiors on the image.

Calculates bounding box of text stroke (useful for alignment)

Renders text stroke with specified font and color at specified location.

Initializes font structure (OpenCV 1.x API).

Draws one or more polygonal curves.

Fills an area bounded by one or more arbitrary polygons.

Fills convex or monotonous polygon.

Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector.

Draws a circle with specified center and radius.

Draws a rectangle specified by a CvRect structure.

Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)

Draws 4-connected, 8-connected or antialiased line segment connecting two points.

Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)

Finds a sparse set of points within the selected region that seem to be easy to track.

Adjust corner position using some sort of gradient search.

Harris corner detector:

Calculates minimal eigenvalue for 2x2 gradient covariation matrix at every image pixel.

Calculates eigen values and vectors of 2x2 gradient covariation matrix at every image pixel.

Calculates constraint image for corner detection.

Runs canny edge detector.

Fills the connected component until the color difference gets large enough.

Applies adaptive threshold to grayscale image.

Applies distance transform to binary image.

equalizes histogram of 8-bit single-channel image

Divides one histogram by another.

Locates a template within an image by using a histogram comparison.

Calculates back project.

Calculates array histogram.

Calculates bayesian probabilistic histograms (each or src and dst is an array of _number_ histograms.

Copies a histogram.

Thresholds the histogram.

Normalizes the histogram.

Finds the minimum and maximum histogram bins.

Clears the histogram.

Releases the histogram.

Sets the bounds of the histogram bins.

Finds coordinates of the box vertices.

Initializes Freeman chain reader.

Substitutes the last retrieved contour with the new one.

Measures similarity between template and overlapped windows in the source image and fills the resultant image with the measurements.

Retrieves quadrangle from the input array.

Retrieves the rectangular image region with specified center from the input array.

Calculates 7 Hu's invariants from precalculated spatial and central moments.

Calculates all spatial and central moments up to the 3rd order.

Performs complex morphological transformation.

dilates input image (applies maximum filter) one or more times.

erodes input image (applies minimum filter) one or more times.

releases structuring element

Computes the original (undistorted) feature coordinates from the observed (distorted) coordinates.

Computes undistortion+rectification map for a head of stereo camera.

Computes transformation map from intrinsic camera parameters that can used by cvRemap.

Transforms the input image to compensate lens distortion.

Performs forward or inverse linear-polar image transform.

Performs forward or inverse log-polar image transform.

Converts mapx & mapy from floating-point to integer formats for cvRemap.

Performs generic geometric transformation using the specified coordinate maps.

Warps image with perspective (projective) transform.

Warps image with affine transform.

Resizes image (input array is resized to fit the destination array)

Converts input array pixels from one color space to another.

Calculates the image Laplacian: (d2/dx + d2/dy)I.

Calculates an image derivative using generalized Sobel.

Segments image using seed "markers".

Filters image using meanshift algorithm.

Releases pyramid.

Up-samples image and smoothes the result with gaussian kernel.

Smoothes the input image with gaussian kernel and then down-samples it.

Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y)

Convolves an image with the kernel.

Smooths the image in one of several ways.

Copies source 2D array inside of the larger destination array and makes a border of the specified type (IPL_BORDER_*) around the copied area.

Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha.

Adds a product of two images to accumulator.

Adds squared image to accumulator.

See also:

cv::accumulate

cv::accumulateSquare

cv::accumulateProduct

cv::accumulateWeighted

Parameters:

src	The source image
dst	The destination image
smoothtype	Type of the smoothing, see SmoothMethod_c
size1	The first parameter of the smoothing operation, the aperture width. Must be a positive odd number (1, 3, 5, ...)
size2	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 size2 is zero, it is set to size1. Otherwise it must be a positive odd number.
sigma1	In the case of a Gaussian parameter this parameter may specify Gaussian (standard deviation). If it is zero, it is calculated from the kernel size: Using standard sigma for small kernels ( to ) gives better speed. If sigma1 is not zero, while size1 and size2 are zeros, the kernel size is calculated from the sigma (to provide accurate enough operation).
sigma2	additional parameter for bilateral filtering

See also:

cv::GaussianBlur, cv::blur, cv::medianBlur, cv::bilateralFilter.

Parameters:

src	input image.
dst	output image of the same size and the same number of channels as src.
kernel	convolution kernel (or rather a correlation 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 split and process them individually.
anchor	anchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.

See also:

cv::filter2D

cv::integral

dst_width = floor(src_width/2)[+1], dst_height = floor(src_height/2)[+1]

See also:

cv::pyrDown

dst_width = src_width*2, dst_height = src_height*2

See also:

cv::pyrUp

cv::pyrMeanShiftFiltering

cv::watershed

(aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator. Scharr can be used only for the first dx or dy derivative

See also:

cv::Sobel

cv::Laplacian

cv::cvtColor

cv::resize

Note:

cvGetQuadrangleSubPix is similar to cvWarpAffine, but the outliers are extrapolated using replication border mode.

See also:

cv::warpAffine

cv::warpPerspective

cv::remap

cv::convertMaps

cv::logPolar

cv::linearPolar

cv::undistort

cv::initUndistortRectifyMap

cv::undistortPoints

cvCreateStructuringElementEx

If element pointer is NULL, 3x3 rectangular element is used

See also:

cv::erode

If element pointer is NULL, 3x3 rectangular element is used

See also:

cv::dilate

cv::morphologyEx

cv::moments

cv::HuMoments

dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2). Values of pixels with fractional coordinates are retrieved using bilinear interpolation

See also:

cv::getRectSubPix

matrixarr = ( a11 a12 | b1 ) dst(x,y) <- src(A[x y]' + b) ( a21 a22 | b2 ) (bilinear interpolation is used to retrieve pixels with fractional coordinates)

See also:

cvWarpAffine

cv::matchTemplate

(if the substitutor is null, the last retrieved contour is removed from the tree)

See also:

cvFindContours

The reader is used to iteratively get coordinates of all the chain points. If the Freeman codes should be read as is, a simple sequence reader should be used

See also:

cvApproxChains

This is a standalone function for setting bin ranges in the histogram. For a more detailed description of the parameters ranges and uniform, see the :ocvCalcHist function that can initialize the ranges as well. Ranges for the histogram bins must be set before the histogram is calculated or the backproject of the histogram is calculated.

Parameters:

hist	Histogram.
ranges	Array of bin ranges arrays. See :ocvCreateHist for details.
uniform	Uniformity flag. See :ocvCreateHist for details.

The function releases the histogram (header and the data). The pointer to the histogram is cleared by the function. If \*hist pointer is already NULL, the function does nothing.

Parameters:

hist	Double pointer to the released histogram.

The function sets all of the histogram bins to 0 in case of a dense histogram and removes all histogram bins in case of a sparse array.

Parameters:

hist	Histogram.

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 the lexicographical order) are returned. In case of several maximums or minimums, the earliest in the lexicographical order (extrema locations) is returned.

Parameters:

hist	Histogram.
min_value	Pointer to the minimum value of the histogram.
max_value	Pointer to the maximum value of the histogram.
min_idx	Pointer to the array of coordinates for the minimum.
max_idx	Pointer to the array of coordinates for the maximum.

The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to factor.

Parameters:

hist	Pointer to the histogram.
factor	Normalization factor.

The function clears histogram bins that are below the specified threshold.

Parameters:

hist	Pointer to the histogram.
threshold	Threshold level.

The function makes a copy of the histogram. If the second histogram pointer \*dst is NULL, a new histogram of the same size as src is created. Otherwise, both histograms must have equal types and sizes. Then the function copies the bin values of the source histogram to the destination histogram and sets the same bin value ranges as in src.

Parameters:

src	Source histogram.
dst	Pointer to the destination histogram.

See also:

cv::calcHist

cvCalcBackProject, cv::calcBackProject

The function calculates the back projection by comparing histograms of the source image patches with the given histogram. The function is similar to matchTemplate, but instead of comparing the raster patch with all its possible positions within the search window, the function CalcBackProjectPatch compares histograms. See the algorithm diagram below:


Parameters:

image	Source images (though, you may pass CvMat\*\* as well).
dst	Destination image.
range
hist	Histogram.
method	Comparison method passed to cvCompareHist (see the function description).
factor	Normalization factor for histograms that affects the normalization scale of the destination image. Pass 1 if not sure.

See also:

cvCalcBackProjectPatch

The function calculates the object probability density from two histograms as:

Parameters:

hist1	First histogram (the divisor).
hist2	Second histogram.
dst_hist	Destination histogram.
scale	Scale factor for the destination histogram.

See also:

cv::equalizeHist

cv::distanceTransform

The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and CV_ADAPTIVE_THRESH_GAUSSIAN_C are: neighborhood size (3, 5, 7 etc.), and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)

See also:

cv::adaptiveThreshold

cv::floodFill

cv::Canny

Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy. Applying threshold to the result gives coordinates of corners

See also:

cv::preCornerDetect

cv::cornerEigenValsAndVecs

cv::cornerMinEigenVal

Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel

See also:

cv::cornerHarris

cv::cornerSubPix

cv::goodFeaturesToTrack

cv::fitLine

cv::line

if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn

See also:

cv::rectangle

cv::rectangle

Thickness works in the same way as with cvRectangle

See also:

cv::circle

depending on _thickness_, _start_angle_ and _end_angle_ parameters. The resultant figure is rotated by _angle_. All the angles are in degrees

See also:

cv::ellipse

cv::fillConvexPoly

cv::fillPoly

cv::polylines

The function initializes the font structure that can be passed to text rendering functions.

Parameters:

font	Pointer to the font structure initialized by the function
font_face	Font name identifier. See cv::HersheyFonts and corresponding old CV_* identifiers.
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.
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.
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.
thickness	Thickness of the text strokes
line_type	Type of the strokes, see line description

See also:

cvPutText

CvFont should be initialized with cvInitFont

See also:

cvInitFont, cvGetTextSize, cvFont, cv::putText

cv::getTextSize

cv::drawContours

Computes earth mover distance between two weighted point sets (called signatures)

See also:

cv::EMD

Unpacks color value.

if arrtype is CV_8UC?, _color_ is treated as packed color value, otherwise the first channels (depending on arrtype) of destination scalar are set to the same value = _color_

Retrieve spatial moments.

Applies fixed-level threshold to grayscale image.

Compares two histogram.

Checks whether the point is inside polygon, outside, on an edge (at a vertex).

Compares two contours by matching their moments.

Calculates area of a contour or contour segment.

Calculates perimeter of a contour or length of a part of contour.

Retrieve normalized central moments.

Retrieve central moments.

See also:

cv::arcLength

cv::contourArea

cv::matchShapes

Returns positive, negative or zero value, correspondingly. Optionally, measures a signed distance between the point and the nearest polygon edge (measure_dist=1)

See also:

cv::pointPolygonTest

This is a basic operation applied before retrieving contours

See also:

cv::threshold

Calculates the dot product of two arrays in Euclidean metrics.

Applies fixed-level threshold to grayscale image.

Compares two histogram.

Checks whether the point is inside polygon, outside, on an edge (at a vertex).

Compares two contours by matching their moments.

Calculates area of a contour or contour segment.

Calculates perimeter of a contour or length of a part of contour.

Retrieve normalized central moments.

Retrieve central moments.

Finds norm, difference norm or relative difference norm for an array (or two arrays)

Calculates Mahalanobis(weighted) distance.

Calculates determinant of input matrix.

Inverts matrix.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

arr	Input array. Must have a single channel.
idx	Array of the element indices

The function calculates and returns the Euclidean dot product of two arrays.

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 . The function can process multi-dimensional arrays, row by row, layer by layer, and so on.

Parameters:

src1	The first source array
src2	The second source array

See also:

ref core_c_NormFlags "flags"

cv::arcLength

cv::contourArea

cv::matchShapes

Returns positive, negative or zero value, correspondingly. Optionally, measures a signed distance between the point and the nearest polygon edge (measure_dist=1)

See also:

cv::pointPolygonTest

This is a basic operation applied before retrieving contours

See also:

cv::threshold

Returns a structuring element of the specified size and shape for morphological operations.

Note:

the created structuring element IplConvKernel\* element must be released in the end using `cvReleaseStructuringElement(&element)`.

Parameters:

cols	Width of the structuring element
rows	Height of the structuring element
anchor_x	x-coordinate of the anchor
anchor_y	y-coordinate of the anchor
shape	element shape that could be one of the cv::MorphShapes_c
values	integer array of cols*rows elements that specifies the custom shape of the structuring element, when shape=CV_SHAPE_CUSTOM.

See also:

cv::getStructuringElement

Builds pyramid for an image.

See also:

buildPyramid

Retrieves the next chain point.

See also:

cvApproxChains

Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2)

Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3)

Computes rotation_matrix matrix.

See also:

cv::getAffineTransform

cv::getRotationMatrix2D

cv::getPerspectiveTransform

Finds minimum area rotated rectangle bounding a set of points.

Fits ellipse into a set of 2d points.

See also:

cv::minAreaRect

cv::fitEllipse

Calculates contour bounding rectangle (update=1) or just retrieves pre-calculated rectangle (update=0)

Finds minimum rectangle containing two given rectangles.

See also:

cv::boundingRect

Fetches pixels that belong to the specified line segment and stores them to the buffer.

Returns the polygon points which make up the given ellipse.

Initializes line iterator.

Clips the line segment connecting *pt1 and *pt2 by the rectangular window.

Checks whether the contour is convex or not (returns 1 if convex, 0 if not)

Finds minimum enclosing circle for a set of points.

Retrieves outer and optionally inner boundaries of white (non-zero) connected components in the black (zero) background.

Returns the number of retrieved points.

See also:

cv::LineSegmentDetector

cv::findContours, cvStartFindContours, cvFindNextContour, cvSubstituteContour, cvEndFindContours

cv::minEnclosingCircle

cv::isContourConvex

(0<=x<img_size.width, 0<=y<img_size.height).

See also:

cv::clipLine

Initially, line_iterator->ptr will point to pt1 (or pt2, see left_to_right description) location in the image. Returns the number of pixels on the line between the ending points.

See also:

cv::LineIterator

The ellipse is define by the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep of the ellipse arc can be done by spcifying arc_start and arc_end to be something other than 0 and 360, respectively. The input array 'pts' must be large enough to hold the result. The total number of points stored into 'pts' is returned by this function.

See also:

cv::ellipse2Poly

Creates a histogram.

Makes a histogram out of an array.

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 cvSetHistBinRanges. Though cvCalcHist and cvCalcBackProject may process 8-bit images without setting bin ranges, they assume they are equally spaced in 0 to 255 bins.

Parameters:

dims	Number of histogram dimensions.
sizes	Array of the histogram dimension sizes.
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.
ranges	Array of ranges for the histogram bins. Its meaning depends on the uniform parameter value. The ranges are used when the histogram is calculated or backprojected to determine which histogram bin corresponds to which value/tuple of values from the input image(s).
uniform	Uniformity flag. If not zero, the histogram has evenly spaced bins and for every 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 the i-th element of the ranges array contains dims[i]+1 elements: where and are lower and upper boundaries of the i-th input tuple value for the j-th bin, respectively. In either case, the input values that are beyond the specified range for a histogram bin are not counted by cvCalcHist and filled with 0 by cvCalcBackProject.

The function initializes the histogram, whose header and bins are allocated by the user. cvReleaseHist does not need to be called afterwards. Only dense histograms can be initialized this way. The function returns hist.

Parameters:

dims	Number of the histogram dimensions.
sizes	Array of the histogram dimension sizes.
hist	Histogram header initialized by the function.
data	Array used to store histogram bins.
ranges	Histogram bin ranges. See cvCreateHist for details.
uniform	Uniformity flag. See cvCreateHist for details.

Initializes contour retrieving process.

Calls cvStartFindContours. Calls cvFindNextContour until null pointer is returned or some other condition becomes true. Calls cvEndFindContours at the end.

See also:

cvFindContours

Retrieves next contour.

Finds circles in the image.

Finds lines on binary image using one of several methods.

Initializes sequence header for a matrix (column or row vector) of points.

Finds convexity defects for the contour.

Calculates exact convex hull of 2d point set.

Approximates a single polygonal curve (contour) or a tree of polygonal curves (contours)

Approximates Freeman chain(s) with a polygonal curve.

Releases contour scanner and returns pointer to the first outer contour.

See also:

cvFindContours

This is a standalone contour approximation routine, not represented in the new interface. When cvFindContours retrieves contours as Freeman chains, it calls the function to get approximated contours, represented as polygons.

Parameters:

src_seq	Pointer to the approximated Freeman chain that can refer to other chains.
storage	Storage location for the resulting polylines.
method	Approximation method (see the description of the function :ocvFindContours ).
parameter	Method parameter (not used now).
minimal_perimeter	Approximates only those contours whose perimeters are not less than minimal_perimeter . Other chains are removed from the resulting structure.
recursive	Recursion flag. If it is non-zero, the function approximates all chains that can be obtained from chain by using the h_next or v_next links. Otherwise, the single input chain is approximated.

See also:

cvStartReadChainPoints, cvReadChainPoint

cv::approxPolyDP

cv::convexHull

cv::convexityDefects

a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!)

line_storage is either memory storage or 1 x _max number of lines_ CvMat, its number of columns is changed by the function. method is one of CV_HOUGH_*; rho, theta and threshold are used for each of those methods; param1 ~ line length, param2 ~ line gap - for probabilistic, param1 ~ srn, param2 ~ stn - for multi-scale

See also:

cv::HoughLines

cv::HoughCircles

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 771 of file imgproc_c.h.

same as cvArcLength for closed contour

Definition at line 530 of file imgproc_c.h.