source: UH/SAMGAR/SAMGAR Gui/HeaderFiles/cxtypes.h @ 125

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