cxcore.h
资源名称:gabor.rar [点击查看]
上传用户:soukeisyuu
上传日期:2022-07-03
资源大小:5943k
文件大小:85k
源码类别:
波变换
开发平台:
Visual C++
- /*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 _CXCORE_H_
- #define _CXCORE_H_
- #ifdef __IPL_H__
- #define HAVE_IPL
- #endif
- #ifndef SKIP_INCLUDES
- #if defined HAVE_IPL && !defined __IPL_H__
- #ifndef _INC_WINDOWS
- #define CV_PRETEND_WINDOWS
- #define _INC_WINDOWS
- typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;
- typedef int BOOL;
- #endif
- #if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
- #include "ipl.h"
- #else
- #include "ipl/ipl.h"
- #endif
- #ifdef CV_PRETEND_WINDOWS
- #undef _INC_WINDOWS
- #endif
- #endif
- #endif // SKIP_INCLUDES
- #include "cxtypes.h"
- #include "cxerror.h"
- #include "cvver.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 initalizes 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, int header_size,
- int 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, (CvSetElem**)&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 index )
- {
- CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );
- 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 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.height*0.5);
- axes.height = cvRound(box.size.width*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
- {
- int font_face; /* =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; /* letters thickness */
- float dx; /* horizontal interval between letters */
- int line_type;
- }
- 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 );
- /* 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 );
- 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 );
- /* 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 );
- /*********************************** 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 );
- /*************** Convenience functions for better interaction with HighGUI **************/
- typedef IplImage* (CV_CDECL * CvLoadImageFunc)( const char* filename, int colorness );
- typedef CvMat* (CV_CDECL * CvLoadImageMFunc)( const char* filename, int colorness );
- typedef int (CV_CDECL * CvSaveImageFunc)( const char* filename, const CvArr* image,
- const int* params );
- typedef void (CV_CDECL * CvShowImageFunc)( const char* windowname, const CvArr* image );
- CVAPI(int) cvSetImageIOFunctions( CvLoadImageFunc _load_image, CvLoadImageMFunc _load_image_m,
- CvSaveImageFunc _save_image, CvShowImageFunc _show_image );
- #define CV_SET_IMAGE_IO_FUNCTIONS()
- cvSetImageIOFunctions( cvLoadImage, cvLoadImageM, cvSaveImage, cvShowImage )
- #ifdef __cplusplus
- }
- class CV_EXPORTS CvImage
- {
- public:
- CvImage() : image(0), refcount(0) {}
- CvImage( CvSize size, int depth, int channels )
- {
- image = cvCreateImage( size, depth, channels );
- refcount = image ? new int(1) : 0;
- }
- CvImage( IplImage* img ) : image(img)
- {
- refcount = image ? new int(1) : 0;
- }
- CvImage( const CvImage& img ) : image(img.image), refcount(img.refcount)
- {
- if( refcount ) ++(*refcount);
- }
- CvImage( const char* filename, const char* imgname=0, int color=-1 ) : image(0), refcount(0)
- { load( filename, imgname, color ); }
- CvImage( CvFileStorage* fs, const char* mapname, const char* imgname ) : image(0), refcount(0)
- { read( fs, mapname, imgname ); }
- CvImage( CvFileStorage* fs, const char* seqname, int idx ) : image(0), refcount(0)
- { read( fs, seqname, idx ); }
- ~CvImage()
- {
- if( refcount && !(--*refcount) )
- {
- cvReleaseImage( &image );
- delete refcount;
- }
- }
- CvImage clone() { return CvImage(image ? cvCloneImage(image) : 0); }
- void create( CvSize size, int depth, int channels )
- {
- if( !image || !refcount ||
- image->width != size.width || image->height != size.height ||
- image->depth != depth || image->nChannels != channels )
- attach( cvCreateImage( size, depth, channels ));
- }
- void release() { detach(); }
- void clear() { detach(); }
- void attach( IplImage* img, bool use_refcount=true )
- {
- if( refcount && --*refcount == 0 )
- {
- cvReleaseImage( &image );
- delete refcount;
- }
- image = img;
- refcount = use_refcount && image ? new int(1) : 0;
- }
- void detach()
- {
- if( refcount && --*refcount == 0 )
- {
- cvReleaseImage( &image );
- delete refcount;
- }
- image = 0;
- refcount = 0;
- }
- bool load( const char* filename, const char* imgname=0, int color=-1 );
- bool read( CvFileStorage* fs, const char* mapname, const char* imgname );
- bool read( CvFileStorage* fs, const char* seqname, int idx );
- void save( const char* filename, const char* imgname, const int* params=0 );
- void write( CvFileStorage* fs, const char* imgname );
- void show( const char* window_name );
- bool is_valid() { return image != 0; }
- int width() const { return image ? image->width : 0; }
- int height() const { return image ? image->height : 0; }
- CvSize size() const { return image ? cvSize(image->width, image->height) : cvSize(0,0); }
- CvSize roi_size() const
- {
- return !image ? cvSize(0,0) :
- !image->roi ? cvSize(image->width,image->height) :
- cvSize(image->roi->width, image->roi->height);
- }
- CvRect roi() const
- {
- return !image ? cvRect(0,0,0,0) :
- !image->roi ? cvRect(0,0,image->width,image->height) :
- cvRect(image->roi->xOffset,image->roi->yOffset,
- image->roi->width,image->roi->height);
- }
- int coi() const { return !image || !image->roi ? 0 : image->roi->coi; }
- void set_roi(CvRect roi) { cvSetImageROI(image,roi); }
- void reset_roi() { cvResetImageROI(image); }
- void set_coi(int coi) { cvSetImageCOI(image,coi); }
- int depth() const { return image ? image->depth : 0; }
- int channels() const { return image ? image->nChannels : 0; }
- int pix_size() const { return image ? ((image->depth & 255)>>3)*image->nChannels : 0; }
- uchar* data() { return image ? (uchar*)image->imageData : 0; }
- const uchar* data() const { return image ? (const uchar*)image->imageData : 0; }
- int step() const { return image ? image->widthStep : 0; }
- int origin() const { return image ? image->origin : 0; }
- uchar* roi_row(int y)
- {
- assert(0<=y);
- assert(!image ?
- 1 : image->roi ?
- y<image->roi->height : y<image->height);
- return !image ? 0 :
- !image->roi ?
- (uchar*)(image->imageData + y*image->widthStep) :
- (uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +
- image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);
- }
- const uchar* roi_row(int y) const
- {
- assert(0<=y);
- assert(!image ?
- 1 : image->roi ?
- y<image->roi->height : y<image->height);
- return !image ? 0 :
- !image->roi ?
- (const uchar*)(image->imageData + y*image->widthStep) :
- (const uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +
- image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);
- }
- operator const IplImage* () const { return image; }
- operator IplImage* () { return image; }
- CvImage& operator = (const CvImage& img)
- {
- if( img.refcount )
- ++*img.refcount;
- if( refcount && !(--*refcount) )
- cvReleaseImage( &image );
- image=img.image;
- refcount=img.refcount;
- return *this;
- }
- protected:
- IplImage* image;
- int* refcount;
- };
- class CV_EXPORTS CvMatrix
- {
- public:
- CvMatrix() : matrix(0) {}
- CvMatrix( int rows, int cols, int type )
- { matrix = cvCreateMat( rows, cols, type ); }
- CvMatrix( int rows, int cols, int type, CvMat* hdr,
- void* data=0, int step=CV_AUTOSTEP )
- { matrix = cvInitMatHeader( hdr, rows, cols, type, data, step ); }
- CvMatrix( int rows, int cols, int type, CvMemStorage* storage, bool alloc_data=true );
- CvMatrix( int rows, int cols, int type, void* data, int step=CV_AUTOSTEP )
- { matrix = cvCreateMatHeader( rows, cols, type );
- cvSetData( matrix, data, step ); }
- CvMatrix( CvMat* m )
- { matrix = m; }
- CvMatrix( const CvMatrix& m )
- {
- matrix = m.matrix;
- addref();
- }
- CvMatrix( const char* filename, const char* matname=0, int color=-1 ) : matrix(0)
- { load( filename, matname, color ); }
- CvMatrix( CvFileStorage* fs, const char* mapname, const char* matname ) : matrix(0)
- { read( fs, mapname, matname ); }
- CvMatrix( CvFileStorage* fs, const char* seqname, int idx ) : matrix(0)
- { read( fs, seqname, idx ); }
- ~CvMatrix()
- {
- release();
- }
- CvMatrix clone() { return CvMatrix(matrix ? cvCloneMat(matrix) : 0); }
- void set( CvMat* m, bool add_ref )
- {
- release();
- matrix = m;
- if( add_ref )
- addref();
- }
- void create( int rows, int cols, int type )
- {
- if( !matrix || !matrix->refcount ||
- matrix->rows != rows || matrix->cols != cols ||
- CV_MAT_TYPE(matrix->type) != type )
- set( cvCreateMat( rows, cols, type ), false );
- }
- void addref() const
- {
- if( matrix )
- {
- if( matrix->hdr_refcount )
- ++matrix->hdr_refcount;
- else if( matrix->refcount )
- ++*matrix->refcount;
- }
- }
- void release()
- {
- if( matrix )
- {
- if( matrix->hdr_refcount )
- {
- if( --matrix->hdr_refcount == 0 )
- cvReleaseMat( &matrix );
- }
- else if( matrix->refcount )
- {
- if( --*matrix->refcount == 0 )
- cvFree( &matrix->refcount );
- }
- matrix = 0;
- }
- }
- void clear()
- {
- release();
- }
- bool load( const char* filename, const char* matname=0, int color=-1 );
- bool read( CvFileStorage* fs, const char* mapname, const char* matname );
- bool read( CvFileStorage* fs, const char* seqname, int idx );
- void save( const char* filename, const char* matname, const int* params=0 );
- void write( CvFileStorage* fs, const char* matname );
- void show( const char* window_name );
- bool is_valid() { return matrix != 0; }
- int rows() const { return matrix ? matrix->rows : 0; }
- int cols() const { return matrix ? matrix->cols : 0; }
- CvSize size() const
- {
- return !matrix ? cvSize(0,0) : cvSize(matrix->rows,matrix->cols);
- }
- int type() const { return matrix ? CV_MAT_TYPE(matrix->type) : 0; }
- int depth() const { return matrix ? CV_MAT_DEPTH(matrix->type) : 0; }
- int channels() const { return matrix ? CV_MAT_CN(matrix->type) : 0; }
- int pix_size() const { return matrix ? CV_ELEM_SIZE(matrix->type) : 0; }
- uchar* data() { return matrix ? matrix->data.ptr : 0; }
- const uchar* data() const { return matrix ? matrix->data.ptr : 0; }
- int step() const { return matrix ? matrix->step : 0; }
- void set_data( void* data, int step=CV_AUTOSTEP )
- { cvSetData( matrix, data, step ); }
- uchar* row(int i) { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; }
- const uchar* row(int i) const
- { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; }
- operator const CvMat* () const { return matrix; }
- operator CvMat* () { return matrix; }
- CvMatrix& operator = (const CvMatrix& _m)
- {
- _m.addref();
- release();
- matrix = _m.matrix;
- return *this;
- }
- protected:
- CvMat* matrix;
- };
- // 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
- #ifndef SKIP_INCLUDES // for now only expose old interface to swig
- #include "cxcore.hpp"
- #endif // SKIP_INCLUDES
- #endif /*_CXCORE_H_*/