00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #ifndef __OPENCV_CORE_TYPES_H__
00044 #define __OPENCV_CORE_TYPES_H__
00045
00046 #if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300
00047 #define _CRT_SECURE_NO_DEPRECATE
00048 #endif
00049
00050
00051 #ifndef SKIP_INCLUDES
00052 #include <assert.h>
00053 #include <stdlib.h>
00054 #include <string.h>
00055 #include <float.h>
00056
00057 #if !defined _MSC_VER && !defined __BORLANDC__
00058 #include <stdint.h>
00059 #endif
00060
00061 #if defined __ICL
00062 #define CV_ICC __ICL
00063 #elif defined __ICC
00064 #define CV_ICC __ICC
00065 #elif defined __ECL
00066 #define CV_ICC __ECL
00067 #elif defined __ECC
00068 #define CV_ICC __ECC
00069 #elif defined __INTEL_COMPILER
00070 #define CV_ICC __INTEL_COMPILER
00071 #endif
00072
00073 #if (_MSC_VER >= 1400 && defined _M_X64) || (__GNUC__ >= 4 && defined __x86_64__)
00074 #if defined WIN32
00075 #include <intrin.h>
00076 #endif
00077 #include <emmintrin.h>
00078 #endif
00079
00080 #if defined __BORLANDC__
00081 #include <fastmath.h>
00082 #else
00083 #include <math.h>
00084 #endif
00085
00086 #ifdef HAVE_IPL
00087 #ifndef __IPL_H__
00088 #if defined WIN32 || defined _WIN32
00089 #include <ipl.h>
00090 #else
00091 #include <ipl/ipl.h>
00092 #endif
00093 #endif
00094 #elif defined __IPL_H__
00095 #define HAVE_IPL
00096 #endif
00097 #endif // SKIP_INCLUDES
00098
00099 #if defined WIN32 || defined _WIN32
00100 #define CV_CDECL __cdecl
00101 #define CV_STDCALL __stdcall
00102 #else
00103 #define CV_CDECL
00104 #define CV_STDCALL
00105 #endif
00106
00107 #ifndef CV_EXTERN_C
00108 #ifdef __cplusplus
00109 #define CV_EXTERN_C extern "C"
00110 #define CV_DEFAULT(val) = val
00111 #else
00112 #define CV_EXTERN_C
00113 #define CV_DEFAULT(val)
00114 #endif
00115 #endif
00116
00117 #ifndef CV_EXTERN_C_FUNCPTR
00118 #ifdef __cplusplus
00119 #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }
00120 #else
00121 #define CV_EXTERN_C_FUNCPTR(x) typedef x
00122 #endif
00123 #endif
00124
00125 #ifndef CV_INLINE
00126 #if defined __cplusplus
00127 #define CV_INLINE inline
00128 #elif (defined WIN32 || defined _WIN32 || defined WINCE) && !defined __GNUC__
00129 #define CV_INLINE __inline
00130 #else
00131 #define CV_INLINE static
00132 #endif
00133 #endif
00134
00135 #if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
00136 #define CV_EXPORTS __declspec(dllexport)
00137 #else
00138 #define CV_EXPORTS
00139 #endif
00140
00141 #ifndef CVAPI
00142 #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL
00143 #endif
00144
00145 #if defined _MSC_VER || defined __BORLANDC__
00146 typedef __int64 int64;
00147 typedef unsigned __int64 uint64;
00148 #else
00149 typedef int64_t int64;
00150 typedef uint64_t uint64;
00151 #endif
00152
00153 #ifndef HAVE_IPL
00154 typedef unsigned char uchar;
00155 typedef unsigned short ushort;
00156 #endif
00157
00158 typedef signed char schar;
00159
00160
00161 #define CV_CARRAY(counter)
00162 #define CV_CUSTOM_CARRAY(args)
00163 #define CV_EXPORTS_W CV_EXPORTS
00164 #define CV_EXPORTS_W_SIMPLE CV_EXPORTS
00165 #define CV_EXPORTS_AS(synonym) CV_EXPORTS
00166 #define CV_EXPORTS_W_MAP CV_EXPORTS
00167 #define CV_IN_OUT
00168 #define CV_OUT
00169 #define CV_PROP
00170 #define CV_PROP_RW
00171 #define CV_WRAP
00172 #define CV_WRAP_AS(synonym)
00173 #define CV_WRAP_DEFAULT(value)
00174
00175
00176
00177
00178
00179
00180 typedef void CvArr;
00181
00182 typedef union Cv32suf
00183 {
00184 int i;
00185 unsigned u;
00186 float f;
00187 }
00188 Cv32suf;
00189
00190 typedef union Cv64suf
00191 {
00192 int64 i;
00193 uint64 u;
00194 double f;
00195 }
00196 Cv64suf;
00197
00198 typedef int CVStatus;
00199
00200 enum {
00201 CV_StsOk= 0,
00202 CV_StsBackTrace= -1,
00203 CV_StsError= -2,
00204 CV_StsInternal= -3,
00205 CV_StsNoMem= -4,
00206 CV_StsBadArg= -5,
00207 CV_StsBadFunc= -6,
00208 CV_StsNoConv= -7,
00209 CV_StsAutoTrace= -8,
00210 CV_HeaderIsNull= -9,
00211 CV_BadImageSize= -10,
00212 CV_BadOffset= -11,
00213 CV_BadDataPtr= -12,
00214 CV_BadStep= -13,
00215 CV_BadModelOrChSeq= -14,
00216 CV_BadNumChannels= -15,
00217 CV_BadNumChannel1U= -16,
00218 CV_BadDepth= -17,
00219 CV_BadAlphaChannel= -18,
00220 CV_BadOrder= -19,
00221 CV_BadOrigin= -20,
00222 CV_BadAlign= -21,
00223 CV_BadCallBack= -22,
00224 CV_BadTileSize= -23,
00225 CV_BadCOI= -24,
00226 CV_BadROISize= -25,
00227 CV_MaskIsTiled= -26,
00228 CV_StsNullPtr= -27,
00229 CV_StsVecLengthErr= -28,
00230 CV_StsFilterStructContentErr= -29,
00231 CV_StsKernelStructContentErr= -30,
00232 CV_StsFilterOffsetErr= -31,
00233 CV_StsBadSize= -201,
00234 CV_StsDivByZero= -202,
00235 CV_StsInplaceNotSupported= -203,
00236 CV_StsObjectNotFound= -204,
00237 CV_StsUnmatchedFormats= -205,
00238 CV_StsBadFlag= -206,
00239 CV_StsBadPoint= -207,
00240 CV_StsBadMask= -208,
00241 CV_StsUnmatchedSizes= -209,
00242 CV_StsUnsupportedFormat= -210,
00243 CV_StsOutOfRange= -211,
00244 CV_StsParseError= -212,
00245 CV_StsNotImplemented= -213,
00246 CV_StsBadMemBlock= -214,
00247 CV_StsAssert= -215,
00248 CV_GpuNotSupported= -216,
00249 CV_GpuApiCallError= -217,
00250 CV_GpuNppCallError= -218
00251 };
00252
00253
00254
00255
00256
00257 #define CV_PI 3.1415926535897932384626433832795
00258 #define CV_LOG2 0.69314718055994530941723212145818
00259
00260 #define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
00261
00262 #ifndef MIN
00263 #define MIN(a,b) ((a) > (b) ? (b) : (a))
00264 #endif
00265
00266 #ifndef MAX
00267 #define MAX(a,b) ((a) < (b) ? (b) : (a))
00268 #endif
00269
00270
00271 #define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))
00272
00273 #define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))
00274
00275
00276 #ifndef __cplusplus
00277 #define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))
00278 #else
00279 #define CV_IABS(a) abs(a)
00280 #endif
00281 #define CV_CMP(a,b) (((a) > (b)) - ((a) < (b)))
00282 #define CV_SIGN(a) CV_CMP((a),0)
00283
00284 CV_INLINE int cvRound( double value )
00285 {
00286 #if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && !defined __APPLE__)
00287 __m128d t = _mm_set_sd( value );
00288 return _mm_cvtsd_si32(t);
00289 #elif defined _MSC_VER && defined _M_IX86
00290 int t;
00291 __asm
00292 {
00293 fld value;
00294 fistp t;
00295 }
00296 return t;
00297 #elif defined HAVE_LRINT || defined CV_ICC || defined __GNUC__
00298 return (int)lrint(value);
00299 #else
00300
00301 return (int)(value + (value >= 0 ? 0.5 : -0.5));
00302 #endif
00303 }
00304
00305
00306 CV_INLINE int cvFloor( double value )
00307 {
00308 #ifdef __GNUC__
00309 int i = (int)value;
00310 return i - (i > value);
00311 #elif defined _MSC_VER && defined _M_X64
00312 __m128d t = _mm_set_sd( value );
00313 int i = _mm_cvtsd_si32(t);
00314 return i - _mm_movemask_pd(_mm_cmplt_sd(t, _mm_cvtsi32_sd(t,i)));
00315 #else
00316 int i = cvRound(value);
00317 Cv32suf diff;
00318 diff.f = (float)(value - i);
00319 return i - (diff.i < 0);
00320 #endif
00321 }
00322
00323
00324 CV_INLINE int cvCeil( double value )
00325 {
00326 #ifdef __GNUC__
00327 int i = (int)value;
00328 return i + (i < value);
00329 #elif defined _MSC_VER && defined _M_X64
00330 __m128d t = _mm_set_sd( value );
00331 int i = _mm_cvtsd_si32(t);
00332 return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i), t));
00333 #else
00334 int i = cvRound(value);
00335 Cv32suf diff;
00336 diff.f = (float)(i - value);
00337 return i + (diff.i < 0);
00338 #endif
00339 }
00340
00341 #define cvInvSqrt(value) ((float)(1./sqrt(value)))
00342 #define cvSqrt(value) ((float)sqrt(value))
00343
00344 CV_INLINE int cvIsNaN( double value )
00345 {
00346 #if 1
00347
00348
00349
00350
00351 Cv64suf ieee754;
00352 ieee754.f = value;
00353 return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +
00354 ((unsigned)ieee754.u != 0) > 0x7ff00000;
00355 #endif
00356 }
00357
00358
00359 CV_INLINE int cvIsInf( double value )
00360 {
00361 #if 1
00362
00363
00364
00365
00366 Cv64suf ieee754;
00367 ieee754.f = value;
00368 return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&
00369 (unsigned)ieee754.u == 0;
00370 #endif
00371 }
00372
00373
00374
00375
00376 typedef uint64 CvRNG;
00377
00378 CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))
00379 {
00380 CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;
00381 return rng;
00382 }
00383
00384
00385 CV_INLINE unsigned cvRandInt( CvRNG* rng )
00386 {
00387 uint64 temp = *rng;
00388 temp = (uint64)(unsigned)temp*4164903690U + (temp >> 32);
00389 *rng = temp;
00390 return (unsigned)temp;
00391 }
00392
00393
00394 CV_INLINE double cvRandReal( CvRNG* rng )
00395 {
00396 return cvRandInt(rng)*2.3283064365386962890625e-10 ;
00397 }
00398
00399
00400
00401
00402
00403 #ifndef HAVE_IPL
00404
00405
00406
00407
00408
00409
00410 #define IPL_DEPTH_SIGN 0x80000000
00411
00412 #define IPL_DEPTH_1U 1
00413 #define IPL_DEPTH_8U 8
00414 #define IPL_DEPTH_16U 16
00415 #define IPL_DEPTH_32F 32
00416
00417 #define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)
00418 #define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)
00419 #define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)
00420
00421 #define IPL_DATA_ORDER_PIXEL 0
00422 #define IPL_DATA_ORDER_PLANE 1
00423
00424 #define IPL_ORIGIN_TL 0
00425 #define IPL_ORIGIN_BL 1
00426
00427 #define IPL_ALIGN_4BYTES 4
00428 #define IPL_ALIGN_8BYTES 8
00429 #define IPL_ALIGN_16BYTES 16
00430 #define IPL_ALIGN_32BYTES 32
00431
00432 #define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES
00433 #define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES
00434
00435 #define IPL_BORDER_CONSTANT 0
00436 #define IPL_BORDER_REPLICATE 1
00437 #define IPL_BORDER_REFLECT 2
00438 #define IPL_BORDER_WRAP 3
00439
00440 typedef struct _IplImage
00441 {
00442 int nSize;
00443 int ID;
00444 int nChannels;
00445 int alphaChannel;
00446 int depth;
00447
00448 char colorModel[4];
00449 char channelSeq[4];
00450 int dataOrder;
00451
00452 int origin;
00453
00454 int align;
00455
00456 int width;
00457 int height;
00458 struct _IplROI *roi;
00459 struct _IplImage *maskROI;
00460 void *imageId;
00461 struct _IplTileInfo *tileInfo;
00462 int imageSize;
00463
00464
00465 char *imageData;
00466 int widthStep;
00467 int BorderMode[4];
00468 int BorderConst[4];
00469 char *imageDataOrigin;
00470
00471
00472 }
00473 IplImage;
00474
00475 typedef struct _IplTileInfo IplTileInfo;
00476
00477 typedef struct _IplROI
00478 {
00479 int coi;
00480 int xOffset;
00481 int yOffset;
00482 int width;
00483 int height;
00484 }
00485 IplROI;
00486
00487 typedef struct _IplConvKernel
00488 {
00489 int nCols;
00490 int nRows;
00491 int anchorX;
00492 int anchorY;
00493 int *values;
00494 int nShiftR;
00495 }
00496 IplConvKernel;
00497
00498 typedef struct _IplConvKernelFP
00499 {
00500 int nCols;
00501 int nRows;
00502 int anchorX;
00503 int anchorY;
00504 float *values;
00505 }
00506 IplConvKernelFP;
00507
00508 #define IPL_IMAGE_HEADER 1
00509 #define IPL_IMAGE_DATA 2
00510 #define IPL_IMAGE_ROI 4
00511
00512 #endif
00513
00514
00515 #define IPL_BORDER_REFLECT_101 4
00516 #define IPL_BORDER_TRANSPARENT 5
00517
00518 #define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))
00519 #define CV_TYPE_NAME_IMAGE "opencv-image"
00520
00521 #define CV_IS_IMAGE_HDR(img) \
00522 ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))
00523
00524 #define CV_IS_IMAGE(img) \
00525 (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)
00526
00527
00528
00529 #define IPL_DEPTH_64F 64
00530
00531
00532
00533 #define CV_IMAGE_ELEM( image, elemtype, row, col ) \
00534 (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])
00535
00536
00537
00538
00539
00540 #define CV_CN_MAX 512
00541 #define CV_CN_SHIFT 3
00542 #define CV_DEPTH_MAX (1 << CV_CN_SHIFT)
00543
00544 #define CV_8U 0
00545 #define CV_8S 1
00546 #define CV_16U 2
00547 #define CV_16S 3
00548 #define CV_32S 4
00549 #define CV_32F 5
00550 #define CV_64F 6
00551 #define CV_USRTYPE1 7
00552
00553 #define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)
00554 #define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)
00555
00556 #define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
00557 #define CV_MAKE_TYPE CV_MAKETYPE
00558
00559 #define CV_8UC1 CV_MAKETYPE(CV_8U,1)
00560 #define CV_8UC2 CV_MAKETYPE(CV_8U,2)
00561 #define CV_8UC3 CV_MAKETYPE(CV_8U,3)
00562 #define CV_8UC4 CV_MAKETYPE(CV_8U,4)
00563 #define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
00564
00565 #define CV_8SC1 CV_MAKETYPE(CV_8S,1)
00566 #define CV_8SC2 CV_MAKETYPE(CV_8S,2)
00567 #define CV_8SC3 CV_MAKETYPE(CV_8S,3)
00568 #define CV_8SC4 CV_MAKETYPE(CV_8S,4)
00569 #define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
00570
00571 #define CV_16UC1 CV_MAKETYPE(CV_16U,1)
00572 #define CV_16UC2 CV_MAKETYPE(CV_16U,2)
00573 #define CV_16UC3 CV_MAKETYPE(CV_16U,3)
00574 #define CV_16UC4 CV_MAKETYPE(CV_16U,4)
00575 #define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
00576
00577 #define CV_16SC1 CV_MAKETYPE(CV_16S,1)
00578 #define CV_16SC2 CV_MAKETYPE(CV_16S,2)
00579 #define CV_16SC3 CV_MAKETYPE(CV_16S,3)
00580 #define CV_16SC4 CV_MAKETYPE(CV_16S,4)
00581 #define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
00582
00583 #define CV_32SC1 CV_MAKETYPE(CV_32S,1)
00584 #define CV_32SC2 CV_MAKETYPE(CV_32S,2)
00585 #define CV_32SC3 CV_MAKETYPE(CV_32S,3)
00586 #define CV_32SC4 CV_MAKETYPE(CV_32S,4)
00587 #define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
00588
00589 #define CV_32FC1 CV_MAKETYPE(CV_32F,1)
00590 #define CV_32FC2 CV_MAKETYPE(CV_32F,2)
00591 #define CV_32FC3 CV_MAKETYPE(CV_32F,3)
00592 #define CV_32FC4 CV_MAKETYPE(CV_32F,4)
00593 #define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
00594
00595 #define CV_64FC1 CV_MAKETYPE(CV_64F,1)
00596 #define CV_64FC2 CV_MAKETYPE(CV_64F,2)
00597 #define CV_64FC3 CV_MAKETYPE(CV_64F,3)
00598 #define CV_64FC4 CV_MAKETYPE(CV_64F,4)
00599 #define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
00600
00601 #define CV_AUTO_STEP 0x7fffffff
00602 #define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )
00603
00604 #define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)
00605 #define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
00606 #define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)
00607 #define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK)
00608 #define CV_MAT_CONT_FLAG_SHIFT 14
00609 #define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)
00610 #define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG)
00611 #define CV_IS_CONT_MAT CV_IS_MAT_CONT
00612 #define CV_SUBMAT_FLAG_SHIFT 15
00613 #define CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)
00614 #define CV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_FLAG)
00615
00616 #define CV_MAGIC_MASK 0xFFFF0000
00617 #define CV_MAT_MAGIC_VAL 0x42420000
00618 #define CV_TYPE_NAME_MAT "opencv-matrix"
00619
00620 typedef struct CvMat
00621 {
00622 int type;
00623 int step;
00624
00625
00626 int* refcount;
00627 int hdr_refcount;
00628
00629 union
00630 {
00631 uchar* ptr;
00632 short* s;
00633 int* i;
00634 float* fl;
00635 double* db;
00636 } data;
00637
00638 #ifdef __cplusplus
00639 union
00640 {
00641 int rows;
00642 int height;
00643 };
00644
00645 union
00646 {
00647 int cols;
00648 int width;
00649 };
00650 #else
00651 int rows;
00652 int cols;
00653 #endif
00654
00655 }
00656 CvMat;
00657
00658
00659 #define CV_IS_MAT_HDR(mat) \
00660 ((mat) != NULL && \
00661 (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \
00662 ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)
00663
00664 #define CV_IS_MAT_HDR_Z(mat) \
00665 ((mat) != NULL && \
00666 (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \
00667 ((const CvMat*)(mat))->cols >= 0 && ((const CvMat*)(mat))->rows >= 0)
00668
00669 #define CV_IS_MAT(mat) \
00670 (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL)
00671
00672 #define CV_IS_MASK_ARR(mat) \
00673 (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)
00674
00675 #define CV_ARE_TYPES_EQ(mat1, mat2) \
00676 ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)
00677
00678 #define CV_ARE_CNS_EQ(mat1, mat2) \
00679 ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)
00680
00681 #define CV_ARE_DEPTHS_EQ(mat1, mat2) \
00682 ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)
00683
00684 #define CV_ARE_SIZES_EQ(mat1, mat2) \
00685 ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)
00686
00687 #define CV_IS_MAT_CONST(mat) \
00688 (((mat)->rows|(mat)->cols) == 1)
00689
00690
00691
00692 #define CV_ELEM_SIZE1(type) \
00693 ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)
00694
00695
00696 #define CV_ELEM_SIZE(type) \
00697 (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))
00698
00699 #define IPL2CV_DEPTH(depth) \
00700 ((((CV_8U)+(CV_16U<<4)+(CV_32F<<8)+(CV_64F<<16)+(CV_8S<<20)+ \
00701 (CV_16S<<24)+(CV_32S<<28)) >> ((((depth) & 0xF0) >> 2) + \
00702 (((depth) & IPL_DEPTH_SIGN) ? 20 : 0))) & 15)
00703
00704
00705
00706
00707
00708 CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL))
00709 {
00710 CvMat m;
00711
00712 assert( (unsigned)CV_MAT_DEPTH(type) <= CV_64F );
00713 type = CV_MAT_TYPE(type);
00714 m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type;
00715 m.cols = cols;
00716 m.rows = rows;
00717 m.step = m.cols*CV_ELEM_SIZE(type);
00718 m.data.ptr = (uchar*)data;
00719 m.refcount = NULL;
00720 m.hdr_refcount = 0;
00721
00722 return m;
00723 }
00724
00725
00726 #define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \
00727 (assert( (unsigned)(row) < (unsigned)(mat).rows && \
00728 (unsigned)(col) < (unsigned)(mat).cols ), \
00729 (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))
00730
00731 #define CV_MAT_ELEM_PTR( mat, row, col ) \
00732 CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )
00733
00734 #define CV_MAT_ELEM( mat, elemtype, row, col ) \
00735 (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))
00736
00737
00738 CV_INLINE double cvmGet( const CvMat* mat, int row, int col )
00739 {
00740 int type;
00741
00742 type = CV_MAT_TYPE(mat->type);
00743 assert( (unsigned)row < (unsigned)mat->rows &&
00744 (unsigned)col < (unsigned)mat->cols );
00745
00746 if( type == CV_32FC1 )
00747 return ((float*)(mat->data.ptr + (size_t)mat->step*row))[col];
00748 else
00749 {
00750 assert( type == CV_64FC1 );
00751 return ((double*)(mat->data.ptr + (size_t)mat->step*row))[col];
00752 }
00753 }
00754
00755
00756 CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value )
00757 {
00758 int type;
00759 type = CV_MAT_TYPE(mat->type);
00760 assert( (unsigned)row < (unsigned)mat->rows &&
00761 (unsigned)col < (unsigned)mat->cols );
00762
00763 if( type == CV_32FC1 )
00764 ((float*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;
00765 else
00766 {
00767 assert( type == CV_64FC1 );
00768 ((double*)(mat->data.ptr + (size_t)mat->step*row))[col] = (double)value;
00769 }
00770 }
00771
00772
00773 CV_INLINE int cvIplDepth( int type )
00774 {
00775 int depth = CV_MAT_DEPTH(type);
00776 return CV_ELEM_SIZE1(depth)*8 | (depth == CV_8S || depth == CV_16S ||
00777 depth == CV_32S ? IPL_DEPTH_SIGN : 0);
00778 }
00779
00780
00781
00782
00783
00784
00785 #define CV_MATND_MAGIC_VAL 0x42430000
00786 #define CV_TYPE_NAME_MATND "opencv-nd-matrix"
00787
00788 #define CV_MAX_DIM 32
00789 #define CV_MAX_DIM_HEAP (1 << 16)
00790
00791 typedef struct CvMatND
00792 {
00793 int type;
00794 int dims;
00795
00796 int* refcount;
00797 int hdr_refcount;
00798
00799 union
00800 {
00801 uchar* ptr;
00802 float* fl;
00803 double* db;
00804 int* i;
00805 short* s;
00806 } data;
00807
00808 struct
00809 {
00810 int size;
00811 int step;
00812 }
00813 dim[CV_MAX_DIM];
00814 }
00815 CvMatND;
00816
00817 #define CV_IS_MATND_HDR(mat) \
00818 ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)
00819
00820 #define CV_IS_MATND(mat) \
00821 (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)
00822
00823
00824
00825
00826
00827
00828 #define CV_SPARSE_MAT_MAGIC_VAL 0x42440000
00829 #define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
00830
00831 struct CvSet;
00832
00833 typedef struct CvSparseMat
00834 {
00835 int type;
00836 int dims;
00837 int* refcount;
00838 int hdr_refcount;
00839
00840 struct CvSet* heap;
00841 void** hashtable;
00842 int hashsize;
00843 int valoffset;
00844 int idxoffset;
00845 int size[CV_MAX_DIM];
00846 }
00847 CvSparseMat;
00848
00849 #define CV_IS_SPARSE_MAT_HDR(mat) \
00850 ((mat) != NULL && \
00851 (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)
00852
00853 #define CV_IS_SPARSE_MAT(mat) \
00854 CV_IS_SPARSE_MAT_HDR(mat)
00855
00856
00857
00858 typedef struct CvSparseNode
00859 {
00860 unsigned hashval;
00861 struct CvSparseNode* next;
00862 }
00863 CvSparseNode;
00864
00865 typedef struct CvSparseMatIterator
00866 {
00867 CvSparseMat* mat;
00868 CvSparseNode* node;
00869 int curidx;
00870 }
00871 CvSparseMatIterator;
00872
00873 #define CV_NODE_VAL(mat,node) ((void*)((uchar*)(node) + (mat)->valoffset))
00874 #define CV_NODE_IDX(mat,node) ((int*)((uchar*)(node) + (mat)->idxoffset))
00875
00876
00877
00878
00879
00880 typedef int CvHistType;
00881
00882 #define CV_HIST_MAGIC_VAL 0x42450000
00883 #define CV_HIST_UNIFORM_FLAG (1 << 10)
00884
00885
00886 #define CV_HIST_RANGES_FLAG (1 << 11)
00887
00888 #define CV_HIST_ARRAY 0
00889 #define CV_HIST_SPARSE 1
00890 #define CV_HIST_TREE CV_HIST_SPARSE
00891
00892
00893
00894 #define CV_HIST_UNIFORM 1
00895
00896 typedef struct CvHistogram
00897 {
00898 int type;
00899 CvArr* bins;
00900 float thresh[CV_MAX_DIM][2];
00901 float** thresh2;
00902 CvMatND mat;
00903 }
00904 CvHistogram;
00905
00906 #define CV_IS_HIST( hist ) \
00907 ((hist) != NULL && \
00908 (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \
00909 (hist)->bins != NULL)
00910
00911 #define CV_IS_UNIFORM_HIST( hist ) \
00912 (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)
00913
00914 #define CV_IS_SPARSE_HIST( hist ) \
00915 CV_IS_SPARSE_MAT((hist)->bins)
00916
00917 #define CV_HIST_HAS_RANGES( hist ) \
00918 (((hist)->type & CV_HIST_RANGES_FLAG) != 0)
00919
00920
00921
00922
00923
00924
00925
00926 typedef struct CvRect
00927 {
00928 int x;
00929 int y;
00930 int width;
00931 int height;
00932 }
00933 CvRect;
00934
00935 CV_INLINE CvRect cvRect( int x, int y, int width, int height )
00936 {
00937 CvRect r;
00938
00939 r.x = x;
00940 r.y = y;
00941 r.width = width;
00942 r.height = height;
00943
00944 return r;
00945 }
00946
00947
00948 CV_INLINE IplROI cvRectToROI( CvRect rect, int coi )
00949 {
00950 IplROI roi;
00951 roi.xOffset = rect.x;
00952 roi.yOffset = rect.y;
00953 roi.width = rect.width;
00954 roi.height = rect.height;
00955 roi.coi = coi;
00956
00957 return roi;
00958 }
00959
00960
00961 CV_INLINE CvRect cvROIToRect( IplROI roi )
00962 {
00963 return cvRect( roi.xOffset, roi.yOffset, roi.width, roi.height );
00964 }
00965
00966
00967
00968 #define CV_TERMCRIT_ITER 1
00969 #define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER
00970 #define CV_TERMCRIT_EPS 2
00971
00972 typedef struct CvTermCriteria
00973 {
00974 int type;
00975
00976
00977 int max_iter;
00978 double epsilon;
00979 }
00980 CvTermCriteria;
00981
00982 CV_INLINE CvTermCriteria cvTermCriteria( int type, int max_iter, double epsilon )
00983 {
00984 CvTermCriteria t;
00985
00986 t.type = type;
00987 t.max_iter = max_iter;
00988 t.epsilon = (float)epsilon;
00989
00990 return t;
00991 }
00992
00993
00994
00995
00996 typedef struct CvPoint
00997 {
00998 int x;
00999 int y;
01000 }
01001 CvPoint;
01002
01003
01004 CV_INLINE CvPoint cvPoint( int x, int y )
01005 {
01006 CvPoint p;
01007
01008 p.x = x;
01009 p.y = y;
01010
01011 return p;
01012 }
01013
01014
01015 typedef struct CvPoint2D32f
01016 {
01017 float x;
01018 float y;
01019 }
01020 CvPoint2D32f;
01021
01022
01023 CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y )
01024 {
01025 CvPoint2D32f p;
01026
01027 p.x = (float)x;
01028 p.y = (float)y;
01029
01030 return p;
01031 }
01032
01033
01034 CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )
01035 {
01036 return cvPoint2D32f( (float)point.x, (float)point.y );
01037 }
01038
01039
01040 CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point )
01041 {
01042 CvPoint ipt;
01043 ipt.x = cvRound(point.x);
01044 ipt.y = cvRound(point.y);
01045
01046 return ipt;
01047 }
01048
01049
01050 typedef struct CvPoint3D32f
01051 {
01052 float x;
01053 float y;
01054 float z;
01055 }
01056 CvPoint3D32f;
01057
01058
01059 CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z )
01060 {
01061 CvPoint3D32f p;
01062
01063 p.x = (float)x;
01064 p.y = (float)y;
01065 p.z = (float)z;
01066
01067 return p;
01068 }
01069
01070
01071 typedef struct CvPoint2D64f
01072 {
01073 double x;
01074 double y;
01075 }
01076 CvPoint2D64f;
01077
01078
01079 CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y )
01080 {
01081 CvPoint2D64f p;
01082
01083 p.x = x;
01084 p.y = y;
01085
01086 return p;
01087 }
01088
01089
01090 typedef struct CvPoint3D64f
01091 {
01092 double x;
01093 double y;
01094 double z;
01095 }
01096 CvPoint3D64f;
01097
01098
01099 CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z )
01100 {
01101 CvPoint3D64f p;
01102
01103 p.x = x;
01104 p.y = y;
01105 p.z = z;
01106
01107 return p;
01108 }
01109
01110
01111
01112
01113 typedef struct
01114 {
01115 int width;
01116 int height;
01117 }
01118 CvSize;
01119
01120 CV_INLINE CvSize cvSize( int width, int height )
01121 {
01122 CvSize s;
01123
01124 s.width = width;
01125 s.height = height;
01126
01127 return s;
01128 }
01129
01130 typedef struct CvSize2D32f
01131 {
01132 float width;
01133 float height;
01134 }
01135 CvSize2D32f;
01136
01137
01138 CV_INLINE CvSize2D32f cvSize2D32f( double width, double height )
01139 {
01140 CvSize2D32f s;
01141
01142 s.width = (float)width;
01143 s.height = (float)height;
01144
01145 return s;
01146 }
01147
01148 typedef struct CvBox2D
01149 {
01150 CvPoint2D32f center;
01151 CvSize2D32f size;
01152 float angle;
01153
01154 }
01155 CvBox2D;
01156
01157
01158
01159 typedef struct CvLineIterator
01160 {
01161
01162 uchar* ptr;
01163
01164
01165 int err;
01166 int plus_delta;
01167 int minus_delta;
01168 int plus_step;
01169 int minus_step;
01170 }
01171 CvLineIterator;
01172
01173
01174
01175
01176
01177 typedef struct CvSlice
01178 {
01179 int start_index, end_index;
01180 }
01181 CvSlice;
01182
01183 CV_INLINE CvSlice cvSlice( int start, int end )
01184 {
01185 CvSlice slice;
01186 slice.start_index = start;
01187 slice.end_index = end;
01188
01189 return slice;
01190 }
01191
01192 #define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
01193 #define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
01194
01195
01196
01197
01198 typedef struct CvScalar
01199 {
01200 double val[4];
01201 }
01202 CvScalar;
01203
01204 CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0),
01205 double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))
01206 {
01207 CvScalar scalar;
01208 scalar.val[0] = val0; scalar.val[1] = val1;
01209 scalar.val[2] = val2; scalar.val[3] = val3;
01210 return scalar;
01211 }
01212
01213
01214 CV_INLINE CvScalar cvRealScalar( double val0 )
01215 {
01216 CvScalar scalar;
01217 scalar.val[0] = val0;
01218 scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
01219 return scalar;
01220 }
01221
01222 CV_INLINE CvScalar cvScalarAll( double val0123 )
01223 {
01224 CvScalar scalar;
01225 scalar.val[0] = val0123;
01226 scalar.val[1] = val0123;
01227 scalar.val[2] = val0123;
01228 scalar.val[3] = val0123;
01229 return scalar;
01230 }
01231
01232
01233
01234
01235
01236
01237
01238 typedef struct CvMemBlock
01239 {
01240 struct CvMemBlock* prev;
01241 struct CvMemBlock* next;
01242 }
01243 CvMemBlock;
01244
01245 #define CV_STORAGE_MAGIC_VAL 0x42890000
01246
01247 typedef struct CvMemStorage
01248 {
01249 int signature;
01250 CvMemBlock* bottom;
01251 CvMemBlock* top;
01252 struct CvMemStorage* parent;
01253 int block_size;
01254 int free_space;
01255 }
01256 CvMemStorage;
01257
01258 #define CV_IS_STORAGE(storage) \
01259 ((storage) != NULL && \
01260 (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)
01261
01262
01263 typedef struct CvMemStoragePos
01264 {
01265 CvMemBlock* top;
01266 int free_space;
01267 }
01268 CvMemStoragePos;
01269
01270
01271
01272
01273 typedef struct CvSeqBlock
01274 {
01275 struct CvSeqBlock* prev;
01276 struct CvSeqBlock* next;
01277 int start_index;
01278
01279 int count;
01280 schar* data;
01281 }
01282 CvSeqBlock;
01283
01284
01285 #define CV_TREE_NODE_FIELDS(node_type) \
01286 int flags; \
01287 int header_size; \
01288 struct node_type* h_prev; \
01289 struct node_type* h_next; \
01290 struct node_type* v_prev; \
01291 struct node_type* v_next
01292
01293
01294
01295
01296
01297 #define CV_SEQUENCE_FIELDS() \
01298 CV_TREE_NODE_FIELDS(CvSeq); \
01299 int total; \
01300 int elem_size; \
01301 schar* block_max; \
01302 schar* ptr; \
01303 int delta_elems; \
01304 CvMemStorage* storage; \
01305 CvSeqBlock* free_blocks; \
01306 CvSeqBlock* first;
01307
01308 typedef struct CvSeq
01309 {
01310 CV_SEQUENCE_FIELDS()
01311 }
01312 CvSeq;
01313
01314 #define CV_TYPE_NAME_SEQ "opencv-sequence"
01315 #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
01316
01317
01318
01319
01320
01321
01322
01323
01324 #define CV_SET_ELEM_FIELDS(elem_type) \
01325 int flags; \
01326 struct elem_type* next_free;
01327
01328 typedef struct CvSetElem
01329 {
01330 CV_SET_ELEM_FIELDS(CvSetElem)
01331 }
01332 CvSetElem;
01333
01334 #define CV_SET_FIELDS() \
01335 CV_SEQUENCE_FIELDS() \
01336 CvSetElem* free_elems; \
01337 int active_count;
01338
01339 typedef struct CvSet
01340 {
01341 CV_SET_FIELDS()
01342 }
01343 CvSet;
01344
01345
01346 #define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)
01347 #define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))
01348
01349
01350 #define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0)
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372 #define CV_GRAPH_EDGE_FIELDS() \
01373 int flags; \
01374 float weight; \
01375 struct CvGraphEdge* next[2]; \
01376 struct CvGraphVtx* vtx[2];
01377
01378
01379 #define CV_GRAPH_VERTEX_FIELDS() \
01380 int flags; \
01381 struct CvGraphEdge* first;
01382
01383
01384 typedef struct CvGraphEdge
01385 {
01386 CV_GRAPH_EDGE_FIELDS()
01387 }
01388 CvGraphEdge;
01389
01390 typedef struct CvGraphVtx
01391 {
01392 CV_GRAPH_VERTEX_FIELDS()
01393 }
01394 CvGraphVtx;
01395
01396 typedef struct CvGraphVtx2D
01397 {
01398 CV_GRAPH_VERTEX_FIELDS()
01399 CvPoint2D32f* ptr;
01400 }
01401 CvGraphVtx2D;
01402
01403
01404
01405
01406
01407 #define CV_GRAPH_FIELDS() \
01408 CV_SET_FIELDS() \
01409 CvSet* edges;
01410
01411 typedef struct CvGraph
01412 {
01413 CV_GRAPH_FIELDS()
01414 }
01415 CvGraph;
01416
01417 #define CV_TYPE_NAME_GRAPH "opencv-graph"
01418
01419
01420
01421 typedef struct CvChain
01422 {
01423 CV_SEQUENCE_FIELDS()
01424 CvPoint origin;
01425 }
01426 CvChain;
01427
01428 #define CV_CONTOUR_FIELDS() \
01429 CV_SEQUENCE_FIELDS() \
01430 CvRect rect; \
01431 int color; \
01432 int reserved[3];
01433
01434 typedef struct CvContour
01435 {
01436 CV_CONTOUR_FIELDS()
01437 }
01438 CvContour;
01439
01440 typedef CvContour CvPoint2DSeq;
01441
01442
01443
01444
01445
01446 #define CV_SEQ_MAGIC_VAL 0x42990000
01447
01448 #define CV_IS_SEQ(seq) \
01449 ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)
01450
01451 #define CV_SET_MAGIC_VAL 0x42980000
01452 #define CV_IS_SET(set) \
01453 ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)
01454
01455 #define CV_SEQ_ELTYPE_BITS 12
01456 #define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)
01457
01458 #define CV_SEQ_ELTYPE_POINT CV_32SC2
01459 #define CV_SEQ_ELTYPE_CODE CV_8UC1
01460 #define CV_SEQ_ELTYPE_GENERIC 0
01461 #define CV_SEQ_ELTYPE_PTR CV_USRTYPE1
01462 #define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR
01463 #define CV_SEQ_ELTYPE_INDEX CV_32SC1
01464 #define CV_SEQ_ELTYPE_GRAPH_EDGE 0
01465 #define CV_SEQ_ELTYPE_GRAPH_VERTEX 0
01466 #define CV_SEQ_ELTYPE_TRIAN_ATR 0
01467 #define CV_SEQ_ELTYPE_CONNECTED_COMP 0
01468 #define CV_SEQ_ELTYPE_POINT3D CV_32FC3
01469
01470 #define CV_SEQ_KIND_BITS 2
01471 #define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)
01472
01473
01474 #define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)
01475 #define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)
01476 #define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)
01477
01478
01479 #define CV_SEQ_KIND_GRAPH (1 << CV_SEQ_ELTYPE_BITS)
01480 #define CV_SEQ_KIND_SUBDIV2D (2 << CV_SEQ_ELTYPE_BITS)
01481
01482 #define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)
01483
01484
01485 #define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)
01486 #define CV_SEQ_FLAG_SIMPLE (0 << CV_SEQ_FLAG_SHIFT)
01487 #define CV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)
01488 #define CV_SEQ_FLAG_HOLE (2 << CV_SEQ_FLAG_SHIFT)
01489
01490
01491 #define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)
01492
01493 #define CV_GRAPH CV_SEQ_KIND_GRAPH
01494 #define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)
01495
01496
01497 #define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)
01498 #define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)
01499 #define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)
01500 #define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )
01501 #define CV_SEQ_CONTOUR CV_SEQ_POLYGON
01502 #define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )
01503
01504
01505 #define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)
01506 #define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)
01507
01508
01509 #define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)
01510
01511
01512 #define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)
01513
01514
01515 #define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)
01516
01517 #define CV_SEQ_ELTYPE( seq ) ((seq)->flags & CV_SEQ_ELTYPE_MASK)
01518 #define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK )
01519
01520
01521 #define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \
01522 (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))
01523
01524 #define CV_IS_SEQ_CURVE( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)
01525 #define CV_IS_SEQ_CLOSED( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)
01526 #define CV_IS_SEQ_CONVEX( seq ) 0
01527 #define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
01528 #define CV_IS_SEQ_SIMPLE( seq ) 1
01529
01530
01531 #define CV_IS_SEQ_POINT_SET( seq ) \
01532 ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))
01533
01534 #define CV_IS_SEQ_POINT_SUBSET( seq ) \
01535 (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)
01536
01537 #define CV_IS_SEQ_POLYLINE( seq ) \
01538 (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))
01539
01540 #define CV_IS_SEQ_POLYGON( seq ) \
01541 (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))
01542
01543 #define CV_IS_SEQ_CHAIN( seq ) \
01544 (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)
01545
01546 #define CV_IS_SEQ_CONTOUR( seq ) \
01547 (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))
01548
01549 #define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \
01550 (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))
01551
01552 #define CV_IS_SEQ_POLYGON_TREE( seq ) \
01553 (CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && \
01554 CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE )
01555
01556 #define CV_IS_GRAPH( seq ) \
01557 (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)
01558
01559 #define CV_IS_GRAPH_ORIENTED( seq ) \
01560 (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)
01561
01562 #define CV_IS_SUBDIV2D( seq ) \
01563 (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)
01564
01565
01566
01567
01568
01569 #define CV_SEQ_WRITER_FIELDS() \
01570 int header_size; \
01571 CvSeq* seq; \
01572 CvSeqBlock* block; \
01573 schar* ptr; \
01574 schar* block_min; \
01575 schar* block_max;
01576
01577 typedef struct CvSeqWriter
01578 {
01579 CV_SEQ_WRITER_FIELDS()
01580 }
01581 CvSeqWriter;
01582
01583
01584 #define CV_SEQ_READER_FIELDS() \
01585 int header_size; \
01586 CvSeq* seq; \
01587 CvSeqBlock* block; \
01588 schar* ptr; \
01589 schar* block_min; \
01590 schar* block_max; \
01591 int delta_index; \
01592 schar* prev_elem;
01593
01594
01595 typedef struct CvSeqReader
01596 {
01597 CV_SEQ_READER_FIELDS()
01598 }
01599 CvSeqReader;
01600
01601
01602
01603
01604
01605 #define CV_SEQ_ELEM( seq, elem_type, index ) \
01606 \
01607 ( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && \
01608 (seq)->elem_size == sizeof(elem_type)), \
01609 (elem_type*)((seq)->first && (unsigned)index < \
01610 (unsigned)((seq)->first->count) ? \
01611 (seq)->first->data + (index) * sizeof(elem_type) : \
01612 cvGetSeqElem( (CvSeq*)(seq), (index) )))
01613 #define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) )
01614
01615
01616 #define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) \
01617 { \
01618 if( (writer).ptr >= (writer).block_max ) \
01619 { \
01620 cvCreateSeqBlock( &writer); \
01621 } \
01622 memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\
01623 (writer).ptr += (writer).seq->elem_size; \
01624 }
01625
01626 #define CV_WRITE_SEQ_ELEM( elem, writer ) \
01627 { \
01628 assert( (writer).seq->elem_size == sizeof(elem)); \
01629 if( (writer).ptr >= (writer).block_max ) \
01630 { \
01631 cvCreateSeqBlock( &writer); \
01632 } \
01633 assert( (writer).ptr <= (writer).block_max - sizeof(elem));\
01634 memcpy((writer).ptr, &(elem), sizeof(elem)); \
01635 (writer).ptr += sizeof(elem); \
01636 }
01637
01638
01639
01640 #define CV_NEXT_SEQ_ELEM( elem_size, reader ) \
01641 { \
01642 if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \
01643 { \
01644 cvChangeSeqBlock( &(reader), 1 ); \
01645 } \
01646 }
01647
01648
01649
01650 #define CV_PREV_SEQ_ELEM( elem_size, reader ) \
01651 { \
01652 if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \
01653 { \
01654 cvChangeSeqBlock( &(reader), -1 ); \
01655 } \
01656 }
01657
01658
01659 #define CV_READ_SEQ_ELEM( elem, reader ) \
01660 { \
01661 assert( (reader).seq->elem_size == sizeof(elem)); \
01662 memcpy( &(elem), (reader).ptr, sizeof((elem))); \
01663 CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) \
01664 }
01665
01666
01667 #define CV_REV_READ_SEQ_ELEM( elem, reader ) \
01668 { \
01669 assert( (reader).seq->elem_size == sizeof(elem)); \
01670 memcpy(&(elem), (reader).ptr, sizeof((elem))); \
01671 CV_PREV_SEQ_ELEM( sizeof(elem), reader ) \
01672 }
01673
01674
01675 #define CV_READ_CHAIN_POINT( _pt, reader ) \
01676 { \
01677 (_pt) = (reader).pt; \
01678 if( (reader).ptr ) \
01679 { \
01680 CV_READ_SEQ_ELEM( (reader).code, (reader)); \
01681 assert( ((reader).code & ~7) == 0 ); \
01682 (reader).pt.x += (reader).deltas[(int)(reader).code][0]; \
01683 (reader).pt.y += (reader).deltas[(int)(reader).code][1]; \
01684 } \
01685 }
01686
01687 #define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr)))
01688 #define CV_PREV_POINT( reader ) (*((CvPoint*)((reader).prev_elem)))
01689
01690 #define CV_READ_EDGE( pt1, pt2, reader ) \
01691 { \
01692 assert( sizeof(pt1) == sizeof(CvPoint) && \
01693 sizeof(pt2) == sizeof(CvPoint) && \
01694 reader.seq->elem_size == sizeof(CvPoint)); \
01695 (pt1) = CV_PREV_POINT( reader ); \
01696 (pt2) = CV_CURRENT_POINT( reader ); \
01697 (reader).prev_elem = (reader).ptr; \
01698 CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader)); \
01699 }
01700
01701
01702
01703
01704 #define CV_NEXT_GRAPH_EDGE( edge, vertex ) \
01705 (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \
01706 (edge)->next[(edge)->vtx[1] == (vertex)])
01707
01708
01709
01710
01711
01712
01713
01714
01715 typedef struct CvFileStorage CvFileStorage;
01716
01717
01718 #define CV_STORAGE_READ 0
01719 #define CV_STORAGE_WRITE 1
01720 #define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE
01721 #define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE
01722 #define CV_STORAGE_APPEND 2
01723
01724
01725 typedef struct CvAttrList
01726 {
01727 const char** attr;
01728 struct CvAttrList* next;
01729 }
01730 CvAttrList;
01731
01732 CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),
01733 CvAttrList* next CV_DEFAULT(NULL) )
01734 {
01735 CvAttrList l;
01736 l.attr = attr;
01737 l.next = next;
01738
01739 return l;
01740 }
01741
01742 struct CvTypeInfo;
01743
01744 #define CV_NODE_NONE 0
01745 #define CV_NODE_INT 1
01746 #define CV_NODE_INTEGER CV_NODE_INT
01747 #define CV_NODE_REAL 2
01748 #define CV_NODE_FLOAT CV_NODE_REAL
01749 #define CV_NODE_STR 3
01750 #define CV_NODE_STRING CV_NODE_STR
01751 #define CV_NODE_REF 4
01752 #define CV_NODE_SEQ 5
01753 #define CV_NODE_MAP 6
01754 #define CV_NODE_TYPE_MASK 7
01755
01756 #define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK)
01757
01758
01759 #define CV_NODE_FLOW 8
01760 #define CV_NODE_USER 16
01761 #define CV_NODE_EMPTY 32
01762 #define CV_NODE_NAMED 64
01763
01764 #define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT)
01765 #define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL)
01766 #define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING)
01767 #define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)
01768 #define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP)
01769 #define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)
01770 #define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0)
01771 #define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0)
01772 #define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0)
01773 #define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0)
01774
01775 #define CV_NODE_SEQ_SIMPLE 256
01776 #define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)
01777
01778 typedef struct CvString
01779 {
01780 int len;
01781 char* ptr;
01782 }
01783 CvString;
01784
01785
01786
01787 typedef struct CvStringHashNode
01788 {
01789 unsigned hashval;
01790 CvString str;
01791 struct CvStringHashNode* next;
01792 }
01793 CvStringHashNode;
01794
01795 typedef struct CvGenericHash CvFileNodeHash;
01796
01797
01798 typedef struct CvFileNode
01799 {
01800 int tag;
01801 struct CvTypeInfo* info;
01802
01803 union
01804 {
01805 double f;
01806 int i;
01807 CvString str;
01808 CvSeq* seq;
01809 CvFileNodeHash* map;
01810 } data;
01811 }
01812 CvFileNode;
01813
01814 #ifdef __cplusplus
01815 extern "C" {
01816 #endif
01817 typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
01818 typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
01819 typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );
01820 typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,
01821 const void* struct_ptr, CvAttrList attributes );
01822 typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );
01823 #ifdef __cplusplus
01824 }
01825 #endif
01826
01827 typedef struct CvTypeInfo
01828 {
01829 int flags;
01830 int header_size;
01831 struct CvTypeInfo* prev;
01832 struct CvTypeInfo* next;
01833 const char* type_name;
01834 CvIsInstanceFunc is_instance;
01835 CvReleaseFunc release;
01836 CvReadFunc read;
01837 CvWriteFunc write;
01838 CvCloneFunc clone;
01839 }
01840 CvTypeInfo;
01841
01842
01843
01844
01845 typedef struct CvPluginFuncInfo
01846 {
01847 void** func_addr;
01848 void* default_func_addr;
01849 const char* func_names;
01850 int search_modules;
01851 int loaded_from;
01852 }
01853 CvPluginFuncInfo;
01854
01855 typedef struct CvModuleInfo
01856 {
01857 struct CvModuleInfo* next;
01858 const char* name;
01859 const char* version;
01860 CvPluginFuncInfo* func_tab;
01861 }
01862 CvModuleInfo;
01863
01864 #endif
01865
01866