| /*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 <assert.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <float.h> |
| |
| #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 <emmintrin.h> |
| #define CV_SSE2 1 |
| #else |
| #define CV_SSE2 0 |
| #endif |
| |
| #if defined __BORLANDC__ |
| #include <fastmath.h> |
| #elif defined WIN64 && !defined EM64T && defined CV_ICC |
| #include <mathimf.h> |
| #else |
| #include <math.h> |
| #endif |
| |
| #ifdef HAVE_IPL |
| #ifndef __IPL_H__ |
| #if defined WIN32 || defined WIN64 |
| #include <ipl.h> |
| #else |
| #include <ipl/ipl.h> |
| #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)<<CV_SEQ_ELTYPE_BITS) |
| |
| /* types of sequences */ |
| #define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS) |
| #define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS) |
| #define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS) |
| |
| /* types of sparse sequences (sets) */ |
| #define CV_SEQ_KIND_GRAPH (3 << CV_SEQ_ELTYPE_BITS) |
| #define CV_SEQ_KIND_SUBDIV2D (4 << CV_SEQ_ELTYPE_BITS) |
| |
| #define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS) |
| |
| /* flags for curves */ |
| #define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT) |
| #define CV_SEQ_FLAG_SIMPLE (2 << CV_SEQ_FLAG_SHIFT) |
| #define CV_SEQ_FLAG_CONVEX (4 << CV_SEQ_FLAG_SHIFT) |
| #define CV_SEQ_FLAG_HOLE (8 << CV_SEQ_FLAG_SHIFT) |
| |
| /* flags for graphs */ |
| #define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT) |
| |
| #define CV_GRAPH CV_SEQ_KIND_GRAPH |
| #define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED) |
| |
| /* point sets */ |
| #define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT) |
| #define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D) |
| #define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT) |
| #define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE ) |
| #define CV_SEQ_CONTOUR CV_SEQ_POLYGON |
| #define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON ) |
| |
| /* chain-coded curves */ |
| #define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE) |
| #define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN) |
| |
| /* binary tree for the contour */ |
| #define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR) |
| |
| /* sequence of the connected components */ |
| #define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP) |
| |
| /* sequence of the integer numbers */ |
| #define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX) |
| |
| #define CV_SEQ_ELTYPE( seq ) ((seq)->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 <seq> 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. */ |