/*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_TYPES_H_ #define _CXCORE_TYPES_H_ #if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300 #define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */ #endif #ifndef SKIP_INCLUDES #include #include #include #include #if defined __ICL #define CV_ICC __ICL #elif defined __ICC #define CV_ICC __ICC #elif defined __ECL #define CV_ICC __ECL #elif defined __ECC #define CV_ICC __ECC #endif #if defined WIN32 && (!defined WIN64 || defined EM64T) && \ (_MSC_VER >= 1400 || defined CV_ICC) \ || (defined __SSE2__ && defined __GNUC__ && __GNUC__ >= 4) #include #define CV_SSE2 1 #else #define CV_SSE2 0 #endif #if defined __BORLANDC__ #include #elif defined WIN64 && !defined EM64T && defined CV_ICC #include #else #include #endif #ifdef HAVE_IPL #ifndef __IPL_H__ #if defined WIN32 || defined WIN64 #include #else #include #endif #endif #elif defined __IPL_H__ #define HAVE_IPL #endif #endif // SKIP_INCLUDES #if defined WIN32 || defined WIN64 #define CV_CDECL __cdecl #define CV_STDCALL __stdcall #else #define CV_CDECL #define CV_STDCALL #endif #ifndef CV_EXTERN_C #ifdef __cplusplus #define CV_EXTERN_C extern "C" #define CV_DEFAULT(val) = val #else #define CV_EXTERN_C #define CV_DEFAULT(val) #endif #endif #ifndef CV_EXTERN_C_FUNCPTR #ifdef __cplusplus #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; } #else #define CV_EXTERN_C_FUNCPTR(x) typedef x #endif #endif #ifndef CV_INLINE #if defined __cplusplus #define CV_INLINE inline #elif (defined WIN32 || defined WIN64) && !defined __GNUC__ #define CV_INLINE __inline #else #define CV_INLINE static #endif #endif /* CV_INLINE */ #if (defined WIN32 || defined WIN64) && defined CVAPI_EXPORTS #define CV_EXPORTS __declspec(dllexport) #else #define CV_EXPORTS #endif #ifndef CVAPI #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL #endif #if defined _MSC_VER || defined __BORLANDC__ typedef __int64 int64; typedef unsigned __int64 uint64; #else typedef long long int64; typedef unsigned long long uint64; #endif #ifndef HAVE_IPL typedef unsigned char uchar; typedef unsigned short ushort; #endif typedef signed char schar; /* CvArr* is used to pass arbitrary * array-like data structures * into functions where the particular * array type is recognized at runtime: */ typedef void CvArr; typedef union Cv32suf { int i; unsigned u; float f; } Cv32suf; typedef union Cv64suf { int64 i; uint64 u; double f; } Cv64suf; /****************************************************************************************\ * Common macros and inline functions * \****************************************************************************************/ #define CV_PI 3.1415926535897932384626433832795 #define CV_LOG2 0.69314718055994530941723212145818 #define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t)) #ifndef MIN #define MIN(a,b) ((a) > (b) ? (b) : (a)) #endif #ifndef MAX #define MAX(a,b) ((a) < (b) ? (b) : (a)) #endif /* min & max without jumps */ #define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1))) #define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1))) /* absolute value without jumps */ #ifndef __cplusplus #define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0)) #else #define CV_IABS(a) abs(a) #endif #define CV_CMP(a,b) (((a) > (b)) - ((a) < (b))) #define CV_SIGN(a) CV_CMP((a),0) CV_INLINE int cvRound( double value ) { #if CV_SSE2 __m128d t = _mm_load_sd( &value ); return _mm_cvtsd_si32(t); #elif defined WIN32 && !defined WIN64 && defined _MSC_VER int t; __asm { fld value; fistp t; } return t; #elif (defined HAVE_LRINT) || (defined WIN64 && !defined EM64T && defined CV_ICC) return (int)lrint(value); #else /* the algorithm was taken from Agner Fog's optimization guide at http://www.agner.org/assem */ Cv64suf temp; temp.f = value + 6755399441055744.0; return (int)temp.u; #endif } CV_INLINE int cvFloor( double value ) { #if CV_SSE2 __m128d t = _mm_load_sd( &value ); int i = _mm_cvtsd_si32(t); return i - _mm_movemask_pd(_mm_cmplt_sd(t,_mm_cvtsi32_sd(t,i))); #else int temp = cvRound(value); Cv32suf diff; diff.f = (float)(value - temp); return temp - (diff.i < 0); #endif } CV_INLINE int cvCeil( double value ) { #if CV_SSE2 __m128d t = _mm_load_sd( &value ); int i = _mm_cvtsd_si32(t); return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i),t)); #else int temp = cvRound(value); Cv32suf diff; diff.f = (float)(temp - value); return temp + (diff.i < 0); #endif } #define cvInvSqrt(value) ((float)(1./sqrt(value))) #define cvSqrt(value) ((float)sqrt(value)) CV_INLINE int cvIsNaN( double value ) { #if 1/*defined _MSC_VER || defined __BORLANDC__ return _isnan(value); #elif defined __GNUC__ return isnan(value); #else*/ Cv64suf ieee754; ieee754.f = value; return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) + ((unsigned)ieee754.u != 0) > 0x7ff00000; #endif } CV_INLINE int cvIsInf( double value ) { #if 1/*defined _MSC_VER || defined __BORLANDC__ return !_finite(value); #elif defined __GNUC__ return isinf(value); #else*/ Cv64suf ieee754; ieee754.f = value; return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 && (unsigned)ieee754.u == 0; #endif } /*************** Random number generation *******************/ typedef uint64 CvRNG; CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1)) { CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1; return rng; } /* Return random 32-bit unsigned integer: */ CV_INLINE unsigned cvRandInt( CvRNG* rng ) { uint64 temp = *rng; temp = (uint64)(unsigned)temp*1554115554 + (temp >> 32); *rng = temp; return (unsigned)temp; } /* Returns random floating-point number between 0 and 1: */ CV_INLINE double cvRandReal( CvRNG* rng ) { return cvRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */; } /****************************************************************************************\ * Image type (IplImage) * \****************************************************************************************/ #ifndef HAVE_IPL /* * The following definitions (until #endif) * is an extract from IPL headers. * Copyright (c) 1995 Intel Corporation. */ #define IPL_DEPTH_SIGN 0x80000000 #define IPL_DEPTH_1U 1 #define IPL_DEPTH_8U 8 #define IPL_DEPTH_16U 16 #define IPL_DEPTH_32F 32 #define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8) #define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16) #define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32) #define IPL_DATA_ORDER_PIXEL 0 #define IPL_DATA_ORDER_PLANE 1 #define IPL_ORIGIN_TL 0 #define IPL_ORIGIN_BL 1 #define IPL_ALIGN_4BYTES 4 #define IPL_ALIGN_8BYTES 8 #define IPL_ALIGN_16BYTES 16 #define IPL_ALIGN_32BYTES 32 #define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES #define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES #define IPL_BORDER_CONSTANT 0 #define IPL_BORDER_REPLICATE 1 #define IPL_BORDER_REFLECT 2 #define IPL_BORDER_WRAP 3 typedef struct _IplImage { int nSize; /* sizeof(IplImage) */ int ID; /* version (=0)*/ int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */ int alphaChannel; /* Ignored by OpenCV */ int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S, IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */ char colorModel[4]; /* Ignored by OpenCV */ char channelSeq[4]; /* ditto */ int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels. cvCreateImage can only create interleaved images */ int origin; /* 0 - top-left origin, 1 - bottom-left origin (Windows bitmaps style). */ int align; /* Alignment of image rows (4 or 8). OpenCV ignores it and uses widthStep instead. */ int width; /* Image width in pixels. */ int height; /* Image height in pixels. */ struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */ struct _IplImage *maskROI; /* Must be NULL. */ void *imageId; /* " " */ struct _IplTileInfo *tileInfo; /* " " */ int imageSize; /* Image data size in bytes (==image->height*image->widthStep in case of interleaved data)*/ char *imageData; /* Pointer to aligned image data. */ int widthStep; /* Size of aligned image row in bytes. */ int BorderMode[4]; /* Ignored by OpenCV. */ int BorderConst[4]; /* Ditto. */ char *imageDataOrigin; /* Pointer to very origin of image data (not necessarily aligned) - needed for correct deallocation */ } IplImage; typedef struct _IplTileInfo IplTileInfo; typedef struct _IplROI { int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/ int xOffset; int yOffset; int width; int height; } IplROI; typedef struct _IplConvKernel { int nCols; int nRows; int anchorX; int anchorY; int *values; int nShiftR; } IplConvKernel; typedef struct _IplConvKernelFP { int nCols; int nRows; int anchorX; int anchorY; float *values; } IplConvKernelFP; #define IPL_IMAGE_HEADER 1 #define IPL_IMAGE_DATA 2 #define IPL_IMAGE_ROI 4 #endif/*HAVE_IPL*/ /* extra border mode */ #define IPL_BORDER_REFLECT_101 4 #define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage)) #define CV_TYPE_NAME_IMAGE "opencv-image" #define CV_IS_IMAGE_HDR(img) \ ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage)) #define CV_IS_IMAGE(img) \ (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL) /* for storing double-precision floating point data in IplImage's */ #define IPL_DEPTH_64F 64 /* get reference to pixel at (col,row), for multi-channel images (col) should be multiplied by number of channels */ #define CV_IMAGE_ELEM( image, elemtype, row, col ) \ (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)]) /****************************************************************************************\ * Matrix type (CvMat) * \****************************************************************************************/ #define CV_CN_MAX 64 #define CV_CN_SHIFT 3 #define CV_DEPTH_MAX (1 << CV_CN_SHIFT) #define CV_8U 0 #define CV_8S 1 #define CV_16U 2 #define CV_16S 3 #define CV_32S 4 #define CV_32F 5 #define CV_64F 6 #define CV_USRTYPE1 7 #define CV_MAKETYPE(depth,cn) ((depth) + (((cn)-1) << CV_CN_SHIFT)) #define CV_MAKE_TYPE CV_MAKETYPE #define CV_8UC1 CV_MAKETYPE(CV_8U,1) #define CV_8UC2 CV_MAKETYPE(CV_8U,2) #define CV_8UC3 CV_MAKETYPE(CV_8U,3) #define CV_8UC4 CV_MAKETYPE(CV_8U,4) #define CV_8UC(n) CV_MAKETYPE(CV_8U,(n)) #define CV_8SC1 CV_MAKETYPE(CV_8S,1) #define CV_8SC2 CV_MAKETYPE(CV_8S,2) #define CV_8SC3 CV_MAKETYPE(CV_8S,3) #define CV_8SC4 CV_MAKETYPE(CV_8S,4) #define CV_8SC(n) CV_MAKETYPE(CV_8S,(n)) #define CV_16UC1 CV_MAKETYPE(CV_16U,1) #define CV_16UC2 CV_MAKETYPE(CV_16U,2) #define CV_16UC3 CV_MAKETYPE(CV_16U,3) #define CV_16UC4 CV_MAKETYPE(CV_16U,4) #define CV_16UC(n) CV_MAKETYPE(CV_16U,(n)) #define CV_16SC1 CV_MAKETYPE(CV_16S,1) #define CV_16SC2 CV_MAKETYPE(CV_16S,2) #define CV_16SC3 CV_MAKETYPE(CV_16S,3) #define CV_16SC4 CV_MAKETYPE(CV_16S,4) #define CV_16SC(n) CV_MAKETYPE(CV_16S,(n)) #define CV_32SC1 CV_MAKETYPE(CV_32S,1) #define CV_32SC2 CV_MAKETYPE(CV_32S,2) #define CV_32SC3 CV_MAKETYPE(CV_32S,3) #define CV_32SC4 CV_MAKETYPE(CV_32S,4) #define CV_32SC(n) CV_MAKETYPE(CV_32S,(n)) #define CV_32FC1 CV_MAKETYPE(CV_32F,1) #define CV_32FC2 CV_MAKETYPE(CV_32F,2) #define CV_32FC3 CV_MAKETYPE(CV_32F,3) #define CV_32FC4 CV_MAKETYPE(CV_32F,4) #define CV_32FC(n) CV_MAKETYPE(CV_32F,(n)) #define CV_64FC1 CV_MAKETYPE(CV_64F,1) #define CV_64FC2 CV_MAKETYPE(CV_64F,2) #define CV_64FC3 CV_MAKETYPE(CV_64F,3) #define CV_64FC4 CV_MAKETYPE(CV_64F,4) #define CV_64FC(n) CV_MAKETYPE(CV_64F,(n)) #define CV_AUTO_STEP 0x7fffffff #define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff ) #define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT) #define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1) #define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1) #define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK) #define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1) #define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK) #define CV_MAT_CONT_FLAG_SHIFT 14 #define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT) #define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG) #define CV_IS_CONT_MAT CV_IS_MAT_CONT #define CV_MAT_TEMP_FLAG_SHIFT 15 #define CV_MAT_TEMP_FLAG (1 << CV_MAT_TEMP_FLAG_SHIFT) #define CV_IS_TEMP_MAT(flags) ((flags) & CV_MAT_TEMP_FLAG) #define CV_MAGIC_MASK 0xFFFF0000 #define CV_MAT_MAGIC_VAL 0x42420000 #define CV_TYPE_NAME_MAT "opencv-matrix" typedef struct CvMat { int type; int step; /* for internal use only */ int* refcount; int hdr_refcount; union { uchar* ptr; short* s; int* i; float* fl; double* db; } data; #ifdef __cplusplus union { int rows; int height; }; union { int cols; int width; }; #else int rows; int cols; #endif } CvMat; #define CV_IS_MAT_HDR(mat) \ ((mat) != NULL && \ (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \ ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0) #define CV_IS_MAT(mat) \ (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL) #define CV_IS_MASK_ARR(mat) \ (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0) #define CV_ARE_TYPES_EQ(mat1, mat2) \ ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0) #define CV_ARE_CNS_EQ(mat1, mat2) \ ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0) #define CV_ARE_DEPTHS_EQ(mat1, mat2) \ ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0) #define CV_ARE_SIZES_EQ(mat1, mat2) \ ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols) #define CV_IS_MAT_CONST(mat) \ (((mat)->rows|(mat)->cols) == 1) /* Size of each channel item, 0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */ #define CV_ELEM_SIZE1(type) \ ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15) /* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */ #define CV_ELEM_SIZE(type) \ (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3)) /* Inline constructor. No data is allocated internally!!! * (Use together with cvCreateData, or use cvCreateMat instead to * get a matrix with allocated data): */ CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL)) { CvMat m; assert( (unsigned)CV_MAT_DEPTH(type) <= CV_64F ); type = CV_MAT_TYPE(type); m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type; m.cols = cols; m.rows = rows; m.step = rows > 1 ? m.cols*CV_ELEM_SIZE(type) : 0; m.data.ptr = (uchar*)data; m.refcount = NULL; m.hdr_refcount = 0; return m; } #define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \ (assert( (unsigned)(row) < (unsigned)(mat).rows && \ (unsigned)(col) < (unsigned)(mat).cols ), \ (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col)) #define CV_MAT_ELEM_PTR( mat, row, col ) \ CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) ) #define CV_MAT_ELEM( mat, elemtype, row, col ) \ (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype))) CV_INLINE double cvmGet( const CvMat* mat, int row, int col ) { int type; type = CV_MAT_TYPE(mat->type); assert( (unsigned)row < (unsigned)mat->rows && (unsigned)col < (unsigned)mat->cols ); if( type == CV_32FC1 ) return ((float*)(mat->data.ptr + (size_t)mat->step*row))[col]; else { assert( type == CV_64FC1 ); return ((double*)(mat->data.ptr + (size_t)mat->step*row))[col]; } } CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value ) { int type; type = CV_MAT_TYPE(mat->type); assert( (unsigned)row < (unsigned)mat->rows && (unsigned)col < (unsigned)mat->cols ); if( type == CV_32FC1 ) ((float*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value; else { assert( type == CV_64FC1 ); ((double*)(mat->data.ptr + (size_t)mat->step*row))[col] = (double)value; } } CV_INLINE int cvCvToIplDepth( int type ) { int depth = CV_MAT_DEPTH(type); return CV_ELEM_SIZE1(depth)*8 | (depth == CV_8S || depth == CV_16S || depth == CV_32S ? IPL_DEPTH_SIGN : 0); } /****************************************************************************************\ * Multi-dimensional dense array (CvMatND) * \****************************************************************************************/ #define CV_MATND_MAGIC_VAL 0x42430000 #define CV_TYPE_NAME_MATND "opencv-nd-matrix" #define CV_MAX_DIM 32 #define CV_MAX_DIM_HEAP (1 << 16) typedef struct CvMatND { int type; int dims; int* refcount; int hdr_refcount; union { uchar* ptr; float* fl; double* db; int* i; short* s; } data; struct { int size; int step; } dim[CV_MAX_DIM]; } CvMatND; #define CV_IS_MATND_HDR(mat) \ ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL) #define CV_IS_MATND(mat) \ (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL) /****************************************************************************************\ * Multi-dimensional sparse array (CvSparseMat) * \****************************************************************************************/ #define CV_SPARSE_MAT_MAGIC_VAL 0x42440000 #define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix" struct CvSet; typedef struct CvSparseMat { int type; int dims; int* refcount; int hdr_refcount; struct CvSet* heap; void** hashtable; int hashsize; int valoffset; int idxoffset; int size[CV_MAX_DIM]; } CvSparseMat; #define CV_IS_SPARSE_MAT_HDR(mat) \ ((mat) != NULL && \ (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL) #define CV_IS_SPARSE_MAT(mat) \ CV_IS_SPARSE_MAT_HDR(mat) /**************** iteration through a sparse array *****************/ typedef struct CvSparseNode { unsigned hashval; struct CvSparseNode* next; } CvSparseNode; typedef struct CvSparseMatIterator { CvSparseMat* mat; CvSparseNode* node; int curidx; } CvSparseMatIterator; #define CV_NODE_VAL(mat,node) ((void*)((uchar*)(node) + (mat)->valoffset)) #define CV_NODE_IDX(mat,node) ((int*)((uchar*)(node) + (mat)->idxoffset)) /****************************************************************************************\ * Histogram * \****************************************************************************************/ typedef int CvHistType; #define CV_HIST_MAGIC_VAL 0x42450000 #define CV_HIST_UNIFORM_FLAG (1 << 10) /* indicates whether bin ranges are set already or not */ #define CV_HIST_RANGES_FLAG (1 << 11) #define CV_HIST_ARRAY 0 #define CV_HIST_SPARSE 1 #define CV_HIST_TREE CV_HIST_SPARSE /* should be used as a parameter only, it turns to CV_HIST_UNIFORM_FLAG of hist->type */ #define CV_HIST_UNIFORM 1 typedef struct CvHistogram { int type; CvArr* bins; float thresh[CV_MAX_DIM][2]; /* For uniform histograms. */ float** thresh2; /* For non-uniform histograms. */ CvMatND mat; /* Embedded matrix header for array histograms. */ } CvHistogram; #define CV_IS_HIST( hist ) \ ((hist) != NULL && \ (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \ (hist)->bins != NULL) #define CV_IS_UNIFORM_HIST( hist ) \ (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0) #define CV_IS_SPARSE_HIST( hist ) \ CV_IS_SPARSE_MAT((hist)->bins) #define CV_HIST_HAS_RANGES( hist ) \ (((hist)->type & CV_HIST_RANGES_FLAG) != 0) /****************************************************************************************\ * Other supplementary data type definitions * \****************************************************************************************/ /*************************************** CvRect *****************************************/ typedef struct CvRect { int x; int y; int width; int height; } CvRect; CV_INLINE CvRect cvRect( int x, int y, int width, int height ) { CvRect r; r.x = x; r.y = y; r.width = width; r.height = height; return r; } CV_INLINE IplROI cvRectToROI( CvRect rect, int coi ) { IplROI roi; roi.xOffset = rect.x; roi.yOffset = rect.y; roi.width = rect.width; roi.height = rect.height; roi.coi = coi; return roi; } CV_INLINE CvRect cvROIToRect( IplROI roi ) { return cvRect( roi.xOffset, roi.yOffset, roi.width, roi.height ); } /*********************************** CvTermCriteria *************************************/ #define CV_TERMCRIT_ITER 1 #define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER #define CV_TERMCRIT_EPS 2 typedef struct CvTermCriteria { int type; /* may be combination of CV_TERMCRIT_ITER CV_TERMCRIT_EPS */ int max_iter; double epsilon; } CvTermCriteria; CV_INLINE CvTermCriteria cvTermCriteria( int type, int max_iter, double epsilon ) { CvTermCriteria t; t.type = type; t.max_iter = max_iter; t.epsilon = (float)epsilon; return t; } /******************************* CvPoint and variants ***********************************/ typedef struct CvPoint { int x; int y; } CvPoint; CV_INLINE CvPoint cvPoint( int x, int y ) { CvPoint p; p.x = x; p.y = y; return p; } typedef struct CvPoint2D32f { float x; float y; } CvPoint2D32f; CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y ) { CvPoint2D32f p; p.x = (float)x; p.y = (float)y; return p; } CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point ) { return cvPoint2D32f( (float)point.x, (float)point.y ); } CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point ) { CvPoint ipt; ipt.x = cvRound(point.x); ipt.y = cvRound(point.y); return ipt; } typedef struct CvPoint3D32f { float x; float y; float z; } CvPoint3D32f; CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z ) { CvPoint3D32f p; p.x = (float)x; p.y = (float)y; p.z = (float)z; return p; } typedef struct CvPoint2D64f { double x; double y; } CvPoint2D64f; CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y ) { CvPoint2D64f p; p.x = x; p.y = y; return p; } typedef struct CvPoint3D64f { double x; double y; double z; } CvPoint3D64f; CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z ) { CvPoint3D64f p; p.x = x; p.y = y; p.z = z; return p; } /******************************** CvSize's & CvBox **************************************/ typedef struct { int width; int height; } CvSize; CV_INLINE CvSize cvSize( int width, int height ) { CvSize s; s.width = width; s.height = height; return s; } typedef struct CvSize2D32f { float width; float height; } CvSize2D32f; CV_INLINE CvSize2D32f cvSize2D32f( double width, double height ) { CvSize2D32f s; s.width = (float)width; s.height = (float)height; return s; } typedef struct CvBox2D { CvPoint2D32f center; /* Center of the box. */ CvSize2D32f size; /* Box width and length. */ float angle; /* Angle between the horizontal axis */ /* and the first side (i.e. length) in degrees */ } CvBox2D; /* Line iterator state: */ typedef struct CvLineIterator { /* Pointer to the current point: */ uchar* ptr; /* Bresenham algorithm state: */ int err; int plus_delta; int minus_delta; int plus_step; int minus_step; } CvLineIterator; /************************************* CvSlice ******************************************/ typedef struct CvSlice { int start_index, end_index; } CvSlice; CV_INLINE CvSlice cvSlice( int start, int end ) { CvSlice slice; slice.start_index = start; slice.end_index = end; return slice; } #define CV_WHOLE_SEQ_END_INDEX 0x3fffffff #define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX) /************************************* CvScalar *****************************************/ typedef struct CvScalar { double val[4]; } CvScalar; CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0), double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0)) { CvScalar scalar; scalar.val[0] = val0; scalar.val[1] = val1; scalar.val[2] = val2; scalar.val[3] = val3; return scalar; } CV_INLINE CvScalar cvRealScalar( double val0 ) { CvScalar scalar; scalar.val[0] = val0; scalar.val[1] = scalar.val[2] = scalar.val[3] = 0; return scalar; } CV_INLINE CvScalar cvScalarAll( double val0123 ) { CvScalar scalar; scalar.val[0] = val0123; scalar.val[1] = val0123; scalar.val[2] = val0123; scalar.val[3] = val0123; return scalar; } /****************************************************************************************\ * Dynamic Data structures * \****************************************************************************************/ /******************************** Memory storage ****************************************/ typedef struct CvMemBlock { struct CvMemBlock* prev; struct CvMemBlock* next; } CvMemBlock; #define CV_STORAGE_MAGIC_VAL 0x42890000 typedef struct CvMemStorage { int signature; CvMemBlock* bottom; /* First allocated block. */ CvMemBlock* top; /* Current memory block - top of the stack. */ struct CvMemStorage* parent; /* We get new blocks from parent as needed. */ int block_size; /* Block size. */ int free_space; /* Remaining free space in current block. */ } CvMemStorage; #define CV_IS_STORAGE(storage) \ ((storage) != NULL && \ (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL) typedef struct CvMemStoragePos { CvMemBlock* top; int free_space; } CvMemStoragePos; /*********************************** Sequence *******************************************/ typedef struct CvSeqBlock { struct CvSeqBlock* prev; /* Previous sequence block. */ struct CvSeqBlock* next; /* Next sequence block. */ int start_index; /* Index of the first element in the block + */ /* sequence->first->start_index. */ int count; /* Number of elements in the block. */ schar* data; /* Pointer to the first element of the block. */ } CvSeqBlock; #define CV_TREE_NODE_FIELDS(node_type) \ int flags; /* Miscellaneous flags. */ \ int header_size; /* Size of sequence header. */ \ struct node_type* h_prev; /* Previous sequence. */ \ struct node_type* h_next; /* Next sequence. */ \ struct node_type* v_prev; /* 2nd previous sequence. */ \ struct node_type* v_next /* 2nd next sequence. */ /* Read/Write sequence. Elements can be dynamically inserted to or deleted from the sequence. */ #define CV_SEQUENCE_FIELDS() \ CV_TREE_NODE_FIELDS(CvSeq); \ int total; /* Total number of elements. */ \ int elem_size; /* Size of sequence element in bytes. */ \ schar* block_max; /* Maximal bound of the last block. */ \ schar* ptr; /* Current write pointer. */ \ int delta_elems; /* Grow seq this many at a time. */ \ CvMemStorage* storage; /* Where the seq is stored. */ \ CvSeqBlock* free_blocks; /* Free blocks list. */ \ CvSeqBlock* first; /* Pointer to the first sequence block. */ typedef struct CvSeq { CV_SEQUENCE_FIELDS() } CvSeq; #define CV_TYPE_NAME_SEQ "opencv-sequence" #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree" /*************************************** Set ********************************************/ /* Set. Order is not preserved. There can be gaps between sequence elements. After the element has been inserted it stays in the same place all the time. The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists. */ #define CV_SET_ELEM_FIELDS(elem_type) \ int flags; \ struct elem_type* next_free; typedef struct CvSetElem { CV_SET_ELEM_FIELDS(CvSetElem) } CvSetElem; #define CV_SET_FIELDS() \ CV_SEQUENCE_FIELDS() \ CvSetElem* free_elems; \ int active_count; typedef struct CvSet { CV_SET_FIELDS() } CvSet; #define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1) #define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1)) /* Checks whether the element pointed by ptr belongs to a set or not */ #define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0) /************************************* Graph ********************************************/ /* We represent a graph as a set of vertices. Vertices contain their adjacency lists (more exactly, pointers to first incoming or outcoming edge (or 0 if isolated vertex)). Edges are stored in another set. There is a singly-linked list of incoming/outcoming edges for each vertex. Each edge consists of o Two pointers to the starting and ending vertices (vtx[0] and vtx[1] respectively). A graph may be oriented or not. In the latter case, edges between vertex i to vertex j are not distinguished during search operations. o Two pointers to next edges for the starting and ending vertices, where next[0] points to the next edge in the vtx[0] adjacency list and next[1] points to the next edge in the vtx[1] adjacency list. */ #define CV_GRAPH_EDGE_FIELDS() \ int flags; \ float weight; \ struct CvGraphEdge* next[2]; \ struct CvGraphVtx* vtx[2]; #define CV_GRAPH_VERTEX_FIELDS() \ int flags; \ struct CvGraphEdge* first; typedef struct CvGraphEdge { CV_GRAPH_EDGE_FIELDS() } CvGraphEdge; typedef struct CvGraphVtx { CV_GRAPH_VERTEX_FIELDS() } CvGraphVtx; typedef struct CvGraphVtx2D { CV_GRAPH_VERTEX_FIELDS() CvPoint2D32f* ptr; } CvGraphVtx2D; /* Graph is "derived" from the set (this is set a of vertices) and includes another set (edges) */ #define CV_GRAPH_FIELDS() \ CV_SET_FIELDS() \ CvSet* edges; typedef struct CvGraph { CV_GRAPH_FIELDS() } CvGraph; #define CV_TYPE_NAME_GRAPH "opencv-graph" /*********************************** Chain/Countour *************************************/ typedef struct CvChain { CV_SEQUENCE_FIELDS() CvPoint origin; } CvChain; #define CV_CONTOUR_FIELDS() \ CV_SEQUENCE_FIELDS() \ CvRect rect; \ int color; \ int reserved[3]; typedef struct CvContour { CV_CONTOUR_FIELDS() } CvContour; typedef CvContour CvPoint2DSeq; /****************************************************************************************\ * Sequence types * \****************************************************************************************/ #define CV_SEQ_MAGIC_VAL 0x42990000 #define CV_IS_SEQ(seq) \ ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL) #define CV_SET_MAGIC_VAL 0x42980000 #define CV_IS_SET(set) \ ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL) #define CV_SEQ_ELTYPE_BITS 9 #define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1) #define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */ #define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */ #define CV_SEQ_ELTYPE_GENERIC 0 #define CV_SEQ_ELTYPE_PTR CV_USRTYPE1 #define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */ #define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #(x,y) */ #define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /* &next_o, &next_d, &vtx_o, &vtx_d */ #define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /* first_edge, &(x,y) */ #define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */ #define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */ #define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */ #define CV_SEQ_KIND_BITS 3 #define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<flags & CV_SEQ_ELTYPE_MASK) #define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK ) /* flag checking */ #define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC)) #define CV_IS_SEQ_CURVE( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE) #define CV_IS_SEQ_CLOSED( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0) #define CV_IS_SEQ_CONVEX( seq ) (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0) #define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0) #define CV_IS_SEQ_SIMPLE( seq ) ((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \ CV_IS_SEQ_CONVEX(seq)) /* type checking macros */ #define CV_IS_SEQ_POINT_SET( seq ) \ ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2)) #define CV_IS_SEQ_POINT_SUBSET( seq ) \ (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT) #define CV_IS_SEQ_POLYLINE( seq ) \ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq)) #define CV_IS_SEQ_POLYGON( seq ) \ (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq)) #define CV_IS_SEQ_CHAIN( seq ) \ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1) #define CV_IS_SEQ_CONTOUR( seq ) \ (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq))) #define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \ (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq )) #define CV_IS_SEQ_POLYGON_TREE( seq ) \ (CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && \ CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE ) #define CV_IS_GRAPH( seq ) \ (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH) #define CV_IS_GRAPH_ORIENTED( seq ) \ (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0) #define CV_IS_SUBDIV2D( seq ) \ (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D) /****************************************************************************************/ /* Sequence writer & reader */ /****************************************************************************************/ #define CV_SEQ_WRITER_FIELDS() \ int header_size; \ CvSeq* seq; /* the sequence written */ \ CvSeqBlock* block; /* current block */ \ schar* ptr; /* pointer to free space */ \ schar* block_min; /* pointer to the beginning of block*/\ schar* block_max; /* pointer to the end of block */ typedef struct CvSeqWriter { CV_SEQ_WRITER_FIELDS() } CvSeqWriter; #define CV_SEQ_READER_FIELDS() \ int header_size; \ CvSeq* seq; /* sequence, beign read */ \ CvSeqBlock* block; /* current block */ \ schar* ptr; /* pointer to element be read next */ \ schar* block_min; /* pointer to the beginning of block */\ schar* block_max; /* pointer to the end of block */ \ int delta_index;/* = seq->first->start_index */ \ schar* prev_elem; /* pointer to previous element */ typedef struct CvSeqReader { CV_SEQ_READER_FIELDS() } CvSeqReader; /****************************************************************************************/ /* Operations on sequences */ /****************************************************************************************/ #define CV_SEQ_ELEM( seq, elem_type, index ) \ /* assert gives some guarantee that parameter is valid */ \ ( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && \ (seq)->elem_size == sizeof(elem_type)), \ (elem_type*)((seq)->first && (unsigned)index < \ (unsigned)((seq)->first->count) ? \ (seq)->first->data + (index) * sizeof(elem_type) : \ cvGetSeqElem( (CvSeq*)(seq), (index) ))) #define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) ) /* Add element to sequence: */ #define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) \ { \ if( (writer).ptr >= (writer).block_max ) \ { \ cvCreateSeqBlock( &writer); \ } \ memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\ (writer).ptr += (writer).seq->elem_size; \ } #define CV_WRITE_SEQ_ELEM( elem, writer ) \ { \ assert( (writer).seq->elem_size == sizeof(elem)); \ if( (writer).ptr >= (writer).block_max ) \ { \ cvCreateSeqBlock( &writer); \ } \ assert( (writer).ptr <= (writer).block_max - sizeof(elem));\ memcpy((writer).ptr, &(elem), sizeof(elem)); \ (writer).ptr += sizeof(elem); \ } /* Move reader position forward: */ #define CV_NEXT_SEQ_ELEM( elem_size, reader ) \ { \ if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \ { \ cvChangeSeqBlock( &(reader), 1 ); \ } \ } /* Move reader position backward: */ #define CV_PREV_SEQ_ELEM( elem_size, reader ) \ { \ if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \ { \ cvChangeSeqBlock( &(reader), -1 ); \ } \ } /* Read element and move read position forward: */ #define CV_READ_SEQ_ELEM( elem, reader ) \ { \ assert( (reader).seq->elem_size == sizeof(elem)); \ memcpy( &(elem), (reader).ptr, sizeof((elem))); \ CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) \ } /* Read element and move read position backward: */ #define CV_REV_READ_SEQ_ELEM( elem, reader ) \ { \ assert( (reader).seq->elem_size == sizeof(elem)); \ memcpy(&(elem), (reader).ptr, sizeof((elem))); \ CV_PREV_SEQ_ELEM( sizeof(elem), reader ) \ } #define CV_READ_CHAIN_POINT( _pt, reader ) \ { \ (_pt) = (reader).pt; \ if( (reader).ptr ) \ { \ CV_READ_SEQ_ELEM( (reader).code, (reader)); \ assert( ((reader).code & ~7) == 0 ); \ (reader).pt.x += (reader).deltas[(int)(reader).code][0]; \ (reader).pt.y += (reader).deltas[(int)(reader).code][1]; \ } \ } #define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr))) #define CV_PREV_POINT( reader ) (*((CvPoint*)((reader).prev_elem))) #define CV_READ_EDGE( pt1, pt2, reader ) \ { \ assert( sizeof(pt1) == sizeof(CvPoint) && \ sizeof(pt2) == sizeof(CvPoint) && \ reader.seq->elem_size == sizeof(CvPoint)); \ (pt1) = CV_PREV_POINT( reader ); \ (pt2) = CV_CURRENT_POINT( reader ); \ (reader).prev_elem = (reader).ptr; \ CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader)); \ } /************ Graph macros ************/ /* Return next graph edge for given vertex: */ #define CV_NEXT_GRAPH_EDGE( edge, vertex ) \ (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \ (edge)->next[(edge)->vtx[1] == (vertex)]) /****************************************************************************************\ * Data structures for persistence (a.k.a serialization) functionality * \****************************************************************************************/ /* "black box" file storage */ typedef struct CvFileStorage CvFileStorage; /* Storage flags: */ #define CV_STORAGE_READ 0 #define CV_STORAGE_WRITE 1 #define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE #define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE #define CV_STORAGE_APPEND 2 /* List of attributes: */ typedef struct CvAttrList { const char** attr; /* NULL-terminated array of (attribute_name,attribute_value) pairs. */ struct CvAttrList* next; /* Pointer to next chunk of the attributes list. */ } CvAttrList; CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL), CvAttrList* next CV_DEFAULT(NULL) ) { CvAttrList l; l.attr = attr; l.next = next; return l; } struct CvTypeInfo; #define CV_NODE_NONE 0 #define CV_NODE_INT 1 #define CV_NODE_INTEGER CV_NODE_INT #define CV_NODE_REAL 2 #define CV_NODE_FLOAT CV_NODE_REAL #define CV_NODE_STR 3 #define CV_NODE_STRING CV_NODE_STR #define CV_NODE_REF 4 /* not used */ #define CV_NODE_SEQ 5 #define CV_NODE_MAP 6 #define CV_NODE_TYPE_MASK 7 #define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK) /* file node flags */ #define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */ #define CV_NODE_USER 16 #define CV_NODE_EMPTY 32 #define CV_NODE_NAMED 64 #define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT) #define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL) #define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING) #define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ) #define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP) #define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ) #define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0) #define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0) #define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0) #define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0) #define CV_NODE_SEQ_SIMPLE 256 #define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0) typedef struct CvString { int len; char* ptr; } CvString; /* All the keys (names) of elements in the readed file storage are stored in the hash to speed up the lookup operations: */ typedef struct CvStringHashNode { unsigned hashval; CvString str; struct CvStringHashNode* next; } CvStringHashNode; typedef struct CvGenericHash CvFileNodeHash; /* Basic element of the file storage - scalar or collection: */ typedef struct CvFileNode { int tag; struct CvTypeInfo* info; /* type information (only for user-defined object, for others it is 0) */ union { double f; /* scalar floating-point number */ int i; /* scalar integer number */ CvString str; /* text string */ CvSeq* seq; /* sequence (ordered collection of file nodes) */ CvFileNodeHash* map; /* map (collection of named file nodes) */ } data; } CvFileNode; #ifdef __cplusplus extern "C" { #endif typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr ); typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr ); typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node ); typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name, const void* struct_ptr, CvAttrList attributes ); typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr ); #ifdef __cplusplus } #endif typedef struct CvTypeInfo { int flags; int header_size; struct CvTypeInfo* prev; struct CvTypeInfo* next; const char* type_name; CvIsInstanceFunc is_instance; CvReleaseFunc release; CvReadFunc read; CvWriteFunc write; CvCloneFunc clone; } CvTypeInfo; /**** System data types ******/ typedef struct CvPluginFuncInfo { void** func_addr; void* default_func_addr; const char* func_names; int search_modules; int loaded_from; } CvPluginFuncInfo; typedef struct CvModuleInfo { struct CvModuleInfo* next; const char* name; const char* version; CvPluginFuncInfo* func_tab; } CvModuleInfo; #endif /*_CXCORE_TYPES_H_*/ /* End of file. */