modules/core/include/opencv2/core/types_c.h

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