Cinder

  • Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

include/opencv2/core/types_c.h

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