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__
142 typedef __int64 int64;
143 typedef unsigned __int64 uint64;
144 #else
145 typedef long long int64;
146 typedef unsigned long long uint64;
147 #endif
148
149 #ifndef HAVE_IPL
150 typedef unsigned char uchar;
151 typedef unsigned short ushort;
152 #endif
153
154 typedef 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 */
161 typedef void CvArr;
162
163 typedef union Cv32suf
164 {
165 int i;
166 unsigned u;
167 float f;
168 }
169 Cv32suf;
170
171 typedef union Cv64suf
172 {
173 int64 i;
174 uint64 u;
175 double f;
176 }
177 Cv64suf;
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
cvRound(double value)210 CV_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
cvFloor(double value)237 CV_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
cvCeil(double value)252 CV_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
cvIsNaN(double value)269 CV_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
cvIsInf(double value)284 CV_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
301 typedef uint64 CvRNG;
302
303 CV_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: */
cvRandInt(CvRNG * rng)310 CV_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: */
cvRandReal(CvRNG * rng)319 CV_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
365 typedef 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 }
398 IplImage;
399
400 typedef struct _IplTileInfo IplTileInfo;
401
402 typedef 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 }
410 IplROI;
411
412 typedef struct _IplConvKernel
413 {
414 int nCols;
415 int nRows;
416 int anchorX;
417 int anchorY;
418 int *values;
419 int nShiftR;
420 }
421 IplConvKernel;
422
423 typedef struct _IplConvKernelFP
424 {
425 int nCols;
426 int nRows;
427 int anchorX;
428 int anchorY;
429 float *values;
430 }
431 IplConvKernelFP;
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
543 typedef 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 }
579 CvMat;
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 */
cvMat(int rows,int cols,int type,void * data CV_DEFAULT (NULL))621 CV_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
cvmGet(const CvMat * mat,int row,int col)651 CV_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
cvmSet(CvMat * mat,int row,int col,double value)669 CV_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
cvCvToIplDepth(int type)686 CV_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
704 typedef 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 }
728 CvMatND;
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
744 struct CvSet;
745
746 typedef 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 }
760 CvSparseMat;
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
771 typedef struct CvSparseNode
772 {
773 unsigned hashval;
774 struct CvSparseNode* next;
775 }
776 CvSparseNode;
777
778 typedef struct CvSparseMatIterator
779 {
780 CvSparseMat* mat;
781 CvSparseNode* node;
782 int curidx;
783 }
784 CvSparseMatIterator;
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
793 typedef 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
809 typedef 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 }
817 CvHistogram;
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
839 typedef struct CvRect
840 {
841 int x;
842 int y;
843 int width;
844 int height;
845 }
846 CvRect;
847
cvRect(int x,int y,int width,int height)848 CV_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
cvRectToROI(CvRect rect,int coi)861 CV_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
cvROIToRect(IplROI roi)874 CV_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
885 typedef 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 }
893 CvTermCriteria;
894
cvTermCriteria(int type,int max_iter,double epsilon)895 CV_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
909 typedef struct CvPoint
910 {
911 int x;
912 int y;
913 }
914 CvPoint;
915
916
cvPoint(int x,int y)917 CV_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
928 typedef struct CvPoint2D32f
929 {
930 float x;
931 float y;
932 }
933 CvPoint2D32f;
934
935
cvPoint2D32f(double x,double y)936 CV_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
cvPointTo32f(CvPoint point)947 CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )
948 {
949 return cvPoint2D32f( (float)point.x, (float)point.y );
950 }
951
952
cvPointFrom32f(CvPoint2D32f point)953 CV_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
963 typedef struct CvPoint3D32f
964 {
965 float x;
966 float y;
967 float z;
968 }
969 CvPoint3D32f;
970
971
cvPoint3D32f(double x,double y,double z)972 CV_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
984 typedef struct CvPoint2D64f
985 {
986 double x;
987 double y;
988 }
989 CvPoint2D64f;
990
991
cvPoint2D64f(double x,double y)992 CV_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
1003 typedef struct CvPoint3D64f
1004 {
1005 double x;
1006 double y;
1007 double z;
1008 }
1009 CvPoint3D64f;
1010
1011
cvPoint3D64f(double x,double y,double z)1012 CV_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
1026 typedef struct
1027 {
1028 int width;
1029 int height;
1030 }
1031 CvSize;
1032
cvSize(int width,int height)1033 CV_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
1043 typedef struct CvSize2D32f
1044 {
1045 float width;
1046 float height;
1047 }
1048 CvSize2D32f;
1049
1050
cvSize2D32f(double width,double height)1051 CV_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
1061 typedef 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 }
1068 CvBox2D;
1069
1070
1071 /* Line iterator state: */
1072 typedef 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 }
1084 CvLineIterator;
1085
1086
1087
1088 /************************************* CvSlice ******************************************/
1089
1090 typedef struct CvSlice
1091 {
1092 int start_index, end_index;
1093 }
1094 CvSlice;
1095
cvSlice(int start,int end)1096 CV_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
1111 typedef struct CvScalar
1112 {
1113 double val[4];
1114 }
1115 CvScalar;
1116
1117 CV_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
cvRealScalar(double val0)1127 CV_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
cvScalarAll(double val0123)1135 CV_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
1151 typedef struct CvMemBlock
1152 {
1153 struct CvMemBlock* prev;
1154 struct CvMemBlock* next;
1155 }
1156 CvMemBlock;
1157
1158 #define CV_STORAGE_MAGIC_VAL 0x42890000
1159
1160 typedef 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 }
1169 CvMemStorage;
1170
1171 #define CV_IS_STORAGE(storage) \
1172 ((storage) != NULL && \
1173 (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)
1174
1175
1176 typedef struct CvMemStoragePos
1177 {
1178 CvMemBlock* top;
1179 int free_space;
1180 }
1181 CvMemStoragePos;
1182
1183
1184 /*********************************** Sequence *******************************************/
1185
1186 typedef 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 }
1195 CvSeqBlock;
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
1221 typedef struct CvSeq
1222 {
1223 CV_SEQUENCE_FIELDS()
1224 }
1225 CvSeq;
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
1241 typedef struct CvSetElem
1242 {
1243 CV_SET_ELEM_FIELDS(CvSetElem)
1244 }
1245 CvSetElem;
1246
1247 #define CV_SET_FIELDS() \
1248 CV_SEQUENCE_FIELDS() \
1249 CvSetElem* free_elems; \
1250 int active_count;
1251
1252 typedef struct CvSet
1253 {
1254 CV_SET_FIELDS()
1255 }
1256 CvSet;
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
1297 typedef struct CvGraphEdge
1298 {
1299 CV_GRAPH_EDGE_FIELDS()
1300 }
1301 CvGraphEdge;
1302
1303 typedef struct CvGraphVtx
1304 {
1305 CV_GRAPH_VERTEX_FIELDS()
1306 }
1307 CvGraphVtx;
1308
1309 typedef struct CvGraphVtx2D
1310 {
1311 CV_GRAPH_VERTEX_FIELDS()
1312 CvPoint2D32f* ptr;
1313 }
1314 CvGraphVtx2D;
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
1324 typedef struct CvGraph
1325 {
1326 CV_GRAPH_FIELDS()
1327 }
1328 CvGraph;
1329
1330 #define CV_TYPE_NAME_GRAPH "opencv-graph"
1331
1332 /*********************************** Chain/Countour *************************************/
1333
1334 typedef struct CvChain
1335 {
1336 CV_SEQUENCE_FIELDS()
1337 CvPoint origin;
1338 }
1339 CvChain;
1340
1341 #define CV_CONTOUR_FIELDS() \
1342 CV_SEQUENCE_FIELDS() \
1343 CvRect rect; \
1344 int color; \
1345 int reserved[3];
1346
1347 typedef struct CvContour
1348 {
1349 CV_CONTOUR_FIELDS()
1350 }
1351 CvContour;
1352
1353 typedef 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
1491 typedef struct CvSeqWriter
1492 {
1493 CV_SEQ_WRITER_FIELDS()
1494 }
1495 CvSeqWriter;
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
1509 typedef struct CvSeqReader
1510 {
1511 CV_SEQ_READER_FIELDS()
1512 }
1513 CvSeqReader;
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 */
1629 typedef 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: */
1639 typedef 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 }
1644 CvAttrList;
1645
cvAttrList(const char ** attr CV_DEFAULT (NULL),CvAttrList * next CV_DEFAULT (NULL))1646 CV_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
1656 struct 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
1692 typedef struct CvString
1693 {
1694 int len;
1695 char* ptr;
1696 }
1697 CvString;
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: */
1701 typedef struct CvStringHashNode
1702 {
1703 unsigned hashval;
1704 CvString str;
1705 struct CvStringHashNode* next;
1706 }
1707 CvStringHashNode;
1708
1709 typedef struct CvGenericHash CvFileNodeHash;
1710
1711 /* Basic element of the file storage - scalar or collection: */
1712 typedef 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 }
1726 CvFileNode;
1727
1728 #ifdef __cplusplus
1729 extern "C" {
1730 #endif
1731 typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
1732 typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
1733 typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );
1734 typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,
1735 const void* struct_ptr, CvAttrList attributes );
1736 typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );
1737 #ifdef __cplusplus
1738 }
1739 #endif
1740
1741 typedef 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 }
1754 CvTypeInfo;
1755
1756
1757 /**** System data types ******/
1758
1759 typedef 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 }
1767 CvPluginFuncInfo;
1768
1769 typedef struct CvModuleInfo
1770 {
1771 struct CvModuleInfo* next;
1772 const char* name;
1773 const char* version;
1774 CvPluginFuncInfo* func_tab;
1775 }
1776 CvModuleInfo;
1777
1778 #endif /*_CXCORE_TYPES_H_*/
1779
1780 /* End of file. */
1781