| /*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. |
| // |
| // |
| // Intel License Agreement |
| // For Open Source Computer Vision Library |
| // |
| // Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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 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 *roots, |
| int maxiter CV_DEFAULT(0), int fig CV_DEFAULT(0)); |
| |
| /****************************************************************************************\ |
| * 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_LSQ 8 |
| |
| /* 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)); |
| |
| /* 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, 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, void* element CV_DEFAULT(NULL)); |
| |
| |
| /* Adds new element to the beginning of sequence. Returns pointer to it */ |
| CVAPI(schar*) cvSeqPushFront( CvSeq* seq, 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, 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, |
| 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, 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, 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, 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 */ |
| CVAPI(void) cvKMeans2( const CvArr* samples, int cluster_count, |
| CvArr* labels, CvTermCriteria termcrit ); |
| |
| /****************************************************************************************\ |
| * 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 ); |
| 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 |
| } |
| |
| #include "cxcore.hpp" |
| #endif |
| |
| #endif /*_CXCORE_H_*/ |