visageSDK
vs_core_types_c.h
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
16 //
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
19 //
20 // * Redistribution's of source code must retain the above copyright notice,
21 // this list of conditions and the following disclaimer.
22 //
23 // * Redistribution's in binary form must reproduce the above copyright notice,
24 // this list of conditions and the following disclaimer in the documentation
25 // and/or other materials provided with the distribution.
26 //
27 // * The name of the copyright holders may not be used to endorse or promote products
28 // derived from this software without specific prior written permission.
29 //
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
40 //
41 //M*/
42 
43 #ifndef __VS_CORE_TYPES_H__
44 #define __VS_CORE_TYPES_H__
45 
46 #if !defined _CRT_SECURE_NO_DEPRECATE && defined _MSC_VER
47 # if _MSC_VER > 1300
48 # define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */
49 # endif
50 #endif
51 
52 
53 #ifndef SKIP_INCLUDES
54 
55 #include <assert.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #include <float.h>
59 
60 #if !defined _MSC_VER && !defined __BORLANDC__
61 # include <stdint.h>
62 #endif
63 
64 #if defined __ICL
65 # define VS_ICC __ICL
66 #elif defined __ICC
67 # define VS_ICC __ICC
68 #elif defined __ECL
69 # define VS_ICC __ECL
70 #elif defined __ECC
71 # define VS_ICC __ECC
72 #elif defined __INTEL_COMPILER
73 # define VS_ICC __INTEL_COMPILER
74 #endif
75 
76 #if defined VS_ICC && !defined VS_ENABLE_UNROLLED
77 # define VS_ENABLE_UNROLLED 0
78 #else
79 # define VS_ENABLE_UNROLLED 1
80 #endif
81 
82 #if (defined _M_X64 && defined _MSC_VER && _MSC_VER >= 1400) || (defined __GNUC__ && __GNUC__ >= 4 && defined __x86_64__)
83 # if defined WIN32
84 # include <intrin.h>
85 # endif
86 # if defined __SSE2__ || !defined __GNUC__
87 # include <emmintrin.h>
88 # endif
89 #endif
90 
91 #include <math.h>
92 
93 #endif // SKIP_INCLUDES
94 
95 #if defined WIN32 || defined _WIN32
96 # define VS_CDECL __cdecl
97 # define VS_STDCALL __stdcall
98 #else
99 # define VS_CDECL
100 # define VS_STDCALL
101 #endif
102 
103 #ifndef VS_EXTERN_C
104 # ifdef __cplusplus
105 # define VS_EXTERN_C extern "C"
106 # define VS_DEFAULT(val) = val
107 # else
108 # define VS_EXTERN_C
109 # define VS_DEFAULT(val)
110 # endif
111 #endif
112 
113 #ifndef VS_EXTERN_C_FUNCPTR
114 # ifdef __cplusplus
115 # define VS_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }
116 # else
117 # define VS_EXTERN_C_FUNCPTR(x) typedef x
118 # endif
119 #endif
120 
121 #ifndef VS_INLINE
122 # if defined __cplusplus
123 # define VS_INLINE inline
124 # elif defined _MSC_VER
125 # define VS_INLINE __inline
126 # else
127 # define VS_INLINE static
128 # endif
129 #endif /* VS_INLINE */
130 
131 #if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
132 # define VS_EXPORTS __declspec(dllexport)
133 #else
134 # define VS_EXPORTS
135 #endif
136 
137 #ifndef CVAPI
138 # define CVAPI(rettype) VS_EXTERN_C VS_EXPORTS rettype VS_CDECL
139 #endif
140 
141 #ifndef VSAPI
142 #if (defined WIN32 || defined _WIN32 || defined WINCE)
143 # define VSAPI(rettype) __declspec(dllexport) rettype VS_CDECL
144 #else
145 # define VSAPI(rettype) VS_EXTERN_C VS_EXPORTS rettype VS_CDECL
146 #endif
147 #endif
148 
149 #if defined _MSC_VER || defined __BORLANDC__
150  typedef __int64 int64;
151  typedef unsigned __int64 uint64;
152 # define VS_BIG_INT(n) n##I64
153 # define VS_BIG_UINT(n) n##UI64
154 #else
155  typedef int64_t int64;
156  typedef uint64_t uint64;
157 # define VS_BIG_INT(n) n##LL
158 # define VS_BIG_UINT(n) n##ULL
159 #endif
160 
161 #ifndef HAVE_IPL
162  typedef unsigned char uchar;
163  typedef unsigned short ushort;
164 #endif
165 
166 typedef signed char schar;
167 
168 /* special informative macros for wrapper generators */
169 #define VS_CARRAY(counter)
170 #define VS_CUSTOM_CARRAY(args)
171 #define VS_EXPORTS_W VS_EXPORTS
172 #define VS_EXPORTS_W_SIMPLE VS_EXPORTS
173 #define VS_EXPORTS_AS(synonym) VS_EXPORTS
174 #define VS_EXPORTS_W_MAP VS_EXPORTS
175 #define VS_IN_OUT
176 #define VS_OUT
177 #define VS_PROP
178 #define VS_PROP_RW
179 #define VS_WRAP
180 #define VS_WRAP_AS(synonym)
181 #define VS_WRAP_DEFAULT(value)
182 
183 /* VsArr* is used to pass arbitrary
184  * array-like data structures
185  * into functions where the particular
186  * array type is recognized at runtime:
187  */
188 typedef void VsArr;
189 
190 typedef union Vs32suf
191 {
192  int i;
193  unsigned u;
194  float f;
195 }
196 Vs32suf;
197 
198 typedef union Vs64suf
199 {
200  int64 i;
201  uint64 u;
202  double f;
203 }
204 Vs64suf;
205 
206 typedef int VSStatus;
207 
208 enum {
209  VS_StsOk= 0, /* everithing is ok */
210  VS_StsBackTrace= -1, /* pseudo error for back trace */
211  VS_StsError= -2, /* unknown /unspecified error */
212  VS_StsInternal= -3, /* internal error (bad state) */
213  VS_StsNoMem= -4, /* insufficient memory */
214  VS_StsBadArg= -5, /* function arg/param is bad */
215  VS_StsBadFunc= -6, /* unsupported function */
216  VS_StsNoConv= -7, /* iter. didn't converge */
217  VS_StsAutoTrace= -8, /* tracing */
218  VS_HeaderIsNull= -9, /* image header is NULL */
219  VS_BadImageSize= -10, /* image size is invalid */
220  VS_BadOffset= -11, /* offset is invalid */
221  VS_BadDataPtr= -12,
222  VS_BadStep= -13,
223  VS_BadModelOrChSeq= -14,
224  VS_BadNumChannels= -15,
225  VS_BadNumChannel1U= -16,
226  VS_BadDepth= -17,
227  VS_BadAlphaChannel= -18,
228  VS_BadOrder= -19,
229  VS_BadOrigin= -20,
230  VS_BadAlign= -21,
231  VS_BadCallBack= -22,
232  VS_BadTileSize= -23,
233  VS_BadCOI= -24,
234  VS_BadROISize= -25,
235  VS_MaskIsTiled= -26,
236  VS_StsNullPtr= -27, /* null pointer */
237  VS_StsVecLengthErr= -28, /* incorrect vector length */
238  VS_StsFilterStructContentErr= -29, /* incorr. filter structure content */
239  VS_StsKernelStructContentErr= -30, /* incorr. transform kernel content */
240  VS_StsFilterOffsetErr= -31, /* incorrect filter offset value */
241  VS_StsBadSize= -201, /* the input/output structure size is incorrect */
242  VS_StsDivByZero= -202, /* division by zero */
243  VS_StsInplaceNotSupported= -203, /* in-place operation is not supported */
244  VS_StsObjectNotFound= -204, /* request can't be completed */
245  VS_StsUnmatchedFormats= -205, /* formats of input/output arrays differ */
246  VS_StsBadFlag= -206, /* flag is wrong or not supported */
247  VS_StsBadPoint= -207, /* bad VsPoint */
248  VS_StsBadMask= -208, /* bad format of mask (neither 8uC1 nor 8sC1)*/
249  VS_StsUnmatchedSizes= -209, /* sizes of input/output structures do not match */
250  VS_StsUnsupportedFormat= -210, /* the data format/type is not supported by the function*/
251  VS_StsOutOfRange= -211, /* some of parameters are out of range */
252  VS_StsParseError= -212, /* invalid syntax/structure of the parsed file */
253  VS_StsNotImplemented= -213, /* the requested function/feature is not implemented */
254  VS_StsBadMemBlock= -214, /* an allocated block has been corrupted */
255  VS_StsAssert= -215, /* assertion failed */
256  VS_GpuNotSupported= -216,
257  VS_GpuApiCallError= -217,
258  VS_OpenGlNotSupported= -218,
259  VS_OpenGlApiCallError= -219,
260  VS_OpenCLDoubleNotSupported= -220,
261  VS_OpenCLInitError= -221,
262  VS_OpenCLNoAMDBlasFft= -222
263 };
264 
265 /****************************************************************************************\
266 * Common macros and inline functions *
267 \****************************************************************************************/
268 
269 #ifdef HAVE_TEGRA_OPTIMIZATION
270 # include "tegra_round.hpp"
271 #endif
272 
273 #define VS_PI 3.1415926535897932384626433832795
274 #define VS_LOG2 0.69314718055994530941723212145818
275 
276 #define VS_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
277 
278 #ifndef MIN
279 # define MIN(a,b) ((a) > (b) ? (b) : (a))
280 #endif
281 
282 #ifndef MAX
283 # define MAX(a,b) ((a) < (b) ? (b) : (a))
284 #endif
285 
286 /* min & max without jumps */
287 #define VS_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))
288 
289 #define VS_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))
290 
291 /* absolute value without jumps */
292 #ifndef __cplusplus
293 # define VS_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))
294 #else
295 # define VS_IABS(a) abs(a)
296 #endif
297 #define VS_CMP(a,b) (((a) > (b)) - ((a) < (b)))
298 #define VS_SIGN(a) VS_CMP((a),0)
299 
300 VS_INLINE int vsRound( double value )
301 {
302 #if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)
303  __m128d t = _mm_set_sd( value );
304  return _mm_cvtsd_si32(t);
305 #elif defined _MSC_VER && defined _M_IX86
306  int t;
307  __asm
308  {
309  fld value;
310  fistp t;
311  }
312  return t;
313 #elif defined _MSC_VER && defined _M_ARM && defined HAVE_TEGRA_OPTIMIZATION
314  TEGRA_ROUND(value);
315 #elif defined VS_ICC || defined __GNUC__
316 # ifdef HAVE_TEGRA_OPTIMIZATION
317  TEGRA_ROUND(value);
318 # else
319  return (int)lrint(value);
320 # endif
321 #else
322  double intpart, fractpart;
323  fractpart = modf(value, &intpart);
324  if ((fabs(fractpart) != 0.5) || ((((int)intpart) % 2) != 0))
325  return (int)(value + (value >= 0 ? 0.5 : -0.5));
326  else
327  return (int)intpart;
328 #endif
329 }
330 
331 #if defined __SSE2__ || (defined _M_IX86_FP && 2 == _M_IX86_FP)
332 # include "emmintrin.h"
333 #endif
334 
335 VS_INLINE int vsFloor( double value )
336 {
337 #if defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__ && !defined __APPLE__)
338  __m128d t = _mm_set_sd( value );
339  int i = _mm_cvtsd_si32(t);
340  return i - _mm_movemask_pd(_mm_cmplt_sd(t, _mm_cvtsi32_sd(t,i)));
341 #elif defined __GNUC__
342  int i = (int)value;
343  return i - (i > value);
344 #else
345  int i = vsRound(value);
346  float diff = (float)(value - i);
347  return i - (diff < 0);
348 #endif
349 }
350 
351 
352 VS_INLINE int vsCeil( double value )
353 {
354 #if defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__&& !defined __APPLE__)
355  __m128d t = _mm_set_sd( value );
356  int i = _mm_cvtsd_si32(t);
357  return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i), t));
358 #elif defined __GNUC__
359  int i = (int)value;
360  return i + (i < value);
361 #else
362  int i = vsRound(value);
363  float diff = (float)(i - value);
364  return i + (diff < 0);
365 #endif
366 }
367 
368 #define vsInvSqrt(value) ((float)(1./sqrt(value)))
369 #define vsSqrt(value) ((float)sqrt(value))
370 
371 VS_INLINE int vsIsNaN( double value )
372 {
373  Vs64suf ieee754;
374  ieee754.f = value;
375  return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +
376  ((unsigned)ieee754.u != 0) > 0x7ff00000;
377 }
378 
379 
380 VS_INLINE int vsIsInf( double value )
381 {
382  Vs64suf ieee754;
383  ieee754.f = value;
384  return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&
385  (unsigned)ieee754.u == 0;
386 }
387 
388 
389 /*************** Random number generation *******************/
390 
391 typedef uint64 VsRNG;
392 
393 #define VS_RNG_COEFF 4164903690U
394 
395 VS_INLINE VsRNG vsRNG( int64 seed VS_DEFAULT(-1))
396 {
397  VsRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;
398  return rng;
399 }
400 
401 /* Return random 32-bit unsigned integer: */
402 VS_INLINE unsigned vsRandInt( VsRNG* rng )
403 {
404  uint64 temp = *rng;
405  temp = (uint64)(unsigned)temp*VS_RNG_COEFF + (temp >> 32);
406  *rng = temp;
407  return (unsigned)temp;
408 }
409 
410 /* Returns random floating-point number between 0 and 1: */
411 VS_INLINE double vsRandReal( VsRNG* rng )
412 {
413  return vsRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */;
414 }
415 
416 /****************************************************************************************\
417 * Image type (VsImage) *
418 \****************************************************************************************/
419 
420 #ifndef HAVE_IPL
421 
422 /*
423  * The following definitions (until #endif)
424  * is an extract from IPL headers.
425  * Copyright (c) 1995 Intel Corporation.
426  */
427 #define VS_DEPTH_SIGN 0x80000000
428 
429 #define VS_DEPTH_1U 1
430 #define VS_DEPTH_8U 8
431 #define VS_DEPTH_16U 16
432 #define VS_DEPTH_32F 32
433 
434 #define VS_DEPTH_8S (VS_DEPTH_SIGN| 8)
435 #define VS_DEPTH_16S (VS_DEPTH_SIGN|16)
436 #define VS_DEPTH_32S (VS_DEPTH_SIGN|32)
437 
438 #define VS_DATA_ORDER_PIXEL 0
439 #define VS_DATA_ORDER_PLANE 1
440 
441 #define VS_ORIGIN_TL 0
442 #define VS_ORIGIN_BL 1
443 
444 #define VS_ALIGN_4BYTES 4
445 #define VS_ALIGN_8BYTES 8
446 #define VS_ALIGN_16BYTES 16
447 #define VS_ALIGN_32BYTES 32
448 
449 #define VS_ALIGN_DWORD VS_ALIGN_4BYTES
450 #define VS_ALIGN_QWORD VS_ALIGN_8BYTES
451 
452 #define VS_BORDER_CONSTANT 0
453 #define VS_BORDER_REPLICATE 1
454 #define VS_BORDER_REFLECT 2
455 #define VS_BORDER_WRAP 3
456 
460 typedef struct _VsImage
461 {
462  int nSize;
463  int ID;
464  int nChannels;
466  int depth;
468  char colorModel[4];
469  char channelSeq[4];
470  int dataOrder;
472  int origin;
474  int align;
476  int width;
477  int height;
478  struct _VsROI *roi;
479  struct _VsImage *maskROI;
480  void *imageId;
481  struct _VsTileInfo *tileInfo;
482  int imageSize;
485  char *imageData;
486  int widthStep;
487  int BorderMode[4];
488  int BorderConst[4];
492 }
493 VsImage;
494 
495 typedef struct _VsTileInfo VsTileInfo;
496 
497 typedef struct _VsROI
498 {
499  int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/
500  int xOffset;
501  int yOffset;
502  int width;
503  int height;
504 }
505 VsROI;
506 
507 typedef struct _VsConvKernel
508 {
509  int nCols;
510  int nRows;
511  int anchorX;
512  int anchorY;
513  int *values;
514  int nShiftR;
515 }
516 VsConvKernel;
517 
518 typedef struct _VsConvKernelFP
519 {
520  int nCols;
521  int nRows;
522  int anchorX;
523  int anchorY;
524  float *values;
525 }
526 VsConvKernelFP;
527 
528 #define VS_IMAGE_HEADER 1
529 #define VS_IMAGE_DATA 2
530 #define VS_IMAGE_ROI 4
531 
532 #endif/*HAVE_IPL*/
533 
534 /* extra border mode */
535 #define VS_BORDER_REFLECT_101 4
536 #define VS_BORDER_TRANSPARENT 5
537 
538 #define VS_IMAGE_MAGIC_VAL ((int)sizeof(VsImage))
539 #define VS_TYPE_NAME_IMAGE "opencv-image"
540 
541 #define VS_IS_IMAGE_HDR(img) \
542  ((img) != NULL && ((const VsImage*)(img))->nSize == sizeof(VsImage))
543 
544 #define VS_IS_IMAGE(img) \
545  (VS_IS_IMAGE_HDR(img) && ((VsImage*)img)->imageData != NULL)
546 
547 /* for storing double-precision
548  floating point data in VsImage's */
549 #define VS_DEPTH_64F 64
550 
551 /* get reference to pixel at (col,row),
552  for multi-channel images (col) should be multiplied by number of channels */
553 #define VS_IMAGE_ELEM( image, elemtype, row, col ) \
554  (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])
555 
556 /****************************************************************************************\
557 * Matrix type (VsMat) *
558 \****************************************************************************************/
559 
560 #define VS_CN_MAX 512
561 #define VS_CN_SHIFT 3
562 #define VS_DEPTH_MAX (1 << VS_CN_SHIFT)
563 
564 #define VS_8U 0
565 #define VS_8S 1
566 #define VS_16U 2
567 #define VS_16S 3
568 #define VS_32S 4
569 #define VS_32F 5
570 #define VS_64F 6
571 #define VS_USRTYPE1 7
572 
573 #define VS_MAT_DEPTH_MASK (VS_DEPTH_MAX - 1)
574 #define VS_MAT_DEPTH(flags) ((flags) & VS_MAT_DEPTH_MASK)
575 
576 #define VS_MAKETYPE(depth,cn) (VS_MAT_DEPTH(depth) + (((cn)-1) << VS_CN_SHIFT))
577 #define VS_MAKE_TYPE VS_MAKETYPE
578 
579 #define VS_8UC1 VS_MAKETYPE(VS_8U,1)
580 #define VS_8UC2 VS_MAKETYPE(VS_8U,2)
581 #define VS_8UC3 VS_MAKETYPE(VS_8U,3)
582 #define VS_8UC4 VS_MAKETYPE(VS_8U,4)
583 #define VS_8UC(n) VS_MAKETYPE(VS_8U,(n))
584 
585 #define VS_8SC1 VS_MAKETYPE(VS_8S,1)
586 #define VS_8SC2 VS_MAKETYPE(VS_8S,2)
587 #define VS_8SC3 VS_MAKETYPE(VS_8S,3)
588 #define VS_8SC4 VS_MAKETYPE(VS_8S,4)
589 #define VS_8SC(n) VS_MAKETYPE(VS_8S,(n))
590 
591 #define VS_16UC1 VS_MAKETYPE(VS_16U,1)
592 #define VS_16UC2 VS_MAKETYPE(VS_16U,2)
593 #define VS_16UC3 VS_MAKETYPE(VS_16U,3)
594 #define VS_16UC4 VS_MAKETYPE(VS_16U,4)
595 #define VS_16UC(n) VS_MAKETYPE(VS_16U,(n))
596 
597 #define VS_16SC1 VS_MAKETYPE(VS_16S,1)
598 #define VS_16SC2 VS_MAKETYPE(VS_16S,2)
599 #define VS_16SC3 VS_MAKETYPE(VS_16S,3)
600 #define VS_16SC4 VS_MAKETYPE(VS_16S,4)
601 #define VS_16SC(n) VS_MAKETYPE(VS_16S,(n))
602 
603 #define VS_32SC1 VS_MAKETYPE(VS_32S,1)
604 #define VS_32SC2 VS_MAKETYPE(VS_32S,2)
605 #define VS_32SC3 VS_MAKETYPE(VS_32S,3)
606 #define VS_32SC4 VS_MAKETYPE(VS_32S,4)
607 #define VS_32SC(n) VS_MAKETYPE(VS_32S,(n))
608 
609 #define VS_32FC1 VS_MAKETYPE(VS_32F,1)
610 #define VS_32FC2 VS_MAKETYPE(VS_32F,2)
611 #define VS_32FC3 VS_MAKETYPE(VS_32F,3)
612 #define VS_32FC4 VS_MAKETYPE(VS_32F,4)
613 #define VS_32FC(n) VS_MAKETYPE(VS_32F,(n))
614 
615 #define VS_64FC1 VS_MAKETYPE(VS_64F,1)
616 #define VS_64FC2 VS_MAKETYPE(VS_64F,2)
617 #define VS_64FC3 VS_MAKETYPE(VS_64F,3)
618 #define VS_64FC4 VS_MAKETYPE(VS_64F,4)
619 #define VS_64FC(n) VS_MAKETYPE(VS_64F,(n))
620 
621 #define VS_AUTO_STEP 0x7fffffff
622 #define VS_WHOLE_ARR vsSlice( 0, 0x3fffffff )
623 
624 #define VS_MAT_CN_MASK ((VS_CN_MAX - 1) << VS_CN_SHIFT)
625 #define VS_MAT_CN(flags) ((((flags) & VS_MAT_CN_MASK) >> VS_CN_SHIFT) + 1)
626 #define VS_MAT_TYPE_MASK (VS_DEPTH_MAX*VS_CN_MAX - 1)
627 #define VS_MAT_TYPE(flags) ((flags) & VS_MAT_TYPE_MASK)
628 #define VS_MAT_CONT_FLAG_SHIFT 14
629 #define VS_MAT_CONT_FLAG (1 << VS_MAT_CONT_FLAG_SHIFT)
630 #define VS_IS_MAT_CONT(flags) ((flags) & VS_MAT_CONT_FLAG)
631 #define VS_IS_CONT_MAT VS_IS_MAT_CONT
632 #define VS_SUBMAT_FLAG_SHIFT 15
633 #define VS_SUBMAT_FLAG (1 << VS_SUBMAT_FLAG_SHIFT)
634 #define VS_IS_SUBMAT(flags) ((flags) & VS_MAT_SUBMAT_FLAG)
635 
636 #define VS_MAGIC_MASK 0xFFFF0000
637 #define VS_MAT_MAGIC_VAL 0x42420000
638 #define VS_TYPE_NAME_MAT "opencv-matrix"
639 
640 typedef struct VsMat
641 {
642  int type;
643  int step;
644 
645  /* for internal use only */
646  int* refcount;
647  int hdr_refcount;
648 
649  union
650  {
651  uchar* ptr;
652  short* s;
653  int* i;
654  float* fl;
655  double* db;
656  } data;
657 
658 #ifdef __cplusplus
659  union
660  {
661  int rows;
662  int height;
663  };
664 
665  union
666  {
667  int cols;
668  int width;
669  };
670 #else
671  int rows;
672  int cols;
673 #endif
674 
675 }
676 VsMat;
677 
678 
679 
680 #define VS_IS_MAT_HDR(mat) \
681  ((mat) != NULL && \
682  (((const VsMat*)(mat))->type & VS_MAGIC_MASK) == VS_MAT_MAGIC_VAL && \
683  ((const VsMat*)(mat))->cols > 0 && ((const VsMat*)(mat))->rows > 0)
684 
685 #define VS_IS_MAT_HDR_Z(mat) \
686  ((mat) != NULL && \
687  (((const VsMat*)(mat))->type & VS_MAGIC_MASK) == VS_MAT_MAGIC_VAL && \
688  ((const VsMat*)(mat))->cols >= 0 && ((const VsMat*)(mat))->rows >= 0)
689 
690 #define VS_IS_MAT(mat) \
691  (VS_IS_MAT_HDR(mat) && ((const VsMat*)(mat))->data.ptr != NULL)
692 
693 #define VS_IS_MASK_ARR(mat) \
694  (((mat)->type & (VS_MAT_TYPE_MASK & ~VS_8SC1)) == 0)
695 
696 #define VS_ARE_TYPES_EQ(mat1, mat2) \
697  ((((mat1)->type ^ (mat2)->type) & VS_MAT_TYPE_MASK) == 0)
698 
699 #define VS_ARE_CNS_EQ(mat1, mat2) \
700  ((((mat1)->type ^ (mat2)->type) & VS_MAT_CN_MASK) == 0)
701 
702 #define VS_ARE_DEPTHS_EQ(mat1, mat2) \
703  ((((mat1)->type ^ (mat2)->type) & VS_MAT_DEPTH_MASK) == 0)
704 
705 #define VS_ARE_SIZES_EQ(mat1, mat2) \
706  ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)
707 
708 #define VS_IS_MAT_CONST(mat) \
709  (((mat)->rows|(mat)->cols) == 1)
710 
711 /* Size of each channel item,
712  0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */
713 #define VS_ELEM_SIZE1(type) \
714  ((((sizeof(size_t)<<28)|0x8442211) >> VS_MAT_DEPTH(type)*4) & 15)
715 
716 /* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */
717 #define VS_ELEM_SIZE(type) \
718  (VS_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> VS_MAT_DEPTH(type)*2) & 3))
719 
720 #define IPL2VS_DEPTH(depth) \
721  ((((VS_8U)+(VS_16U<<4)+(VS_32F<<8)+(VS_64F<<16)+(VS_8S<<20)+ \
722  (VS_16S<<24)+(VS_32S<<28)) >> ((((depth) & 0xF0) >> 2) + \
723  (((depth) & VS_DEPTH_SIGN) ? 20 : 0))) & 15)
724 
725 /* Inline constructor. No data is allocated internally!!!
726  * (Use together with vsCreateData, or use vsCreateMat instead to
727  * get a matrix with allocated data):
728  */
729 VS_INLINE VsMat vsMat( int rows, int cols, int type, void* data VS_DEFAULT(NULL))
730 {
731  VsMat m;
732 
733  assert( (unsigned)VS_MAT_DEPTH(type) <= VS_64F );
734  type = VS_MAT_TYPE(type);
735  m.type = VS_MAT_MAGIC_VAL | VS_MAT_CONT_FLAG | type;
736  m.cols = cols;
737  m.rows = rows;
738  m.step = m.cols*VS_ELEM_SIZE(type);
739  m.data.ptr = (uchar*)data;
740  m.refcount = NULL;
741  m.hdr_refcount = 0;
742 
743  return m;
744 }
745 
746 
747 #define VS_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \
748  (assert( (unsigned)(row) < (unsigned)(mat).rows && \
749  (unsigned)(col) < (unsigned)(mat).cols ), \
750  (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))
751 
752 #define VS_MAT_ELEM_PTR( mat, row, col ) \
753  VS_MAT_ELEM_PTR_FAST( mat, row, col, VS_ELEM_SIZE((mat).type) )
754 
755 #define VS_MAT_ELEM( mat, elemtype, row, col ) \
756  (*(elemtype*)VS_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))
757 
758 
759 VS_INLINE double vsmGet( const VsMat* mat, int row, int col )
760 {
761  int type;
762 
763  type = VS_MAT_TYPE(mat->type);
764  assert( (unsigned)row < (unsigned)mat->rows &&
765  (unsigned)col < (unsigned)mat->cols );
766 
767  if( type == VS_32FC1 )
768  return ((float*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col];
769  else
770  {
771  assert( type == VS_64FC1 );
772  return ((double*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col];
773  }
774 }
775 
776 
777 VS_INLINE void vsmSet( VsMat* mat, int row, int col, double value )
778 {
779  int type;
780  type = VS_MAT_TYPE(mat->type);
781  assert( (unsigned)row < (unsigned)mat->rows &&
782  (unsigned)col < (unsigned)mat->cols );
783 
784  if( type == VS_32FC1 )
785  ((float*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;
786  else
787  {
788  assert( type == VS_64FC1 );
789  ((double*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col] = value;
790  }
791 }
792 
793 
794 VS_INLINE int vsIplDepth( int type )
795 {
796  int depth = VS_MAT_DEPTH(type);
797  return VS_ELEM_SIZE1(depth)*8 | (depth == VS_8S || depth == VS_16S ||
798  depth == VS_32S ? VS_DEPTH_SIGN : 0);
799 }
800 
801 
802 /****************************************************************************************\
803 * Multi-dimensional dense array (VsMatND) *
804 \****************************************************************************************/
805 
806 #define VS_MATND_MAGIC_VAL 0x42430000
807 #define VS_TYPE_NAME_MATND "opencv-nd-matrix"
808 
809 #define VS_MAX_DIM 32
810 #define VS_MAX_DIM_HEAP 1024
811 
812 /****************************************************************************************\
813 * Histogram *
814 \****************************************************************************************/
815 
816 typedef int VsHistType;
817 
818 #define VS_HIST_MAGIC_VAL 0x42450000
819 #define VS_HIST_UNIFORM_FLAG (1 << 10)
820 
821 /* indicates whether bin ranges are set already or not */
822 #define VS_HIST_RANGES_FLAG (1 << 11)
823 
824 #define VS_HIST_ARRAY 0
825 #define VS_HIST_SPARSE 1
826 #define VS_HIST_TREE VS_HIST_SPARSE
827 
828 /* should be used as a parameter only,
829  it turns to VS_HIST_UNIFORM_FLAG of hist->type */
830 #define VS_HIST_UNIFORM 1
831 
832 
833 
834 #define VS_IS_HIST( hist ) \
835  ((hist) != NULL && \
836  (((VsHistogram*)(hist))->type & VS_MAGIC_MASK) == VS_HIST_MAGIC_VAL && \
837  (hist)->bins != NULL)
838 
839 #define VS_IS_UNIFORM_HIST( hist ) \
840  (((hist)->type & VS_HIST_UNIFORM_FLAG) != 0)
841 
842 #define VS_IS_SPARSE_HIST( hist ) \
843  VS_IS_SPARSE_MAT((hist)->bins)
844 
845 #define VS_HIST_HAS_RANGES( hist ) \
846  (((hist)->type & VS_HIST_RANGES_FLAG) != 0)
847 
848 /****************************************************************************************\
849 * Other supplementary data type definitions *
850 \****************************************************************************************/
851 
852 /*************************************** VsRect *****************************************/
853 
854 typedef struct VsRect
855 {
856  int x;
857  int y;
858  int width;
859  int height;
860 }
861 VsRect;
862 
863 VS_INLINE VsRect vsRect( int x, int y, int width, int height )
864 {
865  VsRect r;
866 
867  r.x = x;
868  r.y = y;
869  r.width = width;
870  r.height = height;
871 
872  return r;
873 }
874 
875 
876 VS_INLINE VsROI vsRectToROI( VsRect rect, int coi )
877 {
878  VsROI roi;
879  roi.xOffset = rect.x;
880  roi.yOffset = rect.y;
881  roi.width = rect.width;
882  roi.height = rect.height;
883  roi.coi = coi;
884 
885  return roi;
886 }
887 
888 
889 VS_INLINE VsRect vsROIToRect( VsROI roi )
890 {
891  return vsRect( roi.xOffset, roi.yOffset, roi.width, roi.height );
892 }
893 
894 /* VsRect32f*/
895 
896 typedef struct VsRect32f
897 {
898  float x;
899  float y;
900  float width;
901  float height;
902 }
903 VsRect32f;
904 
905 VS_INLINE VsRect32f vsRect32f(float x, float y, float width, float height)
906 {
907  VsRect32f r;
908 
909  r.x = x;
910  r.y = y;
911  r.width = width;
912  r.height = height;
913 
914  return r;
915 }
916 
917 
918 VS_INLINE VsROI vsRect32fToROI(VsRect32f rect, float coi)
919 {
920  VsROI roi;
921  roi.xOffset = static_cast<int>(rect.x);
922  roi.yOffset = static_cast<int>(rect.y);
923  roi.width = static_cast<int>(rect.width);
924  roi.height = static_cast<int>(rect.height);
925  roi.coi = static_cast<int>(coi);
926 
927  return roi;
928 }
929 
930 
931 VS_INLINE VsRect32f vsROIToRect32f(VsROI roi)
932 {
933  return vsRect32f(static_cast<float>(roi.xOffset), static_cast<float>(roi.yOffset), static_cast<float>(roi.width), static_cast<float>(roi.height));
934 }
935 
936 /*********************************** VsTermCriteria *************************************/
937 
938 #define VS_TERMCRIT_ITER 1
939 #define VS_TERMCRIT_NUMBER VS_TERMCRIT_ITER
940 #define VS_TERMCRIT_EPS 2
941 
942 typedef struct VsTermCriteria
943 {
944  int type; /* may be combination of
945  VS_TERMCRIT_ITER
946  VS_TERMCRIT_EPS */
947  int max_iter;
948  double epsilon;
949 }
950 VsTermCriteria;
951 
952 VS_INLINE VsTermCriteria vsTermCriteria( int type, int max_iter, double epsilon )
953 {
954  VsTermCriteria t;
955 
956  t.type = type;
957  t.max_iter = max_iter;
958  t.epsilon = (float)epsilon;
959 
960  return t;
961 }
962 
963 
964 /******************************* VsPoint and variants ***********************************/
965 
966 typedef struct VsPoint
967 {
968  int x;
969  int y;
970 }
971 VsPoint;
972 
973 
974 VS_INLINE VsPoint vsPoint( int x, int y )
975 {
976  VsPoint p;
977 
978  p.x = x;
979  p.y = y;
980 
981  return p;
982 }
983 
984 
985 typedef struct VsPoint2D32f
986 {
987  float x;
988  float y;
989 }
990 VsPoint2D32f;
991 
992 
993 VS_INLINE VsPoint2D32f vsPoint2D32f( double x, double y )
994 {
995  VsPoint2D32f p;
996 
997  p.x = (float)x;
998  p.y = (float)y;
999 
1000  return p;
1001 }
1002 
1003 
1004 VS_INLINE VsPoint2D32f vsPointTo32f( VsPoint point )
1005 {
1006  return vsPoint2D32f( (float)point.x, (float)point.y );
1007 }
1008 
1009 
1010 VS_INLINE VsPoint vsPointFrom32f( VsPoint2D32f point )
1011 {
1012  VsPoint ipt;
1013  ipt.x = vsRound(point.x);
1014  ipt.y = vsRound(point.y);
1015 
1016  return ipt;
1017 }
1018 
1019 
1020 typedef struct VsPoint3D32f
1021 {
1022  float x;
1023  float y;
1024  float z;
1025 }
1026 VsPoint3D32f;
1027 
1028 
1029 VS_INLINE VsPoint3D32f vsPoint3D32f( double x, double y, double z )
1030 {
1031  VsPoint3D32f p;
1032 
1033  p.x = (float)x;
1034  p.y = (float)y;
1035  p.z = (float)z;
1036 
1037  return p;
1038 }
1039 
1040 
1041 typedef struct VsPoint2D64f
1042 {
1043  double x;
1044  double y;
1045 }
1046 VsPoint2D64f;
1047 
1048 
1049 VS_INLINE VsPoint2D64f vsPoint2D64f( double x, double y )
1050 {
1051  VsPoint2D64f p;
1052 
1053  p.x = x;
1054  p.y = y;
1055 
1056  return p;
1057 }
1058 
1059 
1060 typedef struct VsPoint3D64f
1061 {
1062  double x;
1063  double y;
1064  double z;
1065 }
1066 VsPoint3D64f;
1067 
1068 
1069 VS_INLINE VsPoint3D64f vsPoint3D64f( double x, double y, double z )
1070 {
1071  VsPoint3D64f p;
1072 
1073  p.x = x;
1074  p.y = y;
1075  p.z = z;
1076 
1077  return p;
1078 }
1079 
1080 
1081 /******************************** VsSize's & CvBox **************************************/
1082 
1083 typedef struct VsSize
1084 {
1085  int width;
1086  int height;
1087 }
1088 VsSize;
1089 
1090 VS_INLINE VsSize vsSize( int width, int height )
1091 {
1092  VsSize s;
1093 
1094  s.width = width;
1095  s.height = height;
1096 
1097  return s;
1098 }
1099 
1100 typedef struct VsSize2D32f
1101 {
1102  float width;
1103  float height;
1104 }
1105 VsSize2D32f;
1106 
1107 
1108 VS_INLINE VsSize2D32f vsSize2D32f( double width, double height )
1109 {
1110  VsSize2D32f s;
1111 
1112  s.width = (float)width;
1113  s.height = (float)height;
1114 
1115  return s;
1116 }
1117 
1118 typedef struct VsBox2D
1119 {
1120  VsPoint2D32f center; /* Center of the box. */
1121  VsSize2D32f size; /* Box width and length. */
1122  float angle; /* Angle between the horizontal axis */
1123  /* and the first side (i.e. length) in degrees */
1124 }
1125 VsBox2D;
1126 
1127 
1128 /* Line iterator state: */
1129 typedef struct VsLineIterator
1130 {
1131  /* Pointer to the current point: */
1132  uchar* ptr;
1133 
1134  /* Bresenham algorithm state: */
1135  int err;
1136  int plus_delta;
1137  int minus_delta;
1138  int plus_step;
1139  int minus_step;
1140 }
1141 VsLineIterator;
1142 
1143 
1144 
1145 /************************************* VsSlice ******************************************/
1146 
1147 typedef struct VsSlice
1148 {
1149  int start_index, end_index;
1150 }
1151 VsSlice;
1152 
1153 VS_INLINE VsSlice vsSlice( int start, int end )
1154 {
1155  VsSlice slice;
1156  slice.start_index = start;
1157  slice.end_index = end;
1158 
1159  return slice;
1160 }
1161 
1162 #define VS_WHOLE_SEQ_END_INDEX 0x3fffffff
1163 #define VS_WHOLE_SEQ vsSlice(0, VS_WHOLE_SEQ_END_INDEX)
1164 
1165 
1166 /************************************* VsScalar *****************************************/
1167 
1168 typedef struct VsScalar
1169 {
1170  double val[4];
1171 }
1172 VsScalar;
1173 
1174 VS_INLINE VsScalar vsScalar( double val0, double val1 VS_DEFAULT(0),
1175  double val2 VS_DEFAULT(0), double val3 VS_DEFAULT(0))
1176 {
1177  VsScalar scalar;
1178  scalar.val[0] = val0; scalar.val[1] = val1;
1179  scalar.val[2] = val2; scalar.val[3] = val3;
1180  return scalar;
1181 }
1182 
1183 
1184 VS_INLINE VsScalar vsRealScalar( double val0 )
1185 {
1186  VsScalar scalar;
1187  scalar.val[0] = val0;
1188  scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
1189  return scalar;
1190 }
1191 
1192 VS_INLINE VsScalar vsScalarAll( double val0123 )
1193 {
1194  VsScalar scalar;
1195  scalar.val[0] = val0123;
1196  scalar.val[1] = val0123;
1197  scalar.val[2] = val0123;
1198  scalar.val[3] = val0123;
1199  return scalar;
1200 }
1201 
1202 /****************************************************************************************\
1203 * Dynamic Data structures *
1204 \****************************************************************************************/
1205 
1206 /******************************** Memory storage ****************************************/
1207 
1208 typedef struct VsMemBlock
1209 {
1210  struct VsMemBlock* prev;
1211  struct VsMemBlock* next;
1212 }
1213 VsMemBlock;
1214 
1215 #define VS_STORAGE_MAGIC_VAL 0x42890000
1216 
1217 typedef struct VsMemStorage
1218 {
1219  int signature;
1220  VsMemBlock* bottom; /* First allocated block. */
1221  VsMemBlock* top; /* Current memory block - top of the stack. */
1222  struct VsMemStorage* parent; /* We get new blocks from parent as needed. */
1223  int block_size; /* Block size. */
1224  int free_space; /* Remaining free space in current block. */
1225 }
1226 VsMemStorage;
1227 
1228 #define VS_IS_STORAGE(storage) \
1229  ((storage) != NULL && \
1230  (((VsMemStorage*)(storage))->signature & VS_MAGIC_MASK) == VS_STORAGE_MAGIC_VAL)
1231 
1232 
1233 typedef struct VsMemStoragePos
1234 {
1235  VsMemBlock* top;
1236  int free_space;
1237 }
1238 VsMemStoragePos;
1239 
1240 
1241 /*********************************** Sequence *******************************************/
1242 
1243 typedef struct VsSeqBlock
1244 {
1245  struct VsSeqBlock* prev; /* Previous sequence block. */
1246  struct VsSeqBlock* next; /* Next sequence block. */
1247  int start_index; /* Index of the first element in the block + */
1248  /* sequence->first->start_index. */
1249  int count; /* Number of elements in the block. */
1250  schar* data; /* Pointer to the first element of the block. */
1251 }
1252 VsSeqBlock;
1253 
1254 
1255 #define VS_TREE_NODE_FIELDS(node_type) \
1256  int flags; /* Miscellaneous flags. */ \
1257  int header_size; /* Size of sequence header. */ \
1258  struct node_type* h_prev; /* Previous sequence. */ \
1259  struct node_type* h_next; /* Next sequence. */ \
1260  struct node_type* v_prev; /* 2nd previous sequence. */ \
1261  struct node_type* v_next /* 2nd next sequence. */
1262 
1263 /*
1264  Read/Write sequence.
1265  Elements can be dynamically inserted to or deleted from the sequence.
1266 */
1267 #define VS_SEQUENCE_FIELDS() \
1268  VS_TREE_NODE_FIELDS(VsSeq); \
1269  int total; /* Total number of elements. */ \
1270  int elem_size; /* Size of sequence element in bytes. */ \
1271  schar* block_max; /* Maximal bound of the last block. */ \
1272  schar* ptr; /* Current write pointer. */ \
1273  int delta_elems; /* Grow seq this many at a time. */ \
1274  VsMemStorage* storage; /* Where the seq is stored. */ \
1275  VsSeqBlock* free_blocks; /* Free blocks list. */ \
1276  VsSeqBlock* first; /* Pointer to the first sequence block. */
1277 
1278 #define VS_TYPE_NAME_SEQ "vs-sequence"
1279 #define VS_TYPE_NAME_SEQ_TREE "vs-sequence-tree"
1280 
1281 /*************************************** Set ********************************************/
1282 /*
1283  Set.
1284  Order is not preserved. There can be gaps between sequence elements.
1285  After the element has been inserted it stays in the same place all the time.
1286  The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.
1287 */
1288 #define VS_SET_ELEM_FIELDS(elem_type) \
1289  int flags; \
1290  struct elem_type* next_free;
1291 
1292 typedef struct VsSetElem
1293 {
1294  VS_SET_ELEM_FIELDS(VsSetElem)
1295 }
1296 VsSetElem;
1297 
1298 #define VS_SET_FIELDS() \
1299  VS_SEQUENCE_FIELDS() \
1300  VsSetElem* free_elems; \
1301  int active_count;
1302 
1303 typedef struct VsSet
1304 {
1305  VS_SET_FIELDS()
1306 }
1307 VsSet;
1308 
1309 
1310 #define VS_SET_ELEM_IDX_MASK ((1 << 26) - 1)
1311 #define VS_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))
1312 
1313 /* Checks whether the element pointed by ptr belongs to a set or not */
1314 #define VS_IS_SET_ELEM( ptr ) (((VsSetElem*)(ptr))->flags >= 0)
1315 
1316 /****************************************************************************************\
1317 * Sequence types *
1318 \****************************************************************************************/
1319 
1320 #define VS_SET_MAGIC_VAL 0x42980000
1321 #define VS_IS_SET(set) \
1322  ((set) != NULL && (((VsSeq*)(set))->flags & VS_MAGIC_MASK) == VS_SET_MAGIC_VAL)
1323 
1324 /****************************************************************************************\
1325 * Data structures for persistence (a.k.a serialization) functionality *
1326 \****************************************************************************************/
1327 
1328 
1329 #define VS_NODE_NONE 0
1330 #define VS_NODE_INT 1
1331 #define VS_NODE_INTEGER VS_NODE_INT
1332 #define VS_NODE_REAL 2
1333 #define VS_NODE_FLOAT VS_NODE_REAL
1334 #define VS_NODE_STR 3
1335 #define VS_NODE_STRING VS_NODE_STR
1336 #define VS_NODE_REF 4 /* not used */
1337 #define VS_NODE_SEQ 5
1338 #define VS_NODE_MAP 6
1339 #define VS_NODE_TYPE_MASK 7
1340 
1341 #define VS_NODE_TYPE(flags) ((flags) & VS_NODE_TYPE_MASK)
1342 
1343 /* file node flags */
1344 #define VS_NODE_FLOW 8 /* Used only for writing structures in YAML format. */
1345 #define VS_NODE_USER 16
1346 #define VS_NODE_EMPTY 32
1347 #define VS_NODE_NAMED 64
1348 
1349 #define VS_NODE_IS_INT(flags) (VS_NODE_TYPE(flags) == VS_NODE_INT)
1350 #define VS_NODE_IS_REAL(flags) (VS_NODE_TYPE(flags) == VS_NODE_REAL)
1351 #define VS_NODE_IS_STRING(flags) (VS_NODE_TYPE(flags) == VS_NODE_STRING)
1352 #define VS_NODE_IS_SEQ(flags) (VS_NODE_TYPE(flags) == VS_NODE_SEQ)
1353 #define VS_NODE_IS_MAP(flags) (VS_NODE_TYPE(flags) == VS_NODE_MAP)
1354 #define VS_NODE_IS_COLLECTION(flags) (VS_NODE_TYPE(flags) >= VS_NODE_SEQ)
1355 #define VS_NODE_IS_FLOW(flags) (((flags) & VS_NODE_FLOW) != 0)
1356 #define VS_NODE_IS_EMPTY(flags) (((flags) & VS_NODE_EMPTY) != 0)
1357 #define VS_NODE_IS_USER(flags) (((flags) & VS_NODE_USER) != 0)
1358 #define VS_NODE_HAS_NAME(flags) (((flags) & VS_NODE_NAMED) != 0)
1359 
1360 #define VS_NODE_SEQ_SIMPLE 256
1361 #define VS_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & VS_NODE_SEQ_SIMPLE) != 0)
1362 
1363 typedef struct VsString
1364 {
1365  int len;
1366  char* ptr;
1367 }
1368 VsString;
1369 
1370 #endif /*__VS_CORE_TYPES_H__*/
1371 
1372 /* End of file. */
_VsImage::height
int height
Image height in pixels.
Definition: vs_core_types_c.h:477
_VsImage::BorderConst
int BorderConst[4]
Ignored by OpenCV.
Definition: vs_core_types_c.h:488
_VsImage::alphaChannel
int alphaChannel
Ignored by OpenCV.
Definition: vs_core_types_c.h:465
_VsImage::width
int width
Image width in pixels.
Definition: vs_core_types_c.h:476
_VsImage::imageId
void * imageId
Must be NULL.
Definition: vs_core_types_c.h:480
_VsImage::BorderMode
int BorderMode[4]
Ignored by OpenCV.
Definition: vs_core_types_c.h:487
_VsImage::colorModel
char colorModel[4]
Ignored by OpenCV.
Definition: vs_core_types_c.h:468
_VsImage::origin
int origin
0 - top-left origin, 1 - bottom-left origin (Windows bitmaps style).
Definition: vs_core_types_c.h:472
_VsImage::dataOrder
int dataOrder
0 - interleaved color channels, 1 - separate color channels.
Definition: vs_core_types_c.h:470
_VsImage::roi
struct _VsROI * roi
Image ROI.
Definition: vs_core_types_c.h:478
_VsImage::align
int align
Alignment of image rows (4 or 8).
Definition: vs_core_types_c.h:474
_VsImage::ID
int ID
version (=0)
Definition: vs_core_types_c.h:463
_VsImage::widthStep
int widthStep
Size of aligned image row in bytes.
Definition: vs_core_types_c.h:486
_VsImage
Image store container.
Definition: vs_core_types_c.h:460
_VsImage::channelSeq
char channelSeq[4]
Ignored by OpenCV.
Definition: vs_core_types_c.h:469
_VsImage::depth
int depth
Pixel depth in bits: VS_DEPTH_8U, VS_DEPTH_8S, VS_DEPTH_16S, VS_DEPTH_32S, VS_DEPTH_32F and VS_DEPTH_...
Definition: vs_core_types_c.h:466
_VsImage::imageData
char * imageData
Pointer to aligned image data.
Definition: vs_core_types_c.h:485
_VsImage::imageDataOrigin
char * imageDataOrigin
Pointer to very origin of image data (not necessarily aligned) - needed for correct deallocation.
Definition: vs_core_types_c.h:489
_VsImage::imageSize
int imageSize
Image data size in bytes (==image->height*image->widthStep in case of interleaved data)
Definition: vs_core_types_c.h:482
_VsImage::nSize
int nSize
sizeof(VsImage)
Definition: vs_core_types_c.h:462
_VsImage::nChannels
int nChannels
Most of OpenCV functions support 1,2,3 or 4 channels.
Definition: vs_core_types_c.h:464
_VsImage::tileInfo
struct _VsTileInfo * tileInfo
Must be NULL.
Definition: vs_core_types_c.h:481
_VsImage::maskROI
struct _VsImage * maskROI
Must be NULL.
Definition: vs_core_types_c.h:479