/*M///////////////////////////////////////////////////////////////////////////////////////
|
//
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
//
|
// By downloading, copying, installing or using the software you agree to this license.
|
// If you do not agree to this license, do not download, install,
|
// copy or use the software.
|
//
|
//
|
// License Agreement
|
// For Open Source Computer Vision Library
|
//
|
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
// Third party copyrights are property of their respective owners.
|
//
|
// Redistribution and use in source and binary forms, with or without modification,
|
// are permitted provided that the following conditions are met:
|
//
|
// * Redistribution's of source code must retain the above copyright notice,
|
// this list of conditions and the following disclaimer.
|
//
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
// this list of conditions and the following disclaimer in the documentation
|
// and/or other materials provided with the distribution.
|
//
|
// * The name of the copyright holders may not be used to endorse or promote products
|
// derived from this software without specific prior written permission.
|
//
|
// This software is provided by the copyright holders and contributors "as is" and
|
// any express or implied warranties, including, but not limited to, the implied
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
// indirect, incidental, special, exemplary, or consequential damages
|
// (including, but not limited to, procurement of substitute goods or services;
|
// loss of use, data, or profits; or business interruption) however caused
|
// and on any theory of liability, whether in contract, strict liability,
|
// or tort (including negligence or otherwise) arising in any way out of
|
// the use of this software, even if advised of the possibility of such damage.
|
//
|
//M*/
|
|
|
#ifndef __OPENCV_CORE_C_H__
|
#define __OPENCV_CORE_C_H__
|
|
#include "opencv2/core/types_c.h"
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
/****************************************************************************************\
|
* Array allocation, deallocation, initialization and access to elements *
|
\****************************************************************************************/
|
|
/* <malloc> wrapper.
|
If there is no enough memory, the function
|
(as well as other OpenCV functions that call cvAlloc)
|
raises an error. */
|
CVAPI(void*) cvAlloc( size_t size );
|
|
/* <free> wrapper.
|
Here and further all the memory releasing functions
|
(that all call cvFree) take double pointer in order to
|
to clear pointer to the data after releasing it.
|
Passing pointer to NULL pointer is Ok: nothing happens in this case
|
*/
|
CVAPI(void) cvFree_( void* ptr );
|
#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
|
|
/* Allocates and initializes IplImage header */
|
CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
|
|
/* Inializes IplImage header */
|
CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
|
int channels, int origin CV_DEFAULT(0),
|
int align CV_DEFAULT(4));
|
|
/* Creates IPL image (header and data) */
|
CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
|
|
/* Releases (i.e. deallocates) IPL image header */
|
CVAPI(void) cvReleaseImageHeader( IplImage** image );
|
|
/* Releases IPL image header and data */
|
CVAPI(void) cvReleaseImage( IplImage** image );
|
|
/* Creates a copy of IPL image (widthStep may differ) */
|
CVAPI(IplImage*) cvCloneImage( const IplImage* image );
|
|
/* Sets a Channel Of Interest (only a few functions support COI) -
|
use cvCopy to extract the selected channel and/or put it back */
|
CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
|
|
/* Retrieves image Channel Of Interest */
|
CVAPI(int) cvGetImageCOI( const IplImage* image );
|
|
/* Sets image ROI (region of interest) (COI is not changed) */
|
CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
|
|
/* Resets image ROI and COI */
|
CVAPI(void) cvResetImageROI( IplImage* image );
|
|
/* Retrieves image ROI */
|
CVAPI(CvRect) cvGetImageROI( const IplImage* image );
|
|
/* Allocates and initializes CvMat header */
|
CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
|
|
#define CV_AUTOSTEP 0x7fffffff
|
|
/* Initializes CvMat header */
|
CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
|
int type, void* data CV_DEFAULT(NULL),
|
int step CV_DEFAULT(CV_AUTOSTEP) );
|
|
/* Allocates and initializes CvMat header and allocates data */
|
CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
|
|
/* Releases CvMat header and deallocates matrix data
|
(reference counting is used for data) */
|
CVAPI(void) cvReleaseMat( CvMat** mat );
|
|
/* Decrements CvMat data reference counter and deallocates the data if
|
it reaches 0 */
|
CV_INLINE void cvDecRefData( CvArr* arr )
|
{
|
if( CV_IS_MAT( arr ))
|
{
|
CvMat* mat = (CvMat*)arr;
|
mat->data.ptr = NULL;
|
if( mat->refcount != NULL && --*mat->refcount == 0 )
|
cvFree( &mat->refcount );
|
mat->refcount = NULL;
|
}
|
else if( CV_IS_MATND( arr ))
|
{
|
CvMatND* mat = (CvMatND*)arr;
|
mat->data.ptr = NULL;
|
if( mat->refcount != NULL && --*mat->refcount == 0 )
|
cvFree( &mat->refcount );
|
mat->refcount = NULL;
|
}
|
}
|
|
/* Increments CvMat data reference counter */
|
CV_INLINE int cvIncRefData( CvArr* arr )
|
{
|
int refcount = 0;
|
if( CV_IS_MAT( arr ))
|
{
|
CvMat* mat = (CvMat*)arr;
|
if( mat->refcount != NULL )
|
refcount = ++*mat->refcount;
|
}
|
else if( CV_IS_MATND( arr ))
|
{
|
CvMatND* mat = (CvMatND*)arr;
|
if( mat->refcount != NULL )
|
refcount = ++*mat->refcount;
|
}
|
return refcount;
|
}
|
|
|
/* Creates an exact copy of the input matrix (except, may be, step value) */
|
CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
|
|
|
/* Makes a new matrix from <rect> subrectangle of input array.
|
No data is copied */
|
CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
|
#define cvGetSubArr cvGetSubRect
|
|
/* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
|
(end_row is not included into the span). */
|
CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
|
int start_row, int end_row,
|
int delta_row CV_DEFAULT(1));
|
|
CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )
|
{
|
return cvGetRows( arr, submat, row, row + 1, 1 );
|
}
|
|
|
/* Selects column span of the input array: arr(:,start_col:end_col)
|
(end_col is not included into the span) */
|
CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
|
int start_col, int end_col );
|
|
CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
|
{
|
return cvGetCols( arr, submat, col, col + 1 );
|
}
|
|
/* Select a diagonal of the input array.
|
(diag = 0 means the main diagonal, >0 means a diagonal above the main one,
|
<0 - below the main one).
|
The diagonal will be represented as a column (nx1 matrix). */
|
CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
|
int diag CV_DEFAULT(0));
|
|
/* low-level scalar <-> raw data conversion functions */
|
CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
|
int extend_to_12 CV_DEFAULT(0) );
|
|
CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
|
|
/* Allocates and initializes CvMatND header */
|
CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
|
|
/* Allocates and initializes CvMatND header and allocates data */
|
CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
|
|
/* Initializes preallocated CvMatND header */
|
CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
|
int type, void* data CV_DEFAULT(NULL) );
|
|
/* Releases CvMatND */
|
CV_INLINE void cvReleaseMatND( CvMatND** mat )
|
{
|
cvReleaseMat( (CvMat**)mat );
|
}
|
|
/* Creates a copy of CvMatND (except, may be, steps) */
|
CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
|
|
/* Allocates and initializes CvSparseMat header and allocates data */
|
CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
|
|
/* Releases CvSparseMat */
|
CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
|
|
/* Creates a copy of CvSparseMat (except, may be, zero items) */
|
CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
|
|
/* Initializes sparse array iterator
|
(returns the first node or NULL if the array is empty) */
|
CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
|
CvSparseMatIterator* mat_iterator );
|
|
// returns next sparse array node (or NULL if there is no more nodes)
|
CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
|
{
|
if( mat_iterator->node->next )
|
return mat_iterator->node = mat_iterator->node->next;
|
else
|
{
|
int idx;
|
for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
|
{
|
CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
|
if( node )
|
{
|
mat_iterator->curidx = idx;
|
return mat_iterator->node = node;
|
}
|
}
|
return NULL;
|
}
|
}
|
|
/**************** matrix iterator: used for n-ary operations on dense arrays *********/
|
|
#define CV_MAX_ARR 10
|
|
typedef struct CvNArrayIterator
|
{
|
int count; /* number of arrays */
|
int dims; /* number of dimensions to iterate */
|
CvSize size; /* maximal common linear size: { width = size, height = 1 } */
|
uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */
|
int stack[CV_MAX_DIM]; /* for internal use */
|
CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the
|
matrices that are processed */
|
}
|
CvNArrayIterator;
|
|
#define CV_NO_DEPTH_CHECK 1
|
#define CV_NO_CN_CHECK 2
|
#define CV_NO_SIZE_CHECK 4
|
|
/* initializes iterator that traverses through several arrays simulteneously
|
(the function together with cvNextArraySlice is used for
|
N-ari element-wise operations) */
|
CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
|
const CvArr* mask, CvMatND* stubs,
|
CvNArrayIterator* array_iterator,
|
int flags CV_DEFAULT(0) );
|
|
/* returns zero value if iteration is finished, non-zero (slice length) otherwise */
|
CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
|
|
|
/* Returns type of array elements:
|
CV_8UC1 ... CV_64FC4 ... */
|
CVAPI(int) cvGetElemType( const CvArr* arr );
|
|
/* Retrieves number of an array dimensions and
|
optionally sizes of the dimensions */
|
CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
|
|
|
/* Retrieves size of a particular array dimension.
|
For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)
|
and cvGetDimSize(arr,1) returns number of columns (image width) */
|
CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
|
|
|
/* ptr = &arr(idx0,idx1,...). All indexes are zero-based,
|
the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */
|
CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
|
CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
|
CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
|
int* type CV_DEFAULT(NULL));
|
|
/* For CvMat or IplImage number of indices should be 2
|
(row index (y) goes first, column index (x) goes next).
|
For CvMatND or CvSparseMat number of infices should match number of <dims> and
|
indices order should match the array dimension order. */
|
CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),
|
int create_node CV_DEFAULT(1),
|
unsigned* precalc_hashval CV_DEFAULT(NULL));
|
|
/* value = arr(idx0,idx1,...) */
|
CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
|
CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
|
CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
|
CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
|
|
/* for 1-channel arrays */
|
CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
|
CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
|
CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
|
CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
|
|
/* arr(idx0,idx1,...) = value */
|
CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
|
CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
|
CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
|
CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
|
|
/* for 1-channel arrays */
|
CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
|
CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
|
CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
|
int idx1, int idx2, double value );
|
CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
|
|
/* clears element of ND dense array,
|
in case of sparse arrays it deletes the specified node */
|
CVAPI(void) cvClearND( CvArr* arr, const int* idx );
|
|
/* Converts CvArr (IplImage or CvMat,...) to CvMat.
|
If the last parameter is non-zero, function can
|
convert multi(>2)-dimensional array to CvMat as long as
|
the last array's dimension is continous. The resultant
|
matrix will be have appropriate (a huge) number of rows */
|
CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
|
int* coi CV_DEFAULT(NULL),
|
int allowND CV_DEFAULT(0));
|
|
/* Converts CvArr (IplImage or CvMat) to IplImage */
|
CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
|
|
|
/* Changes a shape of multi-dimensional array.
|
new_cn == 0 means that number of channels remains unchanged.
|
new_dims == 0 means that number and sizes of dimensions remain the same
|
(unless they need to be changed to set the new number of channels)
|
if new_dims == 1, there is no need to specify new dimension sizes
|
The resultant configuration should be achievable w/o data copying.
|
If the resultant array is sparse, CvSparseMat header should be passed
|
to the function else if the result is 1 or 2 dimensional,
|
CvMat header should be passed to the function
|
else CvMatND header should be passed */
|
CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
|
int sizeof_header, CvArr* header,
|
int new_cn, int new_dims, int* new_sizes );
|
|
#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \
|
cvReshapeMatND( (arr), sizeof(*(header)), (header), \
|
(new_cn), (new_dims), (new_sizes))
|
|
CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
|
int new_cn, int new_rows CV_DEFAULT(0) );
|
|
/* Repeats source 2d array several times in both horizontal and
|
vertical direction to fill destination array */
|
CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
|
|
/* Allocates array data */
|
CVAPI(void) cvCreateData( CvArr* arr );
|
|
/* Releases array data */
|
CVAPI(void) cvReleaseData( CvArr* arr );
|
|
/* Attaches user data to the array header. The step is reffered to
|
the pre-last dimension. That is, all the planes of the array
|
must be joint (w/o gaps) */
|
CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
|
|
/* Retrieves raw data of CvMat, IplImage or CvMatND.
|
In the latter case the function raises an error if
|
the array can not be represented as a matrix */
|
CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
|
int* step CV_DEFAULT(NULL),
|
CvSize* roi_size CV_DEFAULT(NULL));
|
|
/* Returns width and height of array in elements */
|
CVAPI(CvSize) cvGetSize( const CvArr* arr );
|
|
/* Copies source array to destination array */
|
CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
/* Sets all or "masked" elements of input array
|
to the same value*/
|
CVAPI(void) cvSet( CvArr* arr, CvScalar value,
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
/* Clears all the array elements (sets them to 0) */
|
CVAPI(void) cvSetZero( CvArr* arr );
|
#define cvZero cvSetZero
|
|
|
/* Splits a multi-channel array into the set of single-channel arrays or
|
extracts particular [color] plane */
|
CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
|
CvArr* dst2, CvArr* dst3 );
|
|
/* Merges a set of single-channel arrays into the single multi-channel array
|
or inserts one particular [color] plane to the array */
|
CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,
|
const CvArr* src2, const CvArr* src3,
|
CvArr* dst );
|
|
/* Copies several channels from input arrays to
|
certain channels of output arrays */
|
CVAPI(void) cvMixChannels( const CvArr** src, int src_count,
|
CvArr** dst, int dst_count,
|
const int* from_to, int pair_count );
|
|
/* Performs linear transformation on every source array element:
|
dst(x,y,c) = scale*src(x,y,c)+shift.
|
Arbitrary combination of input and output array depths are allowed
|
(number of channels must be the same), thus the function can be used
|
for type conversion */
|
CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst,
|
double scale CV_DEFAULT(1),
|
double shift CV_DEFAULT(0) );
|
#define cvCvtScale cvConvertScale
|
#define cvScale cvConvertScale
|
#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )
|
|
|
/* 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).
|
destination array must have 8u type.
|
In other cases one may use cvConvertScale + cvAbsDiffS */
|
CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst,
|
double scale CV_DEFAULT(1),
|
double shift CV_DEFAULT(0) );
|
#define cvCvtScaleAbs cvConvertScaleAbs
|
|
|
/* checks termination criteria validity and
|
sets eps to default_eps (if it is not set),
|
max_iter to default_max_iters (if it is not set)
|
*/
|
CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
|
double default_eps,
|
int default_max_iters );
|
|
/****************************************************************************************\
|
* Arithmetic, logic and comparison operations *
|
\****************************************************************************************/
|
|
/* dst(mask) = src1(mask) + src2(mask) */
|
CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(mask) = src(mask) + value */
|
CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(mask) = src1(mask) - src2(mask) */
|
CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(mask) = src(mask) - value = src(mask) + (-value) */
|
CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL))
|
{
|
cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
|
dst, mask );
|
}
|
|
/* dst(mask) = value - src(mask) */
|
CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
|
const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src1(idx) * src2(idx) * scale
|
(scaled element-wise multiplication of 2 arrays) */
|
CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, double scale CV_DEFAULT(1) );
|
|
/* element-wise division/inversion with scaling:
|
dst(idx) = src1(idx) * scale / src2(idx)
|
or dst(idx) = scale / src2(idx) if src1 == 0 */
|
CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, double scale CV_DEFAULT(1));
|
|
/* dst = src1 * scale + src2 */
|
CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,
|
const CvArr* src2, CvArr* dst );
|
#define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
|
|
/* dst = src1 * alpha + src2 * beta + gamma */
|
CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
|
const CvArr* src2, double beta,
|
double gamma, CvArr* dst );
|
|
/* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */
|
CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
|
|
/* dst(idx) = src1(idx) & src2(idx) */
|
CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src(idx) & value */
|
CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src1(idx) | src2(idx) */
|
CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src(idx) | value */
|
CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src1(idx) ^ src2(idx) */
|
CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = src(idx) ^ value */
|
CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
|
CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
|
|
/* dst(idx) = ~src(idx) */
|
CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
|
|
/* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
|
CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
|
const CvArr* upper, CvArr* dst );
|
|
/* dst(idx) = lower <= src(idx) < upper */
|
CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
|
CvScalar upper, CvArr* dst );
|
|
#define CV_CMP_EQ 0
|
#define CV_CMP_GT 1
|
#define CV_CMP_GE 2
|
#define CV_CMP_LT 3
|
#define CV_CMP_LE 4
|
#define CV_CMP_NE 5
|
|
/* The comparison operation support single-channel arrays only.
|
Destination image should be 8uC1 or 8sC1 */
|
|
/* dst(idx) = src1(idx) _cmp_op_ src2(idx) */
|
CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
|
|
/* dst(idx) = src1(idx) _cmp_op_ value */
|
CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
|
|
/* dst(idx) = min(src1(idx),src2(idx)) */
|
CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
|
|
/* dst(idx) = max(src1(idx),src2(idx)) */
|
CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
|
|
/* dst(idx) = min(src(idx),value) */
|
CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
|
|
/* dst(idx) = max(src(idx),value) */
|
CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
|
|
/* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
|
CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
|
|
/* dst(x,y,c) = abs(src(x,y,c) - value(c)) */
|
CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
|
#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
|
|
/****************************************************************************************\
|
* Math operations *
|
\****************************************************************************************/
|
|
/* Does cartesian->polar coordinates conversion.
|
Either of output components (magnitude or angle) is optional */
|
CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,
|
CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
|
int angle_in_degrees CV_DEFAULT(0));
|
|
/* Does polar->cartesian coordinates conversion.
|
Either of output components (magnitude or angle) is optional.
|
If magnitude is missing it is assumed to be all 1's */
|
CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
|
CvArr* x, CvArr* y,
|
int angle_in_degrees CV_DEFAULT(0));
|
|
/* Does powering: dst(idx) = src(idx)^power */
|
CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
|
|
/* Does exponention: dst(idx) = exp(src(idx)).
|
Overflow is not handled yet. Underflow is handled.
|
Maximal relative error is ~7e-6 for single-precision input */
|
CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
|
|
/* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
|
Logarithm of 0 gives large negative number(~-700)
|
Maximal relative error is ~3e-7 for single-precision output
|
*/
|
CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
|
|
/* Fast arctangent calculation */
|
CVAPI(float) cvFastArctan( float y, float x );
|
|
/* Fast cubic root calculation */
|
CVAPI(float) cvCbrt( float value );
|
|
/* Checks array values for NaNs, Infs or simply for too large numbers
|
(if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
|
no runtime errors is raised (function returns zero value in case of "bad" values).
|
Otherwise cvError is called */
|
#define CV_CHECK_RANGE 1
|
#define CV_CHECK_QUIET 2
|
CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
|
double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
|
#define cvCheckArray cvCheckArr
|
|
#define CV_RAND_UNI 0
|
#define CV_RAND_NORMAL 1
|
CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
|
CvScalar param1, CvScalar param2 );
|
|
CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
|
double iter_factor CV_DEFAULT(1.));
|
|
#define CV_SORT_EVERY_ROW 0
|
#define CV_SORT_EVERY_COLUMN 1
|
#define CV_SORT_ASCENDING 0
|
#define CV_SORT_DESCENDING 16
|
|
CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
|
CvArr* idxmat CV_DEFAULT(NULL),
|
int flags CV_DEFAULT(0));
|
|
/* Finds real roots of a cubic equation */
|
CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
|
|
/* Finds all real and complex roots of a polynomial equation */
|
CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,
|
int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
|
|
/****************************************************************************************\
|
* Matrix operations *
|
\****************************************************************************************/
|
|
/* Calculates cross product of two 3d vectors */
|
CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
|
|
/* Matrix transform: dst = A*B + C, C is optional */
|
#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
|
#define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst))
|
|
#define CV_GEMM_A_T 1
|
#define CV_GEMM_B_T 2
|
#define CV_GEMM_C_T 4
|
/* Extended matrix transform:
|
dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
|
CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
|
const CvArr* src3, double beta, CvArr* dst,
|
int tABC CV_DEFAULT(0));
|
#define cvMatMulAddEx cvGEMM
|
|
/* Transforms each element of source array and stores
|
resultant vectors in destination array */
|
CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,
|
const CvMat* transmat,
|
const CvMat* shiftvec CV_DEFAULT(NULL));
|
#define cvMatMulAddS cvTransform
|
|
/* Does perspective transform on every element of input array */
|
CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,
|
const CvMat* mat );
|
|
/* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */
|
CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
|
const CvArr* delta CV_DEFAULT(NULL),
|
double scale CV_DEFAULT(1.) );
|
|
/* Tranposes matrix. Square matrices can be transposed in-place */
|
CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
|
#define cvT cvTranspose
|
|
/* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */
|
CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
|
|
/* Mirror array data around horizontal (flip=0),
|
vertical (flip=1) or both(flip=-1) axises:
|
cvFlip(src) flips images vertically and sequences horizontally (inplace) */
|
CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
|
int flip_mode CV_DEFAULT(0));
|
#define cvMirror cvFlip
|
|
|
#define CV_SVD_MODIFY_A 1
|
#define CV_SVD_U_T 2
|
#define CV_SVD_V_T 4
|
|
/* Performs Singular Value Decomposition of a matrix */
|
CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
|
CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
|
|
/* Performs Singular Value Back Substitution (solves A*X = B):
|
flags must be the same as in cvSVD */
|
CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U,
|
const CvArr* V, const CvArr* B,
|
CvArr* X, int flags );
|
|
#define CV_LU 0
|
#define CV_SVD 1
|
#define CV_SVD_SYM 2
|
#define CV_CHOLESKY 3
|
#define CV_QR 4
|
#define CV_NORMAL 16
|
|
/* Inverts matrix */
|
CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,
|
int method CV_DEFAULT(CV_LU));
|
#define cvInv cvInvert
|
|
/* Solves linear system (src1)*(dst) = (src2)
|
(returns 0 if src1 is a singular and CV_LU method is used) */
|
CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
|
int method CV_DEFAULT(CV_LU));
|
|
/* Calculates determinant of input matrix */
|
CVAPI(double) cvDet( const CvArr* mat );
|
|
/* Calculates trace of the matrix (sum of elements on the main diagonal) */
|
CVAPI(CvScalar) cvTrace( const CvArr* mat );
|
|
/* Finds eigen values and vectors of a symmetric matrix */
|
CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
|
double eps CV_DEFAULT(0),
|
int lowindex CV_DEFAULT(-1),
|
int highindex CV_DEFAULT(-1));
|
|
///* Finds selected eigen values and vectors of a symmetric matrix */
|
//CVAPI(void) cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
|
// int lowindex, int highindex );
|
|
/* Makes an identity matrix (mat_ij = i == j) */
|
CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
|
|
/* Fills matrix with given range of numbers */
|
CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );
|
|
/* Calculates covariation matrix for a set of vectors */
|
/* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */
|
#define CV_COVAR_SCRAMBLED 0
|
|
/* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */
|
#define CV_COVAR_NORMAL 1
|
|
/* do not calc average (i.e. mean vector) - use the input vector instead
|
(useful for calculating covariance matrix by parts) */
|
#define CV_COVAR_USE_AVG 2
|
|
/* scale the covariance matrix coefficients by number of the vectors */
|
#define CV_COVAR_SCALE 4
|
|
/* all the input vectors are stored in a single matrix, as its rows */
|
#define CV_COVAR_ROWS 8
|
|
/* all the input vectors are stored in a single matrix, as its columns */
|
#define CV_COVAR_COLS 16
|
|
CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,
|
CvArr* cov_mat, CvArr* avg, int flags );
|
|
#define CV_PCA_DATA_AS_ROW 0
|
#define CV_PCA_DATA_AS_COL 1
|
#define CV_PCA_USE_AVG 2
|
CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,
|
CvArr* eigenvals, CvArr* eigenvects, int flags );
|
|
CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,
|
const CvArr* eigenvects, CvArr* result );
|
|
CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
|
const CvArr* eigenvects, CvArr* result );
|
|
/* Calculates Mahalanobis(weighted) distance */
|
CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
|
#define cvMahalonobis cvMahalanobis
|
|
/****************************************************************************************\
|
* Array Statistics *
|
\****************************************************************************************/
|
|
/* Finds sum of array elements */
|
CVAPI(CvScalar) cvSum( const CvArr* arr );
|
|
/* Calculates number of non-zero pixels */
|
CVAPI(int) cvCountNonZero( const CvArr* arr );
|
|
/* Calculates mean value of array elements */
|
CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
|
|
/* Calculates mean and standard deviation of pixel values */
|
CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
/* Finds global minimum, maximum and their positions */
|
CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
|
CvPoint* min_loc CV_DEFAULT(NULL),
|
CvPoint* max_loc CV_DEFAULT(NULL),
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
/* types of array norm */
|
#define CV_C 1
|
#define CV_L1 2
|
#define CV_L2 4
|
#define CV_NORM_MASK 7
|
#define CV_RELATIVE 8
|
#define CV_DIFF 16
|
#define CV_MINMAX 32
|
|
#define CV_DIFF_C (CV_DIFF | CV_C)
|
#define CV_DIFF_L1 (CV_DIFF | CV_L1)
|
#define CV_DIFF_L2 (CV_DIFF | CV_L2)
|
#define CV_RELATIVE_C (CV_RELATIVE | CV_C)
|
#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)
|
#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)
|
|
/* Finds norm, difference norm or relative difference norm for an array (or two arrays) */
|
CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
|
int norm_type CV_DEFAULT(CV_L2),
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst,
|
double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
|
int norm_type CV_DEFAULT(CV_L2),
|
const CvArr* mask CV_DEFAULT(NULL) );
|
|
|
#define CV_REDUCE_SUM 0
|
#define CV_REDUCE_AVG 1
|
#define CV_REDUCE_MAX 2
|
#define CV_REDUCE_MIN 3
|
|
CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
|
int op CV_DEFAULT(CV_REDUCE_SUM) );
|
|
/****************************************************************************************\
|
* Discrete Linear Transforms and Related Functions *
|
\****************************************************************************************/
|
|
#define CV_DXT_FORWARD 0
|
#define CV_DXT_INVERSE 1
|
#define CV_DXT_SCALE 2 /* divide result by size of array */
|
#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
|
#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
|
#define CV_DXT_ROWS 4 /* transform each row individually */
|
#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */
|
|
/* Discrete Fourier Transform:
|
complex->complex,
|
real->ccs (forward),
|
ccs->real (inverse) */
|
CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,
|
int nonzero_rows CV_DEFAULT(0) );
|
#define cvFFT cvDFT
|
|
/* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */
|
CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,
|
CvArr* dst, int flags );
|
|
/* Finds optimal DFT vector size >= size0 */
|
CVAPI(int) cvGetOptimalDFTSize( int size0 );
|
|
/* Discrete Cosine Transform */
|
CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
|
|
/****************************************************************************************\
|
* Dynamic data structures *
|
\****************************************************************************************/
|
|
/* Calculates length of sequence slice (with support of negative indices). */
|
CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
|
|
|
/* Creates new memory storage.
|
block_size == 0 means that default,
|
somewhat optimal size, is used (currently, it is 64K) */
|
CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
|
|
|
/* Creates a memory storage that will borrow memory blocks from parent storage */
|
CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
|
|
|
/* Releases memory storage. 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 */
|
CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
|
|
|
/* Clears memory storage. 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 */
|
CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
|
|
/* Remember a storage "free memory" position */
|
CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
|
|
/* Restore a storage "free memory" position */
|
CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
|
|
/* Allocates continuous buffer of the specified size in the storage */
|
CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
|
|
/* Allocates string in memory storage */
|
CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
|
int len CV_DEFAULT(-1) );
|
|
/* Creates new empty sequence that will reside in the specified storage */
|
CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size,
|
size_t elem_size, CvMemStorage* storage );
|
|
/* Changes default size (granularity) of sequence blocks.
|
The default size is ~1Kbyte */
|
CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
|
|
|
/* Adds new element to the end of sequence. Returns pointer to the element */
|
CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
|
|
|
/* Adds new element to the beginning of sequence. Returns pointer to it */
|
CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
|
|
|
/* Removes the last element from sequence and optionally saves it */
|
CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
|
|
|
/* Removes the first element from sequence and optioanally saves it */
|
CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
|
|
|
#define CV_FRONT 1
|
#define CV_BACK 0
|
/* Adds several new elements to the end of sequence */
|
CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements,
|
int count, int in_front CV_DEFAULT(0) );
|
|
/* Removes several elements from the end of sequence and optionally saves them */
|
CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,
|
int count, int in_front CV_DEFAULT(0) );
|
|
/* Inserts a new element in the middle of sequence.
|
cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
|
CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,
|
const void* element CV_DEFAULT(NULL));
|
|
/* Removes specified sequence element */
|
CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
|
|
|
/* Removes all the elements from the sequence. The freed memory
|
can be reused later only by the same sequence unless cvClearMemStorage
|
or cvRestoreMemStoragePos is called */
|
CVAPI(void) cvClearSeq( CvSeq* seq );
|
|
|
/* Retrieves pointer to specified sequence element.
|
Negative indices are supported and mean counting from the end
|
(e.g -1 means the last sequence element) */
|
CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
|
|
/* Calculates index of the specified sequence element.
|
Returns -1 if element does not belong to the sequence */
|
CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
|
CvSeqBlock** block CV_DEFAULT(NULL) );
|
|
/* Initializes sequence writer. The new elements will be added to the end of sequence */
|
CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
|
|
|
/* Combination of cvCreateSeq and cvStartAppendToSeq */
|
CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,
|
int elem_size, CvMemStorage* storage,
|
CvSeqWriter* writer );
|
|
/* Closes sequence writer, updates sequence header and returns pointer
|
to the resultant sequence
|
(which may be useful if the sequence was created using cvStartWriteSeq))
|
*/
|
CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
|
|
|
/* Updates sequence header. May be useful to get access to some of previously
|
written elements via cvGetSeqElem or sequence reader */
|
CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
|
|
|
/* Initializes sequence reader.
|
The sequence can be read in forward or backward direction */
|
CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
|
int reverse CV_DEFAULT(0) );
|
|
|
/* Returns current sequence reader position (currently observed sequence element) */
|
CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
|
|
|
/* Changes sequence reader position. It may seek to an absolute or
|
to relative to the current position */
|
CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,
|
int is_relative CV_DEFAULT(0));
|
|
/* Copies sequence content to a continuous piece of memory */
|
CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
|
CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
|
|
/* Creates sequence header for array.
|
After that all the operations on sequences that do not alter the content
|
can be applied to the resultant sequence */
|
CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
|
int elem_size, void* elements, int total,
|
CvSeq* seq, CvSeqBlock* block );
|
|
/* Extracts sequence slice (with or without copying sequence elements) */
|
CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
|
CvMemStorage* storage CV_DEFAULT(NULL),
|
int copy_data CV_DEFAULT(0));
|
|
CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
|
{
|
return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
|
}
|
|
/* Removes sequence slice */
|
CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
|
|
/* Inserts a sequence or array into another sequence */
|
CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
|
|
/* a < b ? -1 : a > b ? 1 : 0 */
|
typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
|
|
/* Sorts sequence in-place given element comparison function */
|
CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
|
|
/* Finds element in a [sorted] sequence */
|
CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
|
int is_sorted, int* elem_idx,
|
void* userdata CV_DEFAULT(NULL) );
|
|
/* Reverses order of sequence elements in-place */
|
CVAPI(void) cvSeqInvert( CvSeq* seq );
|
|
/* Splits sequence into one or more equivalence classes using the specified criteria */
|
CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
|
CvSeq** labels, CvCmpFunc is_equal, void* userdata );
|
|
/************ Internal sequence functions ************/
|
CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
|
CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
|
|
|
/* Creates a new set */
|
CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,
|
int elem_size, CvMemStorage* storage );
|
|
/* Adds new element to the set and returns pointer to it */
|
CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
|
CvSetElem** inserted_elem CV_DEFAULT(NULL) );
|
|
/* Fast variant of cvSetAdd */
|
CV_INLINE CvSetElem* cvSetNew( CvSet* set_header )
|
{
|
CvSetElem* elem = set_header->free_elems;
|
if( elem )
|
{
|
set_header->free_elems = elem->next_free;
|
elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
|
set_header->active_count++;
|
}
|
else
|
cvSetAdd( set_header, NULL, &elem );
|
return elem;
|
}
|
|
/* Removes set element given its pointer */
|
CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem )
|
{
|
CvSetElem* _elem = (CvSetElem*)elem;
|
assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
|
_elem->next_free = set_header->free_elems;
|
_elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
|
set_header->free_elems = _elem;
|
set_header->active_count--;
|
}
|
|
/* Removes element from the set by its index */
|
CVAPI(void) cvSetRemove( CvSet* set_header, int index );
|
|
/* Returns a set element by index. If the element doesn't belong to the set,
|
NULL is returned */
|
CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx )
|
{
|
CvSetElem* elem = (CvSetElem*)(void *)cvGetSeqElem( (CvSeq*)set_header, idx );
|
return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
|
}
|
|
/* Removes all the elements from the set */
|
CVAPI(void) cvClearSet( CvSet* set_header );
|
|
/* Creates new graph */
|
CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,
|
int vtx_size, int edge_size,
|
CvMemStorage* storage );
|
|
/* Adds new vertex to the graph */
|
CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
|
CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
|
|
|
/* Removes vertex from the graph together with all incident edges */
|
CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
|
CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
|
|
|
/* Link two vertices specifed by indices or pointers if they
|
are not connected or return pointer to already existing edge
|
connecting the vertices.
|
Functions return 1 if a new edge was created, 0 otherwise */
|
CVAPI(int) cvGraphAddEdge( CvGraph* graph,
|
int start_idx, int end_idx,
|
const CvGraphEdge* edge CV_DEFAULT(NULL),
|
CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
|
|
CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph,
|
CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
|
const CvGraphEdge* edge CV_DEFAULT(NULL),
|
CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
|
|
/* Remove edge connecting two vertices */
|
CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
|
CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
|
CvGraphVtx* end_vtx );
|
|
/* Find edge connecting two vertices */
|
CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
|
CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,
|
const CvGraphVtx* start_vtx,
|
const CvGraphVtx* end_vtx );
|
#define cvGraphFindEdge cvFindGraphEdge
|
#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
|
|
/* Remove all vertices and edges from the graph */
|
CVAPI(void) cvClearGraph( CvGraph* graph );
|
|
|
/* Count number of edges incident to the vertex */
|
CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
|
CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
|
|
|
/* Retrieves graph vertex by given index */
|
#define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
|
|
/* Retrieves index of a graph vertex given its pointer */
|
#define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
|
|
/* Retrieves index of a graph edge given its pointer */
|
#define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
|
|
#define cvGraphGetVtxCount( graph ) ((graph)->active_count)
|
#define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
|
|
#define CV_GRAPH_VERTEX 1
|
#define CV_GRAPH_TREE_EDGE 2
|
#define CV_GRAPH_BACK_EDGE 4
|
#define CV_GRAPH_FORWARD_EDGE 8
|
#define CV_GRAPH_CROSS_EDGE 16
|
#define CV_GRAPH_ANY_EDGE 30
|
#define CV_GRAPH_NEW_TREE 32
|
#define CV_GRAPH_BACKTRACKING 64
|
#define CV_GRAPH_OVER -1
|
|
#define CV_GRAPH_ALL_ITEMS -1
|
|
/* flags for graph vertices and edges */
|
#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)
|
#define CV_IS_GRAPH_VERTEX_VISITED(vtx) \
|
(((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
|
#define CV_IS_GRAPH_EDGE_VISITED(edge) \
|
(((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
|
#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)
|
#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)
|
|
typedef struct CvGraphScanner
|
{
|
CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */
|
CvGraphVtx* dst; /* current graph edge destination vertex */
|
CvGraphEdge* edge; /* current edge */
|
|
CvGraph* graph; /* the graph */
|
CvSeq* stack; /* the graph vertex stack */
|
int index; /* the lower bound of certainly visited vertices */
|
int mask; /* event mask */
|
}
|
CvGraphScanner;
|
|
/* Creates new graph scanner. */
|
CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,
|
CvGraphVtx* vtx CV_DEFAULT(NULL),
|
int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
|
|
/* Releases graph scanner. */
|
CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
|
|
/* Get next graph element */
|
CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
|
|
/* Creates a copy of graph */
|
CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
|
|
/****************************************************************************************\
|
* Drawing *
|
\****************************************************************************************/
|
|
/****************************************************************************************\
|
* Drawing functions work with images/matrices of arbitrary type. *
|
* For color images the channel order is BGR[A] *
|
* Antialiasing is supported only for 8-bit image now. *
|
* All the functions include parameter color that means rgb value (that may be *
|
* constructed with CV_RGB macro) for color images and brightness *
|
* for grayscale images. *
|
* If a drawn figure is partially or completely outside of the image, it is clipped.*
|
\****************************************************************************************/
|
|
#define CV_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 )
|
#define CV_FILLED -1
|
|
#define CV_AA 16
|
|
/* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
|
CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
|
CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
|
|
/* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
|
if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
|
CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
|
CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8),
|
int shift CV_DEFAULT(0));
|
|
/* Draws a rectangle specified by a CvRect structure */
|
CVAPI(void) cvRectangleR( CvArr* img, CvRect r,
|
CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8),
|
int shift CV_DEFAULT(0));
|
|
|
/* Draws a circle with specified center and radius.
|
Thickness works in the same way as with cvRectangle */
|
CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius,
|
CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
|
|
/* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
|
depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
|
is rotated by <angle>. All the angles are in degrees */
|
CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
|
double angle, double start_angle, double end_angle,
|
CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
|
|
CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
|
int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
|
{
|
CvSize axes;
|
axes.width = cvRound(box.size.width*0.5);
|
axes.height = cvRound(box.size.height*0.5);
|
|
cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
|
0, 360, color, thickness, line_type, shift );
|
}
|
|
/* Fills convex or monotonous polygon. */
|
CVAPI(void) cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
|
|
/* Fills an area bounded by one or more arbitrary polygons */
|
CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,
|
int contours, CvScalar color,
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
|
|
/* Draws one or more polygonal curves */
|
CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours,
|
int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
|
|
#define cvDrawRect cvRectangle
|
#define cvDrawLine cvLine
|
#define cvDrawCircle cvCircle
|
#define cvDrawEllipse cvEllipse
|
#define cvDrawPolyLine cvPolyLine
|
|
/* Clips the line segment connecting *pt1 and *pt2
|
by the rectangular window
|
(0<=x<img_size.width, 0<=y<img_size.height). */
|
CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
|
|
/* Initializes line iterator. 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. */
|
CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
|
CvLineIterator* line_iterator,
|
int connectivity CV_DEFAULT(8),
|
int left_to_right CV_DEFAULT(0));
|
|
/* Moves iterator to the next line point */
|
#define CV_NEXT_LINE_POINT( line_iterator ) \
|
{ \
|
int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
|
(line_iterator).err += (line_iterator).minus_delta + \
|
((line_iterator).plus_delta & _line_iterator_mask); \
|
(line_iterator).ptr += (line_iterator).minus_step + \
|
((line_iterator).plus_step & _line_iterator_mask); \
|
}
|
|
|
/* basic font types */
|
#define CV_FONT_HERSHEY_SIMPLEX 0
|
#define CV_FONT_HERSHEY_PLAIN 1
|
#define CV_FONT_HERSHEY_DUPLEX 2
|
#define CV_FONT_HERSHEY_COMPLEX 3
|
#define CV_FONT_HERSHEY_TRIPLEX 4
|
#define CV_FONT_HERSHEY_COMPLEX_SMALL 5
|
#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6
|
#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7
|
|
/* font flags */
|
#define CV_FONT_ITALIC 16
|
|
#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX
|
|
|
/* Font structure */
|
typedef struct CvFont
|
{
|
const char* nameFont; //Qt:nameFont
|
CvScalar color; //Qt:ColorFont -> cvScalar(blue_component, green_component, red\_component[, alpha_component])
|
int font_face; //Qt: bool italic /* =CV_FONT_* */
|
const int* ascii; /* font data and metrics */
|
const int* greek;
|
const int* cyrillic;
|
float hscale, vscale;
|
float shear; /* slope coefficient: 0 - normal, >0 - italic */
|
int thickness; //Qt: weight /* letters thickness */
|
float dx; /* horizontal interval between letters */
|
int line_type; //Qt: PointSize
|
}
|
CvFont;
|
|
/* Initializes font structure used further in cvPutText */
|
CVAPI(void) cvInitFont( CvFont* font, int font_face,
|
double hscale, double vscale,
|
double shear CV_DEFAULT(0),
|
int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8));
|
|
CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
|
{
|
CvFont font;
|
cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
|
return font;
|
}
|
|
/* Renders text stroke with specified font and color at specified location.
|
CvFont should be initialized with cvInitFont */
|
CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org,
|
const CvFont* font, CvScalar color );
|
|
/* Calculates bounding box of text stroke (useful for alignment) */
|
CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font,
|
CvSize* text_size, int* baseline );
|
|
|
|
/* 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> */
|
CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype );
|
|
/* Returns the polygon points which make up the given ellipse. 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. */
|
CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
|
int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
|
|
/* Draws contour outlines or filled interiors on the image */
|
CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour,
|
CvScalar external_color, CvScalar hole_color,
|
int max_level, int thickness CV_DEFAULT(1),
|
int line_type CV_DEFAULT(8),
|
CvPoint offset CV_DEFAULT(cvPoint(0,0)));
|
|
/* Does look-up transformation. Elements of the source array
|
(that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */
|
CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
|
|
|
/******************* Iteration through the sequence tree *****************/
|
typedef struct CvTreeNodeIterator
|
{
|
const void* node;
|
int level;
|
int max_level;
|
}
|
CvTreeNodeIterator;
|
|
CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
|
const void* first, int max_level );
|
CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
|
CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
|
|
/* Inserts sequence into tree with specified "parent" sequence.
|
If parent is equal to frame (e.g. the most external contour),
|
then added contour will have null pointer to parent. */
|
CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
|
|
/* Removes contour from tree (together with the contour children). */
|
CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
|
|
/* Gathers pointers to all the sequences,
|
accessible from the <first>, to the single sequence */
|
CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
|
CvMemStorage* storage );
|
|
/* The function implements the K-means algorithm for clustering an array of sample
|
vectors in a specified number of classes */
|
#define CV_KMEANS_USE_INITIAL_LABELS 1
|
CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,
|
CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
|
CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
|
CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
|
|
/****************************************************************************************\
|
* System functions *
|
\****************************************************************************************/
|
|
/* Add the function pointers table with associated information to the IPP primitives list */
|
CVAPI(int) cvRegisterModule( const CvModuleInfo* module_info );
|
|
/* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
|
CVAPI(int) cvUseOptimized( int on_off );
|
|
/* Retrieves information about the registered modules and loaded optimized plugins */
|
CVAPI(void) cvGetModuleInfo( const char* module_name,
|
const char** version,
|
const char** loaded_addon_plugins );
|
|
typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
|
typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);
|
|
/* Set user-defined memory managment functions (substitutors for malloc and free) that
|
will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */
|
CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),
|
CvFreeFunc free_func CV_DEFAULT(NULL),
|
void* userdata CV_DEFAULT(NULL));
|
|
|
typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
|
(int,int,int,char*,char*,int,int,int,int,int,
|
IplROI*,IplImage*,void*,IplTileInfo*);
|
typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
|
typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
|
typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
|
typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
|
|
/* Makes OpenCV use IPL functions for IplImage allocation/deallocation */
|
CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
|
Cv_iplAllocateImageData allocate_data,
|
Cv_iplDeallocate deallocate,
|
Cv_iplCreateROI create_roi,
|
Cv_iplCloneImage clone_image );
|
|
#define CV_TURN_ON_IPL_COMPATIBILITY() \
|
cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \
|
iplDeallocate, iplCreateROI, iplCloneImage )
|
|
/****************************************************************************************\
|
* Data Persistence *
|
\****************************************************************************************/
|
|
/********************************** High-level functions ********************************/
|
|
/* opens existing or creates new file storage */
|
CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
|
int flags, const char* encoding CV_DEFAULT(NULL) );
|
|
/* closes file storage and deallocates buffers */
|
CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
|
|
/* returns attribute value or 0 (NULL) if there is no such attribute */
|
CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
|
|
/* starts writing compound structure (map or sequence) */
|
CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
|
int struct_flags, const char* type_name CV_DEFAULT(NULL),
|
CvAttrList attributes CV_DEFAULT(cvAttrList()));
|
|
/* finishes writing compound structure */
|
CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
|
|
/* writes an integer */
|
CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
|
|
/* writes a floating-point number */
|
CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
|
|
/* writes a string */
|
CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
|
const char* str, int quote CV_DEFAULT(0) );
|
|
/* writes a comment */
|
CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
|
int eol_comment );
|
|
/* writes instance of a standard type (matrix, image, sequence, graph etc.)
|
or user-defined type */
|
CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
|
CvAttrList attributes CV_DEFAULT(cvAttrList()));
|
|
/* starts the next stream */
|
CVAPI(void) cvStartNextStream( CvFileStorage* fs );
|
|
/* helper function: writes multiple integer or floating-point numbers */
|
CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
|
int len, const char* dt );
|
|
/* returns the hash entry corresponding to the specified literal key string or 0
|
if there is no such a key in the storage */
|
CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
|
int len CV_DEFAULT(-1),
|
int create_missing CV_DEFAULT(0));
|
|
/* returns file node with the specified key within the specified map
|
(collection of named nodes) */
|
CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
|
int stream_index CV_DEFAULT(0) );
|
|
/* returns file node with the specified key within the specified map
|
(collection of named nodes) */
|
CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
|
const CvStringHashNode* key,
|
int create_missing CV_DEFAULT(0) );
|
|
/* this is a slower version of cvGetFileNode that takes the key as a literal string */
|
CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
|
const CvFileNode* map,
|
const char* name );
|
|
CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
|
{
|
return !node ? default_value :
|
CV_NODE_IS_INT(node->tag) ? node->data.i :
|
CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
|
}
|
|
|
CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
|
const char* name, int default_value CV_DEFAULT(0) )
|
{
|
return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
|
}
|
|
|
CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
|
{
|
return !node ? default_value :
|
CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
|
CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
|
}
|
|
|
CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
|
const char* name, double default_value CV_DEFAULT(0.) )
|
{
|
return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
|
}
|
|
|
CV_INLINE const char* cvReadString( const CvFileNode* node,
|
const char* default_value CV_DEFAULT(NULL) )
|
{
|
return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
|
}
|
|
|
CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
|
const char* name, const char* default_value CV_DEFAULT(NULL) )
|
{
|
return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
|
}
|
|
|
/* decodes standard or user-defined object and returns it */
|
CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
|
CvAttrList* attributes CV_DEFAULT(NULL));
|
|
/* decodes standard or user-defined object and returns it */
|
CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
|
const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
|
{
|
return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
|
}
|
|
|
/* starts reading data from sequence or scalar numeric node */
|
CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
|
CvSeqReader* reader );
|
|
/* reads multiple numbers and stores them to array */
|
CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
|
int count, void* dst, const char* dt );
|
|
/* combination of two previous functions for easier reading of whole sequences */
|
CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
|
void* dst, const char* dt );
|
|
/* writes a copy of file node to file storage */
|
CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
|
const CvFileNode* node, int embed );
|
|
/* returns name of file node */
|
CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
|
|
/*********************************** Adding own types ***********************************/
|
|
CVAPI(void) cvRegisterType( const CvTypeInfo* info );
|
CVAPI(void) cvUnregisterType( const char* type_name );
|
CVAPI(CvTypeInfo*) cvFirstType(void);
|
CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
|
CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
|
|
/* universal functions */
|
CVAPI(void) cvRelease( void** struct_ptr );
|
CVAPI(void*) cvClone( const void* struct_ptr );
|
|
/* simple API for reading/writing data */
|
CVAPI(void) cvSave( const char* filename, const void* struct_ptr,
|
const char* name CV_DEFAULT(NULL),
|
const char* comment CV_DEFAULT(NULL),
|
CvAttrList attributes CV_DEFAULT(cvAttrList()));
|
CVAPI(void*) cvLoad( const char* filename,
|
CvMemStorage* memstorage CV_DEFAULT(NULL),
|
const char* name CV_DEFAULT(NULL),
|
const char** real_name CV_DEFAULT(NULL) );
|
|
/*********************************** Measuring Execution Time ***************************/
|
|
/* helper functions for RNG initialization and accurate time measurement:
|
uses internal clock counter on x86 */
|
CVAPI(int64) cvGetTickCount( void );
|
CVAPI(double) cvGetTickFrequency( void );
|
|
/*********************************** CPU capabilities ***********************************/
|
|
#define CV_CPU_NONE 0
|
#define CV_CPU_MMX 1
|
#define CV_CPU_SSE 2
|
#define CV_CPU_SSE2 3
|
#define CV_CPU_SSE3 4
|
#define CV_CPU_SSSE3 5
|
#define CV_CPU_SSE4_1 6
|
#define CV_CPU_SSE4_2 7
|
#define CV_CPU_POPCNT 8
|
#define CV_CPU_AVX 10
|
#define CV_CPU_AVX2 11
|
#define CV_HARDWARE_MAX_FEATURE 255
|
|
CVAPI(int) cvCheckHardwareSupport(int feature);
|
|
/*********************************** Multi-Threading ************************************/
|
|
/* retrieve/set the number of threads used in OpenMP implementations */
|
CVAPI(int) cvGetNumThreads( void );
|
CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
|
/* get index of the thread being executed */
|
CVAPI(int) cvGetThreadNum( void );
|
|
|
/********************************** Error Handling **************************************/
|
|
/* Get current OpenCV error status */
|
CVAPI(int) cvGetErrStatus( void );
|
|
/* Sets error status silently */
|
CVAPI(void) cvSetErrStatus( int status );
|
|
#define CV_ErrModeLeaf 0 /* Print error and exit program */
|
#define CV_ErrModeParent 1 /* Print error and continue */
|
#define CV_ErrModeSilent 2 /* Don't print and continue */
|
|
/* Retrives current error processing mode */
|
CVAPI(int) cvGetErrMode( void );
|
|
/* Sets error processing mode, returns previously used mode */
|
CVAPI(int) cvSetErrMode( int mode );
|
|
/* Sets error status and performs some additonal actions (displaying message box,
|
writing message to stderr, terminating application etc.)
|
depending on the current error mode */
|
CVAPI(void) cvError( int status, const char* func_name,
|
const char* err_msg, const char* file_name, int line );
|
|
/* Retrieves textual description of the error given its code */
|
CVAPI(const char*) cvErrorStr( int status );
|
|
/* Retrieves detailed information about the last error occured */
|
CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
|
const char** filename, int* line );
|
|
/* Maps IPP error codes to the counterparts from OpenCV */
|
CVAPI(int) cvErrorFromIppStatus( int ipp_status );
|
|
typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
|
const char* err_msg, const char* file_name, int line, void* userdata );
|
|
/* Assigns a new error-handling function */
|
CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
|
void* userdata CV_DEFAULT(NULL),
|
void** prev_userdata CV_DEFAULT(NULL) );
|
|
/*
|
Output to:
|
cvNulDevReport - nothing
|
cvStdErrReport - console(fprintf(stderr,...))
|
cvGuiBoxReport - MessageBox(WIN32)
|
*/
|
CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
|
const char* file_name, int line, void* userdata );
|
|
CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
|
const char* file_name, int line, void* userdata );
|
|
CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
|
const char* file_name, int line, void* userdata );
|
|
#define OPENCV_ERROR(status,func,context) \
|
cvError((status),(func),(context),__FILE__,__LINE__)
|
|
#define OPENCV_ERRCHK(func,context) \
|
{if (cvGetErrStatus() >= 0) \
|
{OPENCV_ERROR(CV_StsBackTrace,(func),(context));}}
|
|
#define OPENCV_ASSERT(expr,func,context) \
|
{if (! (expr)) \
|
{OPENCV_ERROR(CV_StsInternal,(func),(context));}}
|
|
#define OPENCV_RSTERR() (cvSetErrStatus(CV_StsOk))
|
|
#define OPENCV_CALL( Func ) \
|
{ \
|
Func; \
|
}
|
|
|
/* CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro */
|
#ifdef CV_NO_FUNC_NAMES
|
#define CV_FUNCNAME( Name )
|
#define cvFuncName ""
|
#else
|
#define CV_FUNCNAME( Name ) \
|
static char cvFuncName[] = Name
|
#endif
|
|
|
/*
|
CV_ERROR macro unconditionally raises error with passed code and message.
|
After raising error, control will be transferred to the exit label.
|
*/
|
#define CV_ERROR( Code, Msg ) \
|
{ \
|
cvError( (Code), cvFuncName, Msg, __FILE__, __LINE__ ); \
|
__CV_EXIT__; \
|
}
|
|
/* Simplified form of CV_ERROR */
|
#define CV_ERROR_FROM_CODE( code ) \
|
CV_ERROR( code, "" )
|
|
/*
|
CV_CHECK macro checks error status after CV (or IPL)
|
function call. If error detected, control will be transferred to the exit
|
label.
|
*/
|
#define CV_CHECK() \
|
{ \
|
if( cvGetErrStatus() < 0 ) \
|
CV_ERROR( CV_StsBackTrace, "Inner function failed." ); \
|
}
|
|
|
/*
|
CV_CALL macro calls CV (or IPL) function, checks error status and
|
signals a error if the function failed. Useful in "parent node"
|
error procesing mode
|
*/
|
#define CV_CALL( Func ) \
|
{ \
|
Func; \
|
CV_CHECK(); \
|
}
|
|
|
/* Runtime assertion macro */
|
#define CV_ASSERT( Condition ) \
|
{ \
|
if( !(Condition) ) \
|
CV_ERROR( CV_StsInternal, "Assertion: " #Condition " failed" ); \
|
}
|
|
#define __CV_BEGIN__ {
|
#define __CV_END__ goto exit; exit: ; }
|
#define __CV_EXIT__ goto exit
|
|
#ifdef __cplusplus
|
}
|
|
// classes for automatic module/RTTI data registration/unregistration
|
struct CV_EXPORTS CvModule
|
{
|
CvModule( CvModuleInfo* _info );
|
~CvModule();
|
CvModuleInfo* info;
|
|
static CvModuleInfo* first;
|
static CvModuleInfo* last;
|
};
|
|
struct CV_EXPORTS CvType
|
{
|
CvType( const char* type_name,
|
CvIsInstanceFunc is_instance, CvReleaseFunc release=0,
|
CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );
|
~CvType();
|
CvTypeInfo* info;
|
|
static CvTypeInfo* first;
|
static CvTypeInfo* last;
|
};
|
|
#endif
|
|
#endif
|
