opencv/include/opencv/cxtypes.h

   1 /*M///////////////////////////////////////////////////////////////////////////////////////\r
   2 //\r
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
   4 //\r
   5 //  By downloading, copying, installing or using the software you agree to this license.\r
   6 //  If you do not agree to this license, do not download, install,\r
   7 //  copy or use the software.\r
   8 //\r
   9 //\r
  10 //                          License Agreement\r
  11 //                For Open Source Computer Vision Library\r
  12 //\r
  13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.\r
  14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.\r
  15 // Third party copyrights are property of their respective owners.\r
  16 //\r
  17 // Redistribution and use in source and binary forms, with or without modification,\r
  18 // are permitted provided that the following conditions are met:\r
  19 //\r
  20 //   * Redistribution's of source code must retain the above copyright notice,\r
  21 //     this list of conditions and the following disclaimer.\r
  22 //\r
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,\r
  24 //     this list of conditions and the following disclaimer in the documentation\r
  25 //     and/or other materials provided with the distribution.\r
  26 //\r
  27 //   * The name of the copyright holders may not be used to endorse or promote products\r
  28 //     derived from this software without specific prior written permission.\r
  29 //\r
  30 // This software is provided by the copyright holders and contributors "as is" and\r
  31 // any express or implied warranties, including, but not limited to, the implied\r
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.\r
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,\r
  34 // indirect, incidental, special, exemplary, or consequential damages\r
  35 // (including, but not limited to, procurement of substitute goods or services;\r
  36 // loss of use, data, or profits; or business interruption) however caused\r
  37 // and on any theory of liability, whether in contract, strict liability,\r
  38 // or tort (including negligence or otherwise) arising in any way out of\r
  39 // the use of this software, even if advised of the possibility of such damage.\r
  40 //\r
  41 //M*/\r
  42 \r
  43 #ifndef _CXCORE_TYPES_H_\r
  44 #define _CXCORE_TYPES_H_\r
  45 \r
  46 #if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300\r
  47 #define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */\r
  48 #endif\r
  49 \r
  50 #ifndef SKIP_INCLUDES\r
  51   #include <assert.h>\r
  52   #include <stdlib.h>\r
  53   #include <string.h>\r
  54   #include <float.h>\r
  55 \r
  56   #if defined __ICL\r
  57     #define CV_ICC   __ICL\r
  58   #elif defined __ICC\r
  59     #define CV_ICC   __ICC\r
  60   #elif defined __ECL\r
  61     #define CV_ICC   __ECL\r
  62   #elif defined __ECC\r
  63     #define CV_ICC   __ECC\r
  64   #endif\r
  65 \r
  66   #if defined WIN32 && (!defined WIN64 || defined EM64T) && \\r
  67       (_MSC_VER >= 1400 || defined CV_ICC) \\r
  68       || (defined __SSE2__ && defined __GNUC__ && __GNUC__ >= 4)\r
  69     #include <emmintrin.h>\r
  70     #define CV_SSE2 1\r
  71   #else\r
  72     #define CV_SSE2 0\r
  73   #endif\r
  74 \r
  75   #if ((defined __SSE__ || defined __MMX__) && defined __GNUC__ && __GNUC__ >= 3)\r
  76     #include <mmintrin.h>\r
  77   #endif\r
  78 \r
  79   #if defined __BORLANDC__\r
  80     #include <fastmath.h>\r
  81   #elif defined WIN64 && !defined EM64T && defined CV_ICC\r
  82     #include <mathimf.h>\r
  83   #else\r
  84     #include <math.h>\r
  85   #endif\r
  86 \r
  87   #ifdef HAVE_IPL\r
  88       #ifndef __IPL_H__\r
  89           #if defined WIN32 || defined WIN64\r
  90               #include <ipl.h>\r
  91           #else\r
  92               #include <ipl/ipl.h>\r
  93           #endif\r
  94       #endif\r
  95   #elif defined __IPL_H__\r
  96       #define HAVE_IPL\r
  97   #endif\r
  98 #endif // SKIP_INCLUDES\r
  99 \r
 100 #if defined WIN32 || defined WIN64\r
 101     #define CV_CDECL __cdecl\r
 102     #define CV_STDCALL __stdcall\r
 103 #else\r
 104     #define CV_CDECL\r
 105     #define CV_STDCALL\r
 106 #endif\r
 107 \r
 108 #ifndef CV_EXTERN_C\r
 109     #ifdef __cplusplus\r
 110         #define CV_EXTERN_C extern "C"\r
 111         #define CV_DEFAULT(val) = val\r
 112     #else\r
 113         #define CV_EXTERN_C\r
 114         #define CV_DEFAULT(val)\r
 115     #endif\r
 116 #endif\r
 117 \r
 118 #ifndef CV_EXTERN_C_FUNCPTR\r
 119     #ifdef __cplusplus\r
 120         #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }\r
 121     #else\r
 122         #define CV_EXTERN_C_FUNCPTR(x) typedef x\r
 123     #endif\r
 124 #endif\r
 125 \r
 126 #ifndef CV_INLINE\r
 127 #if defined __cplusplus\r
 128     #define CV_INLINE inline\r
 129 #elif (defined WIN32 || defined WIN64 || defined WINCE) && !defined __GNUC__\r
 130     #define CV_INLINE __inline\r
 131 #else\r
 132     #define CV_INLINE static\r
 133 #endif\r
 134 #endif /* CV_INLINE */\r
 135 \r
 136 #if (defined WIN32 || defined WIN64 || defined WINCE) && defined CVAPI_EXPORTS\r
 137     #define CV_EXPORTS __declspec(dllexport)\r
 138 #else\r
 139     #define CV_EXPORTS\r
 140 #endif\r
 141 \r
 142 #ifndef CVAPI\r
 143     #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL\r
 144 #endif\r
 145 \r
 146 #if defined _MSC_VER || defined __BORLANDC__\r
 147 typedef __int64 int64;\r
 148 typedef unsigned __int64 uint64;\r
 149 #else\r
 150 typedef long long int64;\r
 151 typedef unsigned long long uint64;\r
 152 #endif\r
 153 \r
 154 #ifndef HAVE_IPL\r
 155 typedef unsigned char uchar;\r
 156 typedef unsigned short ushort;\r
 157 #endif\r
 158 \r
 159 typedef signed char schar;\r
 160 \r
 161 /* CvArr* is used to pass arbitrary\r
 162  * array-like data structures\r
 163  * into functions where the particular\r
 164  * array type is recognized at runtime:\r
 165  */\r
 166 typedef void CvArr;\r
 167 \r
 168 typedef union Cv32suf\r
 169 {\r
 170     int i;\r
 171     unsigned u;\r
 172     float f;\r
 173 }\r
 174 Cv32suf;\r
 175 \r
 176 typedef union Cv64suf\r
 177 {\r
 178     int64 i;\r
 179     uint64 u;\r
 180     double f;\r
 181 }\r
 182 Cv64suf;\r
 183 \r
 184 /****************************************************************************************\\r
 185 *                             Common macros and inline functions                         *\r
 186 \****************************************************************************************/\r
 187 \r
 188 #define CV_PI   3.1415926535897932384626433832795\r
 189 #define CV_LOG2 0.69314718055994530941723212145818\r
 190 \r
 191 #define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))\r
 192 \r
 193 #ifndef MIN\r
 194 #define MIN(a,b)  ((a) > (b) ? (b) : (a))\r
 195 #endif\r
 196 \r
 197 #ifndef MAX\r
 198 #define MAX(a,b)  ((a) < (b) ? (b) : (a))\r
 199 #endif\r
 200 \r
 201 /* min & max without jumps */\r
 202 #define  CV_IMIN(a, b)  ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))\r
 203 \r
 204 #define  CV_IMAX(a, b)  ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))\r
 205 \r
 206 /* absolute value without jumps */\r
 207 #ifndef __cplusplus\r
 208 #define  CV_IABS(a)     (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))\r
 209 #else\r
 210 #define  CV_IABS(a)     abs(a)\r
 211 #endif\r
 212 #define  CV_CMP(a,b)    (((a) > (b)) - ((a) < (b)))\r
 213 #define  CV_SIGN(a)     CV_CMP((a),0)\r
 214 \r
 215 CV_INLINE  int  cvRound( double value )\r
 216 {\r
 217 #if CV_SSE2\r
 218     __m128d t = _mm_load_sd( &value );\r
 219     return _mm_cvtsd_si32(t);\r
 220 #elif defined WIN32 && !defined WIN64 && defined _MSC_VER\r
 221     int t;\r
 222     __asm\r
 223     {\r
 224         fld value;\r
 225         fistp t;\r
 226     }\r
 227     return t;\r
 228 #elif (defined HAVE_LRINT) || (defined WIN64 && !defined EM64T && defined CV_ICC)\r
 229     return (int)lrint(value);\r
 230 #else\r
 231     /*\r
 232      the algorithm was taken from Agner Fog's optimization guide\r
 233      at http://www.agner.org/assem\r
 234      */\r
 235     Cv64suf temp;\r
 236     temp.f = value + 6755399441055744.0;\r
 237     return (int)temp.u;\r
 238 #endif\r
 239 }\r
 240 \r
 241 \r
 242 CV_INLINE  int  cvFloor( double value )\r
 243 {\r
 244 #if CV_SSE2\r
 245     __m128d t = _mm_load_sd( &value );\r
 246     int i = _mm_cvtsd_si32(t);\r
 247     return i - _mm_movemask_pd(_mm_cmplt_sd(t,_mm_cvtsi32_sd(t,i)));\r
 248 #else\r
 249     int temp = cvRound(value);\r
 250     Cv32suf diff;\r
 251     diff.f = (float)(value - temp);\r
 252     return temp - (diff.i < 0);\r
 253 #endif\r
 254 }\r
 255 \r
 256 \r
 257 CV_INLINE  int  cvCeil( double value )\r
 258 {\r
 259 #if CV_SSE2\r
 260     __m128d t = _mm_load_sd( &value );\r
 261     int i = _mm_cvtsd_si32(t);\r
 262     return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i),t));\r
 263 #else\r
 264     int temp = cvRound(value);\r
 265     Cv32suf diff;\r
 266     diff.f = (float)(temp - value);\r
 267     return temp + (diff.i < 0);\r
 268 #endif\r
 269 }\r
 270 \r
 271 #define cvInvSqrt(value) ((float)(1./sqrt(value)))\r
 272 #define cvSqrt(value)  ((float)sqrt(value))\r
 273 \r
 274 CV_INLINE int cvIsNaN( double value )\r
 275 {\r
 276 #if 1/*defined _MSC_VER || defined __BORLANDC__\r
 277     return _isnan(value);\r
 278 #elif defined __GNUC__\r
 279     return isnan(value);\r
 280 #else*/\r
 281     Cv64suf ieee754;\r
 282     ieee754.f = value;\r
 283     return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +\r
 284            ((unsigned)ieee754.u != 0) > 0x7ff00000;\r
 285 #endif\r
 286 }\r
 287 \r
 288 \r
 289 CV_INLINE int cvIsInf( double value )\r
 290 {\r
 291 #if 1/*defined _MSC_VER || defined __BORLANDC__\r
 292     return !_finite(value);\r
 293 #elif defined __GNUC__\r
 294     return isinf(value);\r
 295 #else*/\r
 296     Cv64suf ieee754;\r
 297     ieee754.f = value;\r
 298     return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&\r
 299            (unsigned)ieee754.u == 0;\r
 300 #endif\r
 301 }\r
 302 \r
 303 \r
 304 /*************** Random number generation *******************/\r
 305 \r
 306 typedef uint64 CvRNG;\r
 307 \r
 308 CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))\r
 309 {\r
 310     CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;\r
 311     return rng;\r
 312 }\r
 313 \r
 314 /* Return random 32-bit unsigned integer: */\r
 315 CV_INLINE unsigned cvRandInt( CvRNG* rng )\r
 316 {\r
 317     uint64 temp = *rng;\r
 318     temp = (uint64)(unsigned)temp*4164903690U + (temp >> 32);\r
 319     *rng = temp;\r
 320     return (unsigned)temp;\r
 321 }\r
 322 \r
 323 /* Returns random floating-point number between 0 and 1: */\r
 324 CV_INLINE double cvRandReal( CvRNG* rng )\r
 325 {\r
 326     return cvRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */;\r
 327 }\r
 328 \r
 329 /****************************************************************************************\\r
 330 *                                  Image type (IplImage)                                 *\r
 331 \****************************************************************************************/\r
 332 \r
 333 #ifndef HAVE_IPL\r
 334 \r
 335 /*\r
 336  * The following definitions (until #endif)\r
 337  * is an extract from IPL headers.\r
 338  * Copyright (c) 1995 Intel Corporation.\r
 339  */\r
 340 #define IPL_DEPTH_SIGN 0x80000000\r
 341 \r
 342 #define IPL_DEPTH_1U     1\r
 343 #define IPL_DEPTH_8U     8\r
 344 #define IPL_DEPTH_16U   16\r
 345 #define IPL_DEPTH_32F   32\r
 346 \r
 347 #define IPL_DEPTH_8S  (IPL_DEPTH_SIGN| 8)\r
 348 #define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)\r
 349 #define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)\r
 350 \r
 351 #define IPL_DATA_ORDER_PIXEL  0\r
 352 #define IPL_DATA_ORDER_PLANE  1\r
 353 \r
 354 #define IPL_ORIGIN_TL 0\r
 355 #define IPL_ORIGIN_BL 1\r
 356 \r
 357 #define IPL_ALIGN_4BYTES   4\r
 358 #define IPL_ALIGN_8BYTES   8\r
 359 #define IPL_ALIGN_16BYTES 16\r
 360 #define IPL_ALIGN_32BYTES 32\r
 361 \r
 362 #define IPL_ALIGN_DWORD   IPL_ALIGN_4BYTES\r
 363 #define IPL_ALIGN_QWORD   IPL_ALIGN_8BYTES\r
 364 \r
 365 #define IPL_BORDER_CONSTANT   0\r
 366 #define IPL_BORDER_REPLICATE  1\r
 367 #define IPL_BORDER_REFLECT    2\r
 368 #define IPL_BORDER_WRAP       3\r
 369 \r
 370 typedef struct _IplImage\r
 371 {\r
 372     int  nSize;             /* sizeof(IplImage) */\r
 373     int  ID;                /* version (=0)*/\r
 374     int  nChannels;         /* Most of OpenCV functions support 1,2,3 or 4 channels */\r
 375     int  alphaChannel;      /* Ignored by OpenCV */\r
 376     int  depth;             /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,\r
 377                                IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported.  */\r
 378     char colorModel[4];     /* Ignored by OpenCV */\r
 379     char channelSeq[4];     /* ditto */\r
 380     int  dataOrder;         /* 0 - interleaved color channels, 1 - separate color channels.\r
 381                                cvCreateImage can only create interleaved images */\r
 382     int  origin;            /* 0 - top-left origin,\r
 383                                1 - bottom-left origin (Windows bitmaps style).  */\r
 384     int  align;             /* Alignment of image rows (4 or 8).\r
 385                                OpenCV ignores it and uses widthStep instead.    */\r
 386     int  width;             /* Image width in pixels.                           */\r
 387     int  height;            /* Image height in pixels.                          */\r
 388     struct _IplROI *roi;    /* Image ROI. If NULL, the whole image is selected. */\r
 389     struct _IplImage *maskROI;      /* Must be NULL. */\r
 390     void  *imageId;                 /* "           " */\r
 391     struct _IplTileInfo *tileInfo;  /* "           " */\r
 392     int  imageSize;         /* Image data size in bytes\r
 393                                (==image->height*image->widthStep\r
 394                                in case of interleaved data)*/\r
 395     char *imageData;        /* Pointer to aligned image data.         */\r
 396     int  widthStep;         /* Size of aligned image row in bytes.    */\r
 397     int  BorderMode[4];     /* Ignored by OpenCV.                     */\r
 398     int  BorderConst[4];    /* Ditto.                                 */\r
 399     char *imageDataOrigin;  /* Pointer to very origin of image data\r
 400                                (not necessarily aligned) -\r
 401                                needed for correct deallocation */\r
 402 }\r
 403 IplImage;\r
 404 \r
 405 typedef struct _IplTileInfo IplTileInfo;\r
 406 \r
 407 typedef struct _IplROI\r
 408 {\r
 409     int  coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/\r
 410     int  xOffset;\r
 411     int  yOffset;\r
 412     int  width;\r
 413     int  height;\r
 414 }\r
 415 IplROI;\r
 416 \r
 417 typedef struct _IplConvKernel\r
 418 {\r
 419     int  nCols;\r
 420     int  nRows;\r
 421     int  anchorX;\r
 422     int  anchorY;\r
 423     int *values;\r
 424     int  nShiftR;\r
 425 }\r
 426 IplConvKernel;\r
 427 \r
 428 typedef struct _IplConvKernelFP\r
 429 {\r
 430     int  nCols;\r
 431     int  nRows;\r
 432     int  anchorX;\r
 433     int  anchorY;\r
 434     float *values;\r
 435 }\r
 436 IplConvKernelFP;\r
 437 \r
 438 #define IPL_IMAGE_HEADER 1\r
 439 #define IPL_IMAGE_DATA   2\r
 440 #define IPL_IMAGE_ROI    4\r
 441 \r
 442 #endif/*HAVE_IPL*/\r
 443 \r
 444 /* extra border mode */\r
 445 #define IPL_BORDER_REFLECT_101    4\r
 446 \r
 447 #define IPL_IMAGE_MAGIC_VAL  ((int)sizeof(IplImage))\r
 448 #define CV_TYPE_NAME_IMAGE "opencv-image"\r
 449 \r
 450 #define CV_IS_IMAGE_HDR(img) \\r
 451     ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))\r
 452 \r
 453 #define CV_IS_IMAGE(img) \\r
 454     (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)\r
 455 \r
 456 /* for storing double-precision\r
 457    floating point data in IplImage's */\r
 458 #define IPL_DEPTH_64F  64\r
 459 \r
 460 /* get reference to pixel at (col,row),\r
 461    for multi-channel images (col) should be multiplied by number of channels */\r
 462 #define CV_IMAGE_ELEM( image, elemtype, row, col )       \\r
 463     (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])\r
 464 \r
 465 /****************************************************************************************\\r
 466 *                                  Matrix type (CvMat)                                   *\r
 467 \****************************************************************************************/\r
 468 \r
 469 #define CV_CN_MAX     64\r
 470 #define CV_CN_SHIFT   3\r
 471 #define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)\r
 472 \r
 473 #define CV_8U   0\r
 474 #define CV_8S   1\r
 475 #define CV_16U  2\r
 476 #define CV_16S  3\r
 477 #define CV_32S  4\r
 478 #define CV_32F  5\r
 479 #define CV_64F  6\r
 480 #define CV_USRTYPE1 7\r
 481 \r
 482 #define CV_MAKETYPE(depth,cn) ((depth) + (((cn)-1) << CV_CN_SHIFT))\r
 483 #define CV_MAKE_TYPE CV_MAKETYPE\r
 484 \r
 485 #define CV_8UC1 CV_MAKETYPE(CV_8U,1)\r
 486 #define CV_8UC2 CV_MAKETYPE(CV_8U,2)\r
 487 #define CV_8UC3 CV_MAKETYPE(CV_8U,3)\r
 488 #define CV_8UC4 CV_MAKETYPE(CV_8U,4)\r
 489 #define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))\r
 490 \r
 491 #define CV_8SC1 CV_MAKETYPE(CV_8S,1)\r
 492 #define CV_8SC2 CV_MAKETYPE(CV_8S,2)\r
 493 #define CV_8SC3 CV_MAKETYPE(CV_8S,3)\r
 494 #define CV_8SC4 CV_MAKETYPE(CV_8S,4)\r
 495 #define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))\r
 496 \r
 497 #define CV_16UC1 CV_MAKETYPE(CV_16U,1)\r
 498 #define CV_16UC2 CV_MAKETYPE(CV_16U,2)\r
 499 #define CV_16UC3 CV_MAKETYPE(CV_16U,3)\r
 500 #define CV_16UC4 CV_MAKETYPE(CV_16U,4)\r
 501 #define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))\r
 502 \r
 503 #define CV_16SC1 CV_MAKETYPE(CV_16S,1)\r
 504 #define CV_16SC2 CV_MAKETYPE(CV_16S,2)\r
 505 #define CV_16SC3 CV_MAKETYPE(CV_16S,3)\r
 506 #define CV_16SC4 CV_MAKETYPE(CV_16S,4)\r
 507 #define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))\r
 508 \r
 509 #define CV_32SC1 CV_MAKETYPE(CV_32S,1)\r
 510 #define CV_32SC2 CV_MAKETYPE(CV_32S,2)\r
 511 #define CV_32SC3 CV_MAKETYPE(CV_32S,3)\r
 512 #define CV_32SC4 CV_MAKETYPE(CV_32S,4)\r
 513 #define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))\r
 514 \r
 515 #define CV_32FC1 CV_MAKETYPE(CV_32F,1)\r
 516 #define CV_32FC2 CV_MAKETYPE(CV_32F,2)\r
 517 #define CV_32FC3 CV_MAKETYPE(CV_32F,3)\r
 518 #define CV_32FC4 CV_MAKETYPE(CV_32F,4)\r
 519 #define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))\r
 520 \r
 521 #define CV_64FC1 CV_MAKETYPE(CV_64F,1)\r
 522 #define CV_64FC2 CV_MAKETYPE(CV_64F,2)\r
 523 #define CV_64FC3 CV_MAKETYPE(CV_64F,3)\r
 524 #define CV_64FC4 CV_MAKETYPE(CV_64F,4)\r
 525 #define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))\r
 526 \r
 527 #define CV_AUTO_STEP  0x7fffffff\r
 528 #define CV_WHOLE_ARR  cvSlice( 0, 0x3fffffff )\r
 529 \r
 530 #define CV_MAT_CN_MASK          ((CV_CN_MAX - 1) << CV_CN_SHIFT)\r
 531 #define CV_MAT_CN(flags)        ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)\r
 532 #define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)\r
 533 #define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)\r
 534 #define CV_MAT_TYPE_MASK        (CV_DEPTH_MAX*CV_CN_MAX - 1)\r
 535 #define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)\r
 536 #define CV_MAT_CONT_FLAG_SHIFT  14\r
 537 #define CV_MAT_CONT_FLAG        (1 << CV_MAT_CONT_FLAG_SHIFT)\r
 538 #define CV_IS_MAT_CONT(flags)   ((flags) & CV_MAT_CONT_FLAG)\r
 539 #define CV_IS_CONT_MAT          CV_IS_MAT_CONT\r
 540 #define CV_MAT_TEMP_FLAG_SHIFT  15\r
 541 #define CV_MAT_TEMP_FLAG        (1 << CV_MAT_TEMP_FLAG_SHIFT)\r
 542 #define CV_IS_TEMP_MAT(flags)   ((flags) & CV_MAT_TEMP_FLAG)\r
 543 \r
 544 #define CV_MAGIC_MASK       0xFFFF0000\r
 545 #define CV_MAT_MAGIC_VAL    0x42420000\r
 546 #define CV_TYPE_NAME_MAT    "opencv-matrix"\r
 547 \r
 548 typedef struct CvMat\r
 549 {\r
 550     int type;\r
 551     int step;\r
 552 \r
 553     /* for internal use only */\r
 554     int* refcount;\r
 555     int hdr_refcount;\r
 556 \r
 557     union\r
 558     {\r
 559         uchar* ptr;\r
 560         short* s;\r
 561         int* i;\r
 562         float* fl;\r
 563         double* db;\r
 564     } data;\r
 565 \r
 566 #ifdef __cplusplus\r
 567     union\r
 568     {\r
 569         int rows;\r
 570         int height;\r
 571     };\r
 572 \r
 573     union\r
 574     {\r
 575         int cols;\r
 576         int width;\r
 577     };\r
 578 #else\r
 579     int rows;\r
 580     int cols;\r
 581 #endif\r
 582 \r
 583 }\r
 584 CvMat;\r
 585 \r
 586 \r
 587 #define CV_IS_MAT_HDR(mat) \\r
 588     ((mat) != NULL && \\r
 589     (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \\r
 590     ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)\r
 591 \r
 592 #define CV_IS_MAT(mat) \\r
 593     (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL)\r
 594 \r
 595 #define CV_IS_MASK_ARR(mat) \\r
 596     (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)\r
 597 \r
 598 #define CV_ARE_TYPES_EQ(mat1, mat2) \\r
 599     ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)\r
 600 \r
 601 #define CV_ARE_CNS_EQ(mat1, mat2) \\r
 602     ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)\r
 603 \r
 604 #define CV_ARE_DEPTHS_EQ(mat1, mat2) \\r
 605     ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)\r
 606 \r
 607 #define CV_ARE_SIZES_EQ(mat1, mat2) \\r
 608     ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)\r
 609 \r
 610 #define CV_IS_MAT_CONST(mat)  \\r
 611     (((mat)->rows|(mat)->cols) == 1)\r
 612 \r
 613 /* Size of each channel item,\r
 614    0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */\r
 615 #define CV_ELEM_SIZE1(type) \\r
 616     ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)\r
 617 \r
 618 /* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */\r
 619 #define CV_ELEM_SIZE(type) \\r
 620     (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))\r
 621 \r
 622 /* Inline constructor. No data is allocated internally!!!\r
 623  * (Use together with cvCreateData, or use cvCreateMat instead to\r
 624  * get a matrix with allocated data):\r
 625  */\r
 626 CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL))\r
 627 {\r
 628     CvMat m;\r
 629 \r
 630     assert( (unsigned)CV_MAT_DEPTH(type) <= CV_64F );\r
 631     type = CV_MAT_TYPE(type);\r
 632     m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type;\r
 633     m.cols = cols;\r
 634     m.rows = rows;\r
 635     m.step = rows > 1 ? m.cols*CV_ELEM_SIZE(type) : 0;\r
 636     m.data.ptr = (uchar*)data;\r
 637     m.refcount = NULL;\r
 638     m.hdr_refcount = 0;\r
 639 \r
 640     return m;\r
 641 }\r
 642 \r
 643 \r
 644 #define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size )  \\r
 645     (assert( (unsigned)(row) < (unsigned)(mat).rows &&   \\r
 646              (unsigned)(col) < (unsigned)(mat).cols ),   \\r
 647      (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))\r
 648 \r
 649 #define CV_MAT_ELEM_PTR( mat, row, col )                 \\r
 650     CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )\r
 651 \r
 652 #define CV_MAT_ELEM( mat, elemtype, row, col )           \\r
 653     (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))\r
 654 \r
 655 \r
 656 CV_INLINE  double  cvmGet( const CvMat* mat, int row, int col )\r
 657 {\r
 658     int type;\r
 659 \r
 660     type = CV_MAT_TYPE(mat->type);\r
 661     assert( (unsigned)row < (unsigned)mat->rows &&\r
 662             (unsigned)col < (unsigned)mat->cols );\r
 663 \r
 664     if( type == CV_32FC1 )\r
 665         return ((float*)(mat->data.ptr + (size_t)mat->step*row))[col];\r
 666     else\r
 667     {\r
 668         assert( type == CV_64FC1 );\r
 669         return ((double*)(mat->data.ptr + (size_t)mat->step*row))[col];\r
 670     }\r
 671 }\r
 672 \r
 673 \r
 674 CV_INLINE  void  cvmSet( CvMat* mat, int row, int col, double value )\r
 675 {\r
 676     int type;\r
 677     type = CV_MAT_TYPE(mat->type);\r
 678     assert( (unsigned)row < (unsigned)mat->rows &&\r
 679             (unsigned)col < (unsigned)mat->cols );\r
 680 \r
 681     if( type == CV_32FC1 )\r
 682         ((float*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;\r
 683     else\r
 684     {\r
 685         assert( type == CV_64FC1 );\r
 686         ((double*)(mat->data.ptr + (size_t)mat->step*row))[col] = (double)value;\r
 687     }\r
 688 }\r
 689 \r
 690 \r
 691 CV_INLINE int cvCvToIplDepth( int type )\r
 692 {\r
 693     int depth = CV_MAT_DEPTH(type);\r
 694     return CV_ELEM_SIZE1(depth)*8 | (depth == CV_8S || depth == CV_16S ||\r
 695            depth == CV_32S ? IPL_DEPTH_SIGN : 0);\r
 696 }\r
 697 \r
 698 \r
 699 /****************************************************************************************\\r
 700 *                       Multi-dimensional dense array (CvMatND)                          *\r
 701 \****************************************************************************************/\r
 702 \r
 703 #define CV_MATND_MAGIC_VAL    0x42430000\r
 704 #define CV_TYPE_NAME_MATND    "opencv-nd-matrix"\r
 705 \r
 706 #define CV_MAX_DIM            32\r
 707 #define CV_MAX_DIM_HEAP       (1 << 16)\r
 708 \r
 709 typedef struct CvMatND\r
 710 {\r
 711     int type;\r
 712     int dims;\r
 713 \r
 714     int* refcount;\r
 715     int hdr_refcount;\r
 716 \r
 717     union\r
 718     {\r
 719         uchar* ptr;\r
 720         float* fl;\r
 721         double* db;\r
 722         int* i;\r
 723         short* s;\r
 724     } data;\r
 725 \r
 726     struct\r
 727     {\r
 728         int size;\r
 729         int step;\r
 730     }\r
 731     dim[CV_MAX_DIM];\r
 732 }\r
 733 CvMatND;\r
 734 \r
 735 #define CV_IS_MATND_HDR(mat) \\r
 736     ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)\r
 737 \r
 738 #define CV_IS_MATND(mat) \\r
 739     (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)\r
 740 \r
 741 \r
 742 /****************************************************************************************\\r
 743 *                      Multi-dimensional sparse array (CvSparseMat)                      *\r
 744 \****************************************************************************************/\r
 745 \r
 746 #define CV_SPARSE_MAT_MAGIC_VAL    0x42440000\r
 747 #define CV_TYPE_NAME_SPARSE_MAT    "opencv-sparse-matrix"\r
 748 \r
 749 struct CvSet;\r
 750 \r
 751 typedef struct CvSparseMat\r
 752 {\r
 753     int type;\r
 754     int dims;\r
 755     int* refcount;\r
 756     int hdr_refcount;\r
 757 \r
 758     struct CvSet* heap;\r
 759     void** hashtable;\r
 760     int hashsize;\r
 761     int valoffset;\r
 762     int idxoffset;\r
 763     int size[CV_MAX_DIM];\r
 764 }\r
 765 CvSparseMat;\r
 766 \r
 767 #define CV_IS_SPARSE_MAT_HDR(mat) \\r
 768     ((mat) != NULL && \\r
 769     (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)\r
 770 \r
 771 #define CV_IS_SPARSE_MAT(mat) \\r
 772     CV_IS_SPARSE_MAT_HDR(mat)\r
 773 \r
 774 /**************** iteration through a sparse array *****************/\r
 775 \r
 776 typedef struct CvSparseNode\r
 777 {\r
 778     unsigned hashval;\r
 779     struct CvSparseNode* next;\r
 780 }\r
 781 CvSparseNode;\r
 782 \r
 783 typedef struct CvSparseMatIterator\r
 784 {\r
 785     CvSparseMat* mat;\r
 786     CvSparseNode* node;\r
 787     int curidx;\r
 788 }\r
 789 CvSparseMatIterator;\r
 790 \r
 791 #define CV_NODE_VAL(mat,node)   ((void*)((uchar*)(node) + (mat)->valoffset))\r
 792 #define CV_NODE_IDX(mat,node)   ((int*)((uchar*)(node) + (mat)->idxoffset))\r
 793 \r
 794 /****************************************************************************************\\r
 795 *                                         Histogram                                      *\r
 796 \****************************************************************************************/\r
 797 \r
 798 typedef int CvHistType;\r
 799 \r
 800 #define CV_HIST_MAGIC_VAL     0x42450000\r
 801 #define CV_HIST_UNIFORM_FLAG  (1 << 10)\r
 802 \r
 803 /* indicates whether bin ranges are set already or not */\r
 804 #define CV_HIST_RANGES_FLAG   (1 << 11)\r
 805 \r
 806 #define CV_HIST_ARRAY         0\r
 807 #define CV_HIST_SPARSE        1\r
 808 #define CV_HIST_TREE          CV_HIST_SPARSE\r
 809 \r
 810 /* should be used as a parameter only,\r
 811    it turns to CV_HIST_UNIFORM_FLAG of hist->type */\r
 812 #define CV_HIST_UNIFORM       1\r
 813 \r
 814 typedef struct CvHistogram\r
 815 {\r
 816     int     type;\r
 817     CvArr*  bins;\r
 818     float   thresh[CV_MAX_DIM][2];  /* For uniform histograms.                      */\r
 819     float** thresh2;                /* For non-uniform histograms.                  */\r
 820     CvMatND mat;                    /* Embedded matrix header for array histograms. */\r
 821 }\r
 822 CvHistogram;\r
 823 \r
 824 #define CV_IS_HIST( hist ) \\r
 825     ((hist) != NULL  && \\r
 826      (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \\r
 827      (hist)->bins != NULL)\r
 828 \r
 829 #define CV_IS_UNIFORM_HIST( hist ) \\r
 830     (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)\r
 831 \r
 832 #define CV_IS_SPARSE_HIST( hist ) \\r
 833     CV_IS_SPARSE_MAT((hist)->bins)\r
 834 \r
 835 #define CV_HIST_HAS_RANGES( hist ) \\r
 836     (((hist)->type & CV_HIST_RANGES_FLAG) != 0)\r
 837 \r
 838 /****************************************************************************************\\r
 839 *                      Other supplementary data type definitions                         *\r
 840 \****************************************************************************************/\r
 841 \r
 842 /*************************************** CvRect *****************************************/\r
 843 \r
 844 typedef struct CvRect\r
 845 {\r
 846     int x;\r
 847     int y;\r
 848     int width;\r
 849     int height;\r
 850 }\r
 851 CvRect;\r
 852 \r
 853 CV_INLINE  CvRect  cvRect( int x, int y, int width, int height )\r
 854 {\r
 855     CvRect r;\r
 856 \r
 857     r.x = x;\r
 858     r.y = y;\r
 859     r.width = width;\r
 860     r.height = height;\r
 861 \r
 862     return r;\r
 863 }\r
 864 \r
 865 \r
 866 CV_INLINE  IplROI  cvRectToROI( CvRect rect, int coi )\r
 867 {\r
 868     IplROI roi;\r
 869     roi.xOffset = rect.x;\r
 870     roi.yOffset = rect.y;\r
 871     roi.width = rect.width;\r
 872     roi.height = rect.height;\r
 873     roi.coi = coi;\r
 874 \r
 875     return roi;\r
 876 }\r
 877 \r
 878 \r
 879 CV_INLINE  CvRect  cvROIToRect( IplROI roi )\r
 880 {\r
 881     return cvRect( roi.xOffset, roi.yOffset, roi.width, roi.height );\r
 882 }\r
 883 \r
 884 /*********************************** CvTermCriteria *************************************/\r
 885 \r
 886 #define CV_TERMCRIT_ITER    1\r
 887 #define CV_TERMCRIT_NUMBER  CV_TERMCRIT_ITER\r
 888 #define CV_TERMCRIT_EPS     2\r
 889 \r
 890 typedef struct CvTermCriteria\r
 891 {\r
 892     int    type;  /* may be combination of\r
 893                      CV_TERMCRIT_ITER\r
 894                      CV_TERMCRIT_EPS */\r
 895     int    max_iter;\r
 896     double epsilon;\r
 897 }\r
 898 CvTermCriteria;\r
 899 \r
 900 CV_INLINE  CvTermCriteria  cvTermCriteria( int type, int max_iter, double epsilon )\r
 901 {\r
 902     CvTermCriteria t;\r
 903 \r
 904     t.type = type;\r
 905     t.max_iter = max_iter;\r
 906     t.epsilon = (float)epsilon;\r
 907 \r
 908     return t;\r
 909 }\r
 910 \r
 911 \r
 912 /******************************* CvPoint and variants ***********************************/\r
 913 \r
 914 typedef struct CvPoint\r
 915 {\r
 916     int x;\r
 917     int y;\r
 918 }\r
 919 CvPoint;\r
 920 \r
 921 \r
 922 CV_INLINE  CvPoint  cvPoint( int x, int y )\r
 923 {\r
 924     CvPoint p;\r
 925 \r
 926     p.x = x;\r
 927     p.y = y;\r
 928 \r
 929     return p;\r
 930 }\r
 931 \r
 932 \r
 933 typedef struct CvPoint2D32f\r
 934 {\r
 935     float x;\r
 936     float y;\r
 937 }\r
 938 CvPoint2D32f;\r
 939 \r
 940 \r
 941 CV_INLINE  CvPoint2D32f  cvPoint2D32f( double x, double y )\r
 942 {\r
 943     CvPoint2D32f p;\r
 944 \r
 945     p.x = (float)x;\r
 946     p.y = (float)y;\r
 947 \r
 948     return p;\r
 949 }\r
 950 \r
 951 \r
 952 CV_INLINE  CvPoint2D32f  cvPointTo32f( CvPoint point )\r
 953 {\r
 954     return cvPoint2D32f( (float)point.x, (float)point.y );\r
 955 }\r
 956 \r
 957 \r
 958 CV_INLINE  CvPoint  cvPointFrom32f( CvPoint2D32f point )\r
 959 {\r
 960     CvPoint ipt;\r
 961     ipt.x = cvRound(point.x);\r
 962     ipt.y = cvRound(point.y);\r
 963 \r
 964     return ipt;\r
 965 }\r
 966 \r
 967 \r
 968 typedef struct CvPoint3D32f\r
 969 {\r
 970     float x;\r
 971     float y;\r
 972     float z;\r
 973 }\r
 974 CvPoint3D32f;\r
 975 \r
 976 \r
 977 CV_INLINE  CvPoint3D32f  cvPoint3D32f( double x, double y, double z )\r
 978 {\r
 979     CvPoint3D32f p;\r
 980 \r
 981     p.x = (float)x;\r
 982     p.y = (float)y;\r
 983     p.z = (float)z;\r
 984 \r
 985     return p;\r
 986 }\r
 987 \r
 988 \r
 989 typedef struct CvPoint2D64f\r
 990 {\r
 991     double x;\r
 992     double y;\r
 993 }\r
 994 CvPoint2D64f;\r
 995 \r
 996 \r
 997 CV_INLINE  CvPoint2D64f  cvPoint2D64f( double x, double y )\r
 998 {\r
 999     CvPoint2D64f p;\r
1000 \r
1001     p.x = x;\r
1002     p.y = y;\r
1003 \r
1004     return p;\r
1005 }\r
1006 \r
1007 \r
1008 typedef struct CvPoint3D64f\r
1009 {\r
1010     double x;\r
1011     double y;\r
1012     double z;\r
1013 }\r
1014 CvPoint3D64f;\r
1015 \r
1016 \r
1017 CV_INLINE  CvPoint3D64f  cvPoint3D64f( double x, double y, double z )\r
1018 {\r
1019     CvPoint3D64f p;\r
1020 \r
1021     p.x = x;\r
1022     p.y = y;\r
1023     p.z = z;\r
1024 \r
1025     return p;\r
1026 }\r
1027 \r
1028 \r
1029 /******************************** CvSize's & CvBox **************************************/\r
1030 \r
1031 typedef struct\r
1032 {\r
1033     int width;\r
1034     int height;\r
1035 }\r
1036 CvSize;\r
1037 \r
1038 CV_INLINE  CvSize  cvSize( int width, int height )\r
1039 {\r
1040     CvSize s;\r
1041 \r
1042     s.width = width;\r
1043     s.height = height;\r
1044 \r
1045     return s;\r
1046 }\r
1047 \r
1048 typedef struct CvSize2D32f\r
1049 {\r
1050     float width;\r
1051     float height;\r
1052 }\r
1053 CvSize2D32f;\r
1054 \r
1055 \r
1056 CV_INLINE  CvSize2D32f  cvSize2D32f( double width, double height )\r
1057 {\r
1058     CvSize2D32f s;\r
1059 \r
1060     s.width = (float)width;\r
1061     s.height = (float)height;\r
1062 \r
1063     return s;\r
1064 }\r
1065 \r
1066 typedef struct CvBox2D\r
1067 {\r
1068     CvPoint2D32f center;  /* Center of the box.                          */\r
1069     CvSize2D32f  size;    /* Box width and length.                       */\r
1070     float angle;          /* Angle between the horizontal axis           */\r
1071                           /* and the first side (i.e. length) in degrees */\r
1072 }\r
1073 CvBox2D;\r
1074 \r
1075 \r
1076 /* Line iterator state: */\r
1077 typedef struct CvLineIterator\r
1078 {\r
1079     /* Pointer to the current point: */\r
1080     uchar* ptr;\r
1081 \r
1082     /* Bresenham algorithm state: */\r
1083     int  err;\r
1084     int  plus_delta;\r
1085     int  minus_delta;\r
1086     int  plus_step;\r
1087     int  minus_step;\r
1088 }\r
1089 CvLineIterator;\r
1090 \r
1091 \r
1092 \r
1093 /************************************* CvSlice ******************************************/\r
1094 \r
1095 typedef struct CvSlice\r
1096 {\r
1097     int  start_index, end_index;\r
1098 }\r
1099 CvSlice;\r
1100 \r
1101 CV_INLINE  CvSlice  cvSlice( int start, int end )\r
1102 {\r
1103     CvSlice slice;\r
1104     slice.start_index = start;\r
1105     slice.end_index = end;\r
1106 \r
1107     return slice;\r
1108 }\r
1109 \r
1110 #define CV_WHOLE_SEQ_END_INDEX 0x3fffffff\r
1111 #define CV_WHOLE_SEQ  cvSlice(0, CV_WHOLE_SEQ_END_INDEX)\r
1112 \r
1113 \r
1114 /************************************* CvScalar *****************************************/\r
1115 \r
1116 typedef struct CvScalar\r
1117 {\r
1118     double val[4];\r
1119 }\r
1120 CvScalar;\r
1121 \r
1122 CV_INLINE  CvScalar  cvScalar( double val0, double val1 CV_DEFAULT(0),\r
1123                                double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))\r
1124 {\r
1125     CvScalar scalar;\r
1126     scalar.val[0] = val0; scalar.val[1] = val1;\r
1127     scalar.val[2] = val2; scalar.val[3] = val3;\r
1128     return scalar;\r
1129 }\r
1130 \r
1131 \r
1132 CV_INLINE  CvScalar  cvRealScalar( double val0 )\r
1133 {\r
1134     CvScalar scalar;\r
1135     scalar.val[0] = val0;\r
1136     scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;\r
1137     return scalar;\r
1138 }\r
1139 \r
1140 CV_INLINE  CvScalar  cvScalarAll( double val0123 )\r
1141 {\r
1142     CvScalar scalar;\r
1143     scalar.val[0] = val0123;\r
1144     scalar.val[1] = val0123;\r
1145     scalar.val[2] = val0123;\r
1146     scalar.val[3] = val0123;\r
1147     return scalar;\r
1148 }\r
1149 \r
1150 /****************************************************************************************\\r
1151 *                                   Dynamic Data structures                              *\r
1152 \****************************************************************************************/\r
1153 \r
1154 /******************************** Memory storage ****************************************/\r
1155 \r
1156 typedef struct CvMemBlock\r
1157 {\r
1158     struct CvMemBlock*  prev;\r
1159     struct CvMemBlock*  next;\r
1160 }\r
1161 CvMemBlock;\r
1162 \r
1163 #define CV_STORAGE_MAGIC_VAL    0x42890000\r
1164 \r
1165 typedef struct CvMemStorage\r
1166 {\r
1167     int signature;\r
1168     CvMemBlock* bottom;           /* First allocated block.                   */\r
1169     CvMemBlock* top;              /* Current memory block - top of the stack. */\r
1170     struct  CvMemStorage* parent; /* We get new blocks from parent as needed. */\r
1171     int block_size;               /* Block size.                              */\r
1172     int free_space;               /* Remaining free space in current block.   */\r
1173 }\r
1174 CvMemStorage;\r
1175 \r
1176 #define CV_IS_STORAGE(storage)  \\r
1177     ((storage) != NULL &&       \\r
1178     (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)\r
1179 \r
1180 \r
1181 typedef struct CvMemStoragePos\r
1182 {\r
1183     CvMemBlock* top;\r
1184     int free_space;\r
1185 }\r
1186 CvMemStoragePos;\r
1187 \r
1188 \r
1189 /*********************************** Sequence *******************************************/\r
1190 \r
1191 typedef struct CvSeqBlock\r
1192 {\r
1193     struct CvSeqBlock*  prev; /* Previous sequence block.                   */\r
1194     struct CvSeqBlock*  next; /* Next sequence block.                       */\r
1195   int    start_index;         /* Index of the first element in the block +  */\r
1196                               /* sequence->first->start_index.              */\r
1197     int    count;             /* Number of elements in the block.           */\r
1198     schar* data;              /* Pointer to the first element of the block. */\r
1199 }\r
1200 CvSeqBlock;\r
1201 \r
1202 \r
1203 #define CV_TREE_NODE_FIELDS(node_type)                               \\r
1204     int       flags;             /* Miscellaneous flags.     */      \\r
1205     int       header_size;       /* Size of sequence header. */      \\r
1206     struct    node_type* h_prev; /* Previous sequence.       */      \\r
1207     struct    node_type* h_next; /* Next sequence.           */      \\r
1208     struct    node_type* v_prev; /* 2nd previous sequence.   */      \\r
1209     struct    node_type* v_next  /* 2nd next sequence.       */\r
1210 \r
1211 /*\r
1212    Read/Write sequence.\r
1213    Elements can be dynamically inserted to or deleted from the sequence.\r
1214 */\r
1215 #define CV_SEQUENCE_FIELDS()                                              \\r
1216     CV_TREE_NODE_FIELDS(CvSeq);                                           \\r
1217     int       total;          /* Total number of elements.            */  \\r
1218     int       elem_size;      /* Size of sequence element in bytes.   */  \\r
1219     schar*    block_max;      /* Maximal bound of the last block.     */  \\r
1220     schar*    ptr;            /* Current write pointer.               */  \\r
1221     int       delta_elems;    /* Grow seq this many at a time.        */  \\r
1222     CvMemStorage* storage;    /* Where the seq is stored.             */  \\r
1223     CvSeqBlock* free_blocks;  /* Free blocks list.                    */  \\r
1224     CvSeqBlock* first;        /* Pointer to the first sequence block. */\r
1225 \r
1226 typedef struct CvSeq\r
1227 {\r
1228     CV_SEQUENCE_FIELDS()\r
1229 }\r
1230 CvSeq;\r
1231 \r
1232 #define CV_TYPE_NAME_SEQ             "opencv-sequence"\r
1233 #define CV_TYPE_NAME_SEQ_TREE        "opencv-sequence-tree"\r
1234 \r
1235 /*************************************** Set ********************************************/\r
1236 /*\r
1237   Set.\r
1238   Order is not preserved. There can be gaps between sequence elements.\r
1239   After the element has been inserted it stays in the same place all the time.\r
1240   The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.\r
1241 */\r
1242 #define CV_SET_ELEM_FIELDS(elem_type)   \\r
1243     int  flags;                         \\r
1244     struct elem_type* next_free;\r
1245 \r
1246 typedef struct CvSetElem\r
1247 {\r
1248     CV_SET_ELEM_FIELDS(CvSetElem)\r
1249 }\r
1250 CvSetElem;\r
1251 \r
1252 #define CV_SET_FIELDS()      \\r
1253     CV_SEQUENCE_FIELDS()     \\r
1254     CvSetElem* free_elems;   \\r
1255     int active_count;\r
1256 \r
1257 typedef struct CvSet\r
1258 {\r
1259     CV_SET_FIELDS()\r
1260 }\r
1261 CvSet;\r
1262 \r
1263 \r
1264 #define CV_SET_ELEM_IDX_MASK   ((1 << 26) - 1)\r
1265 #define CV_SET_ELEM_FREE_FLAG  (1 << (sizeof(int)*8-1))\r
1266 \r
1267 /* Checks whether the element pointed by ptr belongs to a set or not */\r
1268 #define CV_IS_SET_ELEM( ptr )  (((CvSetElem*)(ptr))->flags >= 0)\r
1269 \r
1270 /************************************* Graph ********************************************/\r
1271 \r
1272 /*\r
1273   We represent a graph as a set of vertices.\r
1274   Vertices contain their adjacency lists (more exactly, pointers to first incoming or\r
1275   outcoming edge (or 0 if isolated vertex)). Edges are stored in another set.\r
1276   There is a singly-linked list of incoming/outcoming edges for each vertex.\r
1277 \r
1278   Each edge consists of\r
1279 \r
1280      o   Two pointers to the starting and ending vertices\r
1281          (vtx[0] and vtx[1] respectively).\r
1282 \r
1283          A graph may be oriented or not. In the latter case, edges between\r
1284          vertex i to vertex j are not distinguished during search operations.\r
1285 \r
1286      o   Two pointers to next edges for the starting and ending vertices, where\r
1287          next[0] points to the next edge in the vtx[0] adjacency list and\r
1288          next[1] points to the next edge in the vtx[1] adjacency list.\r
1289 */\r
1290 #define CV_GRAPH_EDGE_FIELDS()      \\r
1291     int flags;                      \\r
1292     float weight;                   \\r
1293     struct CvGraphEdge* next[2];    \\r
1294     struct CvGraphVtx* vtx[2];\r
1295 \r
1296 \r
1297 #define CV_GRAPH_VERTEX_FIELDS()    \\r
1298     int flags;                      \\r
1299     struct CvGraphEdge* first;\r
1300 \r
1301 \r
1302 typedef struct CvGraphEdge\r
1303 {\r
1304     CV_GRAPH_EDGE_FIELDS()\r
1305 }\r
1306 CvGraphEdge;\r
1307 \r
1308 typedef struct CvGraphVtx\r
1309 {\r
1310     CV_GRAPH_VERTEX_FIELDS()\r
1311 }\r
1312 CvGraphVtx;\r
1313 \r
1314 typedef struct CvGraphVtx2D\r
1315 {\r
1316     CV_GRAPH_VERTEX_FIELDS()\r
1317     CvPoint2D32f* ptr;\r
1318 }\r
1319 CvGraphVtx2D;\r
1320 \r
1321 /*\r
1322    Graph is "derived" from the set (this is set a of vertices)\r
1323    and includes another set (edges)\r
1324 */\r
1325 #define  CV_GRAPH_FIELDS()   \\r
1326     CV_SET_FIELDS()          \\r
1327     CvSet* edges;\r
1328 \r
1329 typedef struct CvGraph\r
1330 {\r
1331     CV_GRAPH_FIELDS()\r
1332 }\r
1333 CvGraph;\r
1334 \r
1335 #define CV_TYPE_NAME_GRAPH "opencv-graph"\r
1336 \r
1337 /*********************************** Chain/Countour *************************************/\r
1338 \r
1339 typedef struct CvChain\r
1340 {\r
1341     CV_SEQUENCE_FIELDS()\r
1342     CvPoint  origin;\r
1343 }\r
1344 CvChain;\r
1345 \r
1346 #define CV_CONTOUR_FIELDS()  \\r
1347     CV_SEQUENCE_FIELDS()     \\r
1348     CvRect rect;             \\r
1349     int color;               \\r
1350     int reserved[3];\r
1351 \r
1352 typedef struct CvContour\r
1353 {\r
1354     CV_CONTOUR_FIELDS()\r
1355 }\r
1356 CvContour;\r
1357 \r
1358 typedef CvContour CvPoint2DSeq;\r
1359 \r
1360 /****************************************************************************************\\r
1361 *                                    Sequence types                                      *\r
1362 \****************************************************************************************/\r
1363 \r
1364 #define CV_SEQ_MAGIC_VAL             0x42990000\r
1365 \r
1366 #define CV_IS_SEQ(seq) \\r
1367     ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)\r
1368 \r
1369 #define CV_SET_MAGIC_VAL             0x42980000\r
1370 #define CV_IS_SET(set) \\r
1371     ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)\r
1372 \r
1373 #define CV_SEQ_ELTYPE_BITS           9\r
1374 #define CV_SEQ_ELTYPE_MASK           ((1 << CV_SEQ_ELTYPE_BITS) - 1)\r
1375 \r
1376 #define CV_SEQ_ELTYPE_POINT          CV_32SC2  /* (x,y) */\r
1377 #define CV_SEQ_ELTYPE_CODE           CV_8UC1   /* freeman code: 0..7 */\r
1378 #define CV_SEQ_ELTYPE_GENERIC        0\r
1379 #define CV_SEQ_ELTYPE_PTR            CV_USRTYPE1\r
1380 #define CV_SEQ_ELTYPE_PPOINT         CV_SEQ_ELTYPE_PTR  /* &(x,y) */\r
1381 #define CV_SEQ_ELTYPE_INDEX          CV_32SC1  /* #(x,y) */\r
1382 #define CV_SEQ_ELTYPE_GRAPH_EDGE     0  /* &next_o, &next_d, &vtx_o, &vtx_d */\r
1383 #define CV_SEQ_ELTYPE_GRAPH_VERTEX   0  /* first_edge, &(x,y) */\r
1384 #define CV_SEQ_ELTYPE_TRIAN_ATR      0  /* vertex of the binary tree   */\r
1385 #define CV_SEQ_ELTYPE_CONNECTED_COMP 0  /* connected component  */\r
1386 #define CV_SEQ_ELTYPE_POINT3D        CV_32FC3  /* (x,y,z)  */\r
1387 \r
1388 #define CV_SEQ_KIND_BITS        3\r
1389 #define CV_SEQ_KIND_MASK        (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)\r
1390 \r
1391 /* types of sequences */\r
1392 #define CV_SEQ_KIND_GENERIC     (0 << CV_SEQ_ELTYPE_BITS)\r
1393 #define CV_SEQ_KIND_CURVE       (1 << CV_SEQ_ELTYPE_BITS)\r
1394 #define CV_SEQ_KIND_BIN_TREE    (2 << CV_SEQ_ELTYPE_BITS)\r
1395 \r
1396 /* types of sparse sequences (sets) */\r
1397 #define CV_SEQ_KIND_GRAPH       (3 << CV_SEQ_ELTYPE_BITS)\r
1398 #define CV_SEQ_KIND_SUBDIV2D    (4 << CV_SEQ_ELTYPE_BITS)\r
1399 \r
1400 #define CV_SEQ_FLAG_SHIFT       (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)\r
1401 \r
1402 /* flags for curves */\r
1403 #define CV_SEQ_FLAG_CLOSED     (1 << CV_SEQ_FLAG_SHIFT)\r
1404 #define CV_SEQ_FLAG_SIMPLE     (2 << CV_SEQ_FLAG_SHIFT)\r
1405 #define CV_SEQ_FLAG_CONVEX     (4 << CV_SEQ_FLAG_SHIFT)\r
1406 #define CV_SEQ_FLAG_HOLE       (8 << CV_SEQ_FLAG_SHIFT)\r
1407 \r
1408 /* flags for graphs */\r
1409 #define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)\r
1410 \r
1411 #define CV_GRAPH               CV_SEQ_KIND_GRAPH\r
1412 #define CV_ORIENTED_GRAPH      (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)\r
1413 \r
1414 /* point sets */\r
1415 #define CV_SEQ_POINT_SET       (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)\r
1416 #define CV_SEQ_POINT3D_SET     (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)\r
1417 #define CV_SEQ_POLYLINE        (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_POINT)\r
1418 #define CV_SEQ_POLYGON         (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )\r
1419 #define CV_SEQ_CONTOUR         CV_SEQ_POLYGON\r
1420 #define CV_SEQ_SIMPLE_POLYGON  (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON  )\r
1421 \r
1422 /* chain-coded curves */\r
1423 #define CV_SEQ_CHAIN           (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_CODE)\r
1424 #define CV_SEQ_CHAIN_CONTOUR   (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)\r
1425 \r
1426 /* binary tree for the contour */\r
1427 #define CV_SEQ_POLYGON_TREE    (CV_SEQ_KIND_BIN_TREE  | CV_SEQ_ELTYPE_TRIAN_ATR)\r
1428 \r
1429 /* sequence of the connected components */\r
1430 #define CV_SEQ_CONNECTED_COMP  (CV_SEQ_KIND_GENERIC  | CV_SEQ_ELTYPE_CONNECTED_COMP)\r
1431 \r
1432 /* sequence of the integer numbers */\r
1433 #define CV_SEQ_INDEX           (CV_SEQ_KIND_GENERIC  | CV_SEQ_ELTYPE_INDEX)\r
1434 \r
1435 #define CV_SEQ_ELTYPE( seq )   ((seq)->flags & CV_SEQ_ELTYPE_MASK)\r
1436 #define CV_SEQ_KIND( seq )     ((seq)->flags & CV_SEQ_KIND_MASK )\r
1437 \r
1438 /* flag checking */\r
1439 #define CV_IS_SEQ_INDEX( seq )      ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \\r
1440                                      (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))\r
1441 \r
1442 #define CV_IS_SEQ_CURVE( seq )      (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)\r
1443 #define CV_IS_SEQ_CLOSED( seq )     (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)\r
1444 #define CV_IS_SEQ_CONVEX( seq )     (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0)\r
1445 #define CV_IS_SEQ_HOLE( seq )       (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)\r
1446 #define CV_IS_SEQ_SIMPLE( seq )     ((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \\r
1447                                     CV_IS_SEQ_CONVEX(seq))\r
1448 \r
1449 /* type checking macros */\r
1450 #define CV_IS_SEQ_POINT_SET( seq ) \\r
1451     ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))\r
1452 \r
1453 #define CV_IS_SEQ_POINT_SUBSET( seq ) \\r
1454     (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)\r
1455 \r
1456 #define CV_IS_SEQ_POLYLINE( seq )   \\r
1457     (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))\r
1458 \r
1459 #define CV_IS_SEQ_POLYGON( seq )   \\r
1460     (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))\r
1461 \r
1462 #define CV_IS_SEQ_CHAIN( seq )   \\r
1463     (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)\r
1464 \r
1465 #define CV_IS_SEQ_CONTOUR( seq )   \\r
1466     (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))\r
1467 \r
1468 #define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \\r
1469     (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))\r
1470 \r
1471 #define CV_IS_SEQ_POLYGON_TREE( seq ) \\r
1472     (CV_SEQ_ELTYPE (seq) ==  CV_SEQ_ELTYPE_TRIAN_ATR &&    \\r
1473     CV_SEQ_KIND( seq ) ==  CV_SEQ_KIND_BIN_TREE )\r
1474 \r
1475 #define CV_IS_GRAPH( seq )    \\r
1476     (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)\r
1477 \r
1478 #define CV_IS_GRAPH_ORIENTED( seq )   \\r
1479     (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)\r
1480 \r
1481 #define CV_IS_SUBDIV2D( seq )  \\r
1482     (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)\r
1483 \r
1484 /****************************************************************************************/\r
1485 /*                            Sequence writer & reader                                  */\r
1486 /****************************************************************************************/\r
1487 \r
1488 #define CV_SEQ_WRITER_FIELDS()                                     \\r
1489     int          header_size;                                      \\r
1490     CvSeq*       seq;        /* the sequence written */            \\r
1491     CvSeqBlock*  block;      /* current block */                   \\r
1492     schar*       ptr;        /* pointer to free space */           \\r
1493     schar*       block_min;  /* pointer to the beginning of block*/\\r
1494     schar*       block_max;  /* pointer to the end of block */\r
1495 \r
1496 typedef struct CvSeqWriter\r
1497 {\r
1498     CV_SEQ_WRITER_FIELDS()\r
1499 }\r
1500 CvSeqWriter;\r
1501 \r
1502 \r
1503 #define CV_SEQ_READER_FIELDS()                                      \\r
1504     int          header_size;                                       \\r
1505     CvSeq*       seq;        /* sequence, beign read */             \\r
1506     CvSeqBlock*  block;      /* current block */                    \\r
1507     schar*       ptr;        /* pointer to element be read next */  \\r
1508     schar*       block_min;  /* pointer to the beginning of block */\\r
1509     schar*       block_max;  /* pointer to the end of block */      \\r
1510     int          delta_index;/* = seq->first->start_index   */      \\r
1511     schar*       prev_elem;  /* pointer to previous element */\r
1512 \r
1513 \r
1514 typedef struct CvSeqReader\r
1515 {\r
1516     CV_SEQ_READER_FIELDS()\r
1517 }\r
1518 CvSeqReader;\r
1519 \r
1520 /****************************************************************************************/\r
1521 /*                                Operations on sequences                               */\r
1522 /****************************************************************************************/\r
1523 \r
1524 #define  CV_SEQ_ELEM( seq, elem_type, index )                    \\r
1525 /* assert gives some guarantee that <seq> parameter is valid */  \\r
1526 (   assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) &&      \\r
1527     (seq)->elem_size == sizeof(elem_type)),                      \\r
1528     (elem_type*)((seq)->first && (unsigned)index <               \\r
1529     (unsigned)((seq)->first->count) ?                            \\r
1530     (seq)->first->data + (index) * sizeof(elem_type) :           \\r
1531     cvGetSeqElem( (CvSeq*)(seq), (index) )))\r
1532 #define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) )\r
1533 \r
1534 /* Add element to sequence: */\r
1535 #define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer )     \\r
1536 {                                                     \\r
1537     if( (writer).ptr >= (writer).block_max )          \\r
1538     {                                                 \\r
1539         cvCreateSeqBlock( &writer);                   \\r
1540     }                                                 \\r
1541     memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\\r
1542     (writer).ptr += (writer).seq->elem_size;          \\r
1543 }\r
1544 \r
1545 #define CV_WRITE_SEQ_ELEM( elem, writer )             \\r
1546 {                                                     \\r
1547     assert( (writer).seq->elem_size == sizeof(elem)); \\r
1548     if( (writer).ptr >= (writer).block_max )          \\r
1549     {                                                 \\r
1550         cvCreateSeqBlock( &writer);                   \\r
1551     }                                                 \\r
1552     assert( (writer).ptr <= (writer).block_max - sizeof(elem));\\r
1553     memcpy((writer).ptr, &(elem), sizeof(elem));      \\r
1554     (writer).ptr += sizeof(elem);                     \\r
1555 }\r
1556 \r
1557 \r
1558 /* Move reader position forward: */\r
1559 #define CV_NEXT_SEQ_ELEM( elem_size, reader )                 \\r
1560 {                                                             \\r
1561     if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \\r
1562     {                                                         \\r
1563         cvChangeSeqBlock( &(reader), 1 );                     \\r
1564     }                                                         \\r
1565 }\r
1566 \r
1567 \r
1568 /* Move reader position backward: */\r
1569 #define CV_PREV_SEQ_ELEM( elem_size, reader )                \\r
1570 {                                                            \\r
1571     if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \\r
1572     {                                                        \\r
1573         cvChangeSeqBlock( &(reader), -1 );                   \\r
1574     }                                                        \\r
1575 }\r
1576 \r
1577 /* Read element and move read position forward: */\r
1578 #define CV_READ_SEQ_ELEM( elem, reader )                       \\r
1579 {                                                              \\r
1580     assert( (reader).seq->elem_size == sizeof(elem));          \\r
1581     memcpy( &(elem), (reader).ptr, sizeof((elem)));            \\r
1582     CV_NEXT_SEQ_ELEM( sizeof(elem), reader )                   \\r
1583 }\r
1584 \r
1585 /* Read element and move read position backward: */\r
1586 #define CV_REV_READ_SEQ_ELEM( elem, reader )                     \\r
1587 {                                                                \\r
1588     assert( (reader).seq->elem_size == sizeof(elem));            \\r
1589     memcpy(&(elem), (reader).ptr, sizeof((elem)));               \\r
1590     CV_PREV_SEQ_ELEM( sizeof(elem), reader )                     \\r
1591 }\r
1592 \r
1593 \r
1594 #define CV_READ_CHAIN_POINT( _pt, reader )                              \\r
1595 {                                                                       \\r
1596     (_pt) = (reader).pt;                                                \\r
1597     if( (reader).ptr )                                                  \\r
1598     {                                                                   \\r
1599         CV_READ_SEQ_ELEM( (reader).code, (reader));                     \\r
1600         assert( ((reader).code & ~7) == 0 );                            \\r
1601         (reader).pt.x += (reader).deltas[(int)(reader).code][0];        \\r
1602         (reader).pt.y += (reader).deltas[(int)(reader).code][1];        \\r
1603     }                                                                   \\r
1604 }\r
1605 \r
1606 #define CV_CURRENT_POINT( reader )  (*((CvPoint*)((reader).ptr)))\r
1607 #define CV_PREV_POINT( reader )     (*((CvPoint*)((reader).prev_elem)))\r
1608 \r
1609 #define CV_READ_EDGE( pt1, pt2, reader )               \\r
1610 {                                                      \\r
1611     assert( sizeof(pt1) == sizeof(CvPoint) &&          \\r
1612             sizeof(pt2) == sizeof(CvPoint) &&          \\r
1613             reader.seq->elem_size == sizeof(CvPoint)); \\r
1614     (pt1) = CV_PREV_POINT( reader );                   \\r
1615     (pt2) = CV_CURRENT_POINT( reader );                \\r
1616     (reader).prev_elem = (reader).ptr;                 \\r
1617     CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader));      \\r
1618 }\r
1619 \r
1620 /************ Graph macros ************/\r
1621 \r
1622 /* Return next graph edge for given vertex: */\r
1623 #define  CV_NEXT_GRAPH_EDGE( edge, vertex )                              \\r
1624      (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)),  \\r
1625       (edge)->next[(edge)->vtx[1] == (vertex)])\r
1626 \r
1627 \r
1628 \r
1629 /****************************************************************************************\\r
1630 *             Data structures for persistence (a.k.a serialization) functionality        *\r
1631 \****************************************************************************************/\r
1632 \r
1633 /* "black box" file storage */\r
1634 typedef struct CvFileStorage CvFileStorage;\r
1635 \r
1636 /* Storage flags: */\r
1637 #define CV_STORAGE_READ          0\r
1638 #define CV_STORAGE_WRITE         1\r
1639 #define CV_STORAGE_WRITE_TEXT    CV_STORAGE_WRITE\r
1640 #define CV_STORAGE_WRITE_BINARY  CV_STORAGE_WRITE\r
1641 #define CV_STORAGE_APPEND        2\r
1642 \r
1643 /* List of attributes: */\r
1644 typedef struct CvAttrList\r
1645 {\r
1646     const char** attr;         /* NULL-terminated array of (attribute_name,attribute_value) pairs. */\r
1647     struct CvAttrList* next;   /* Pointer to next chunk of the attributes list.                    */\r
1648 }\r
1649 CvAttrList;\r
1650 \r
1651 CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),\r
1652                                  CvAttrList* next CV_DEFAULT(NULL) )\r
1653 {\r
1654     CvAttrList l;\r
1655     l.attr = attr;\r
1656     l.next = next;\r
1657 \r
1658     return l;\r
1659 }\r
1660 \r
1661 struct CvTypeInfo;\r
1662 \r
1663 #define CV_NODE_NONE        0\r
1664 #define CV_NODE_INT         1\r
1665 #define CV_NODE_INTEGER     CV_NODE_INT\r
1666 #define CV_NODE_REAL        2\r
1667 #define CV_NODE_FLOAT       CV_NODE_REAL\r
1668 #define CV_NODE_STR         3\r
1669 #define CV_NODE_STRING      CV_NODE_STR\r
1670 #define CV_NODE_REF         4 /* not used */\r
1671 #define CV_NODE_SEQ         5\r
1672 #define CV_NODE_MAP         6\r
1673 #define CV_NODE_TYPE_MASK   7\r
1674 \r
1675 #define CV_NODE_TYPE(flags)  ((flags) & CV_NODE_TYPE_MASK)\r
1676 \r
1677 /* file node flags */\r
1678 #define CV_NODE_FLOW        8 /* Used only for writing structures in YAML format. */\r
1679 #define CV_NODE_USER        16\r
1680 #define CV_NODE_EMPTY       32\r
1681 #define CV_NODE_NAMED       64\r
1682 \r
1683 #define CV_NODE_IS_INT(flags)        (CV_NODE_TYPE(flags) == CV_NODE_INT)\r
1684 #define CV_NODE_IS_REAL(flags)       (CV_NODE_TYPE(flags) == CV_NODE_REAL)\r
1685 #define CV_NODE_IS_STRING(flags)     (CV_NODE_TYPE(flags) == CV_NODE_STRING)\r
1686 #define CV_NODE_IS_SEQ(flags)        (CV_NODE_TYPE(flags) == CV_NODE_SEQ)\r
1687 #define CV_NODE_IS_MAP(flags)        (CV_NODE_TYPE(flags) == CV_NODE_MAP)\r
1688 #define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)\r
1689 #define CV_NODE_IS_FLOW(flags)       (((flags) & CV_NODE_FLOW) != 0)\r
1690 #define CV_NODE_IS_EMPTY(flags)      (((flags) & CV_NODE_EMPTY) != 0)\r
1691 #define CV_NODE_IS_USER(flags)       (((flags) & CV_NODE_USER) != 0)\r
1692 #define CV_NODE_HAS_NAME(flags)      (((flags) & CV_NODE_NAMED) != 0)\r
1693 \r
1694 #define CV_NODE_SEQ_SIMPLE 256\r
1695 #define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)\r
1696 \r
1697 typedef struct CvString\r
1698 {\r
1699     int len;\r
1700     char* ptr;\r
1701 }\r
1702 CvString;\r
1703 \r
1704 /* All the keys (names) of elements in the readed file storage\r
1705    are stored in the hash to speed up the lookup operations: */\r
1706 typedef struct CvStringHashNode\r
1707 {\r
1708     unsigned hashval;\r
1709     CvString str;\r
1710     struct CvStringHashNode* next;\r
1711 }\r
1712 CvStringHashNode;\r
1713 \r
1714 typedef struct CvGenericHash CvFileNodeHash;\r
1715 \r
1716 /* Basic element of the file storage - scalar or collection: */\r
1717 typedef struct CvFileNode\r
1718 {\r
1719     int tag;\r
1720     struct CvTypeInfo* info; /* type information\r
1721             (only for user-defined object, for others it is 0) */\r
1722     union\r
1723     {\r
1724         double f; /* scalar floating-point number */\r
1725         int i;    /* scalar integer number */\r
1726         CvString str; /* text string */\r
1727         CvSeq* seq; /* sequence (ordered collection of file nodes) */\r
1728         CvFileNodeHash* map; /* map (collection of named file nodes) */\r
1729     } data;\r
1730 }\r
1731 CvFileNode;\r
1732 \r
1733 #ifdef __cplusplus\r
1734 extern "C" {\r
1735 #endif\r
1736 typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );\r
1737 typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );\r
1738 typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );\r
1739 typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,\r
1740                                       const void* struct_ptr, CvAttrList attributes );\r
1741 typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );\r
1742 #ifdef __cplusplus\r
1743 }\r
1744 #endif\r
1745 \r
1746 typedef struct CvTypeInfo\r
1747 {\r
1748     int flags;\r
1749     int header_size;\r
1750     struct CvTypeInfo* prev;\r
1751     struct CvTypeInfo* next;\r
1752     const char* type_name;\r
1753     CvIsInstanceFunc is_instance;\r
1754     CvReleaseFunc release;\r
1755     CvReadFunc read;\r
1756     CvWriteFunc write;\r
1757     CvCloneFunc clone;\r
1758 }\r
1759 CvTypeInfo;\r
1760 \r
1761 \r
1762 /**** System data types ******/\r
1763 \r
1764 typedef struct CvPluginFuncInfo\r
1765 {\r
1766     void** func_addr;\r
1767     void* default_func_addr;\r
1768     const char* func_names;\r
1769     int search_modules;\r
1770     int loaded_from;\r
1771 }\r
1772 CvPluginFuncInfo;\r
1773 \r
1774 typedef struct CvModuleInfo\r
1775 {\r
1776     struct CvModuleInfo* next;\r
1777     const char* name;\r
1778     const char* version;\r
1779     CvPluginFuncInfo* func_tab;\r
1780 }\r
1781 CvModuleInfo;\r
1782 \r
1783 #endif /*_CXCORE_TYPES_H_*/\r
1784 \r
1785 /* End of file. */\r