-/*M///////////////////////////////////////////////////////////////////////////////////////\r
-//\r
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
-//\r
-// By downloading, copying, installing or using the software you agree to this license.\r
-// If you do not agree to this license, do not download, install,\r
-// copy or use the software.\r
-//\r
-//\r
-// License Agreement\r
-// For Open Source Computer Vision Library\r
-//\r
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.\r
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.\r
-// Third party copyrights are property of their respective owners.\r
-//\r
-// Redistribution and use in source and binary forms, with or without modification,\r
-// are permitted provided that the following conditions are met:\r
-//\r
-// * Redistribution's of source code must retain the above copyright notice,\r
-// this list of conditions and the following disclaimer.\r
-//\r
-// * Redistribution's in binary form must reproduce the above copyright notice,\r
-// this list of conditions and the following disclaimer in the documentation\r
-// and/or other materials provided with the distribution.\r
-//\r
-// * The name of the copyright holders may not be used to endorse or promote products\r
-// derived from this software without specific prior written permission.\r
-//\r
-// This software is provided by the copyright holders and contributors "as is" and\r
-// any express or implied warranties, including, but not limited to, the implied\r
-// warranties of merchantability and fitness for a particular purpose are disclaimed.\r
-// In no event shall the Intel Corporation or contributors be liable for any direct,\r
-// indirect, incidental, special, exemplary, or consequential damages\r
-// (including, but not limited to, procurement of substitute goods or services;\r
-// loss of use, data, or profits; or business interruption) however caused\r
-// and on any theory of liability, whether in contract, strict liability,\r
-// or tort (including negligence or otherwise) arising in any way out of\r
-// the use of this software, even if advised of the possibility of such damage.\r
-//\r
-//M*/\r
-\r
-#ifndef _CXCORE_TYPES_H_\r
-#define _CXCORE_TYPES_H_\r
-\r
-#if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300\r
-#define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */\r
-#endif\r
-\r
-#ifndef SKIP_INCLUDES\r
- #include <assert.h>\r
- #include <stdlib.h>\r
- #include <string.h>\r
- #include <float.h>\r
-\r
- #if defined __ICL\r
- #define CV_ICC __ICL\r
- #elif defined __ICC\r
- #define CV_ICC __ICC\r
- #elif defined __ECL\r
- #define CV_ICC __ECL\r
- #elif defined __ECC\r
- #define CV_ICC __ECC\r
- #endif\r
-\r
- #if ((defined WIN32 || defined _WIN64) && \\r
- (_MSC_VER >= 1400 || defined CV_ICC)) \\r
- || (defined __SSE2__ && defined __GNUC__ && __GNUC__ >= 4)\r
- #include <emmintrin.h>\r
- #define CV_SSE2 1\r
- #else\r
- #define CV_SSE2 0\r
- #endif\r
-\r
- #if ((defined __SSE__ || defined __MMX__) && defined __GNUC__ && __GNUC__ >= 3)\r
- #include <mmintrin.h>\r
- #endif\r
-\r
- #if defined __BORLANDC__\r
- #include <fastmath.h>\r
- #else\r
- #include <math.h>\r
- #endif\r
-\r
- #ifdef HAVE_IPL\r
- #ifndef __IPL_H__\r
- #if defined WIN32 || defined WIN64\r
- #include <ipl.h>\r
- #else\r
- #include <ipl/ipl.h>\r
- #endif\r
- #endif\r
- #elif defined __IPL_H__\r
- #define HAVE_IPL\r
- #endif\r
-#endif // SKIP_INCLUDES\r
-\r
-#if defined WIN32 || defined WIN64 || defined _WIN64\r
- #define CV_CDECL __cdecl\r
- #define CV_STDCALL __stdcall\r
-#else\r
- #define CV_CDECL\r
- #define CV_STDCALL\r
-#endif\r
-\r
-#ifndef CV_EXTERN_C\r
- #ifdef __cplusplus\r
- #define CV_EXTERN_C extern "C"\r
- #define CV_DEFAULT(val) = val\r
- #else\r
- #define CV_EXTERN_C\r
- #define CV_DEFAULT(val)\r
- #endif\r
-#endif\r
-\r
-#ifndef CV_EXTERN_C_FUNCPTR\r
- #ifdef __cplusplus\r
- #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }\r
- #else\r
- #define CV_EXTERN_C_FUNCPTR(x) typedef x\r
- #endif\r
-#endif\r
-\r
-#ifndef CV_INLINE\r
-#if defined __cplusplus\r
- #define CV_INLINE inline\r
-#elif (defined WIN32 || defined WIN64 || defined _WIN64 || defined WINCE) && !defined __GNUC__\r
- #define CV_INLINE __inline\r
-#else\r
- #define CV_INLINE static\r
-#endif\r
-#endif /* CV_INLINE */\r
-\r
-#if (defined WIN32 || defined WIN64 || defined _WIN64 || defined WINCE) && defined CVAPI_EXPORTS\r
- #define CV_EXPORTS __declspec(dllexport)\r
-#else\r
- #define CV_EXPORTS\r
-#endif\r
-\r
-#ifndef CVAPI\r
- #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL\r
-#endif\r
-\r
-#if defined _MSC_VER || defined __BORLANDC__\r
-typedef __int64 int64;\r
-typedef unsigned __int64 uint64;\r
-#else\r
-typedef long long int64;\r
-typedef unsigned long long uint64;\r
-#endif\r
-\r
-#ifndef HAVE_IPL\r
-typedef unsigned char uchar;\r
-typedef unsigned short ushort;\r
-#endif\r
-\r
-typedef signed char schar;\r
-\r
-/* CvArr* is used to pass arbitrary\r
- * array-like data structures\r
- * into functions where the particular\r
- * array type is recognized at runtime:\r
- */\r
-typedef void CvArr;\r
-\r
-typedef union Cv32suf\r
-{\r
- int i;\r
- unsigned u;\r
- float f;\r
-}\r
-Cv32suf;\r
-\r
-typedef union Cv64suf\r
-{\r
- int64 i;\r
- uint64 u;\r
- double f;\r
-}\r
-Cv64suf;\r
-\r
-/****************************************************************************************\\r
-* Common macros and inline functions *\r
-\****************************************************************************************/\r
-\r
-#define CV_PI 3.1415926535897932384626433832795\r
-#define CV_LOG2 0.69314718055994530941723212145818\r
-\r
-#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))\r
-\r
-#ifndef MIN\r
-#define MIN(a,b) ((a) > (b) ? (b) : (a))\r
-#endif\r
-\r
-#ifndef MAX\r
-#define MAX(a,b) ((a) < (b) ? (b) : (a))\r
-#endif\r
-\r
-/* min & max without jumps */\r
-#define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))\r
-\r
-#define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))\r
-\r
-/* absolute value without jumps */\r
-#ifndef __cplusplus\r
-#define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))\r
-#else\r
-#define CV_IABS(a) abs(a)\r
-#endif\r
-#define CV_CMP(a,b) (((a) > (b)) - ((a) < (b)))\r
-#define CV_SIGN(a) CV_CMP((a),0)\r
-\r
-CV_INLINE int cvRound( double value )\r
-{\r
-#if CV_SSE2\r
- __m128d t = _mm_load_sd( &value );\r
- return _mm_cvtsd_si32(t);\r
-#elif defined WIN32 && !defined WIN64 && !defined _WIN64 && defined _MSC_VER\r
- int t;\r
- __asm\r
- {\r
- fld value;\r
- fistp t;\r
- }\r
- return t;\r
-#elif (defined HAVE_LRINT) || defined CV_ICC\r
- return (int)lrint(value);\r
-#else\r
- /*\r
- the algorithm was taken from Agner Fog's optimization guide\r
- at http://www.agner.org/assem\r
- */\r
- Cv64suf temp;\r
- temp.f = value + 6755399441055744.0;\r
- return (int)temp.u;\r
-#endif\r
-}\r
-\r
-\r
-CV_INLINE int cvFloor( double value )\r
-{\r
-#if CV_SSE2\r
- __m128d t = _mm_load_sd( &value );\r
- int i = _mm_cvtsd_si32(t);\r
- return i - _mm_movemask_pd(_mm_cmplt_sd(t,_mm_cvtsi32_sd(t,i)));\r
-#else\r
- int temp = cvRound(value);\r
- Cv32suf diff;\r
- diff.f = (float)(value - temp);\r
- return temp - (diff.i < 0);\r
-#endif\r
-}\r
-\r
-\r
-CV_INLINE int cvCeil( double value )\r
-{\r
-#if CV_SSE2\r
- __m128d t = _mm_load_sd( &value );\r
- int i = _mm_cvtsd_si32(t);\r
- return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i),t));\r
-#else\r
- int temp = cvRound(value);\r
- Cv32suf diff;\r
- diff.f = (float)(temp - value);\r
- return temp + (diff.i < 0);\r
-#endif\r
-}\r
-\r
-#define cvInvSqrt(value) ((float)(1./sqrt(value)))\r
-#define cvSqrt(value) ((float)sqrt(value))\r
-\r
-CV_INLINE int cvIsNaN( double value )\r
-{\r
-#if 1/*defined _MSC_VER || defined __BORLANDC__\r
- return _isnan(value);\r
-#elif defined __GNUC__\r
- return isnan(value);\r
-#else*/\r
- Cv64suf ieee754;\r
- ieee754.f = value;\r
- return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +\r
- ((unsigned)ieee754.u != 0) > 0x7ff00000;\r
-#endif\r
-}\r
-\r
-\r
-CV_INLINE int cvIsInf( double value )\r
-{\r
-#if 1/*defined _MSC_VER || defined __BORLANDC__\r
- return !_finite(value);\r
-#elif defined __GNUC__\r
- return isinf(value);\r
-#else*/\r
- Cv64suf ieee754;\r
- ieee754.f = value;\r
- return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&\r
- (unsigned)ieee754.u == 0;\r
-#endif\r
-}\r
-\r
-\r
-/*************** Random number generation *******************/\r
-\r
-typedef uint64 CvRNG;\r
-\r
-CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))\r
-{\r
- CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;\r
- return rng;\r
-}\r
-\r
-/* Return random 32-bit unsigned integer: */\r
-CV_INLINE unsigned cvRandInt( CvRNG* rng )\r
-{\r
- uint64 temp = *rng;\r
- temp = (uint64)(unsigned)temp*4164903690U + (temp >> 32);\r
- *rng = temp;\r
- return (unsigned)temp;\r
-}\r
-\r
-/* Returns random floating-point number between 0 and 1: */\r
-CV_INLINE double cvRandReal( CvRNG* rng )\r
-{\r
- return cvRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */;\r
-}\r
-\r
-/****************************************************************************************\\r
-* Image type (IplImage) *\r
-\****************************************************************************************/\r
-\r
-#ifndef HAVE_IPL\r
-\r
-/*\r
- * The following definitions (until #endif)\r
- * is an extract from IPL headers.\r
- * Copyright (c) 1995 Intel Corporation.\r
- */\r
-#define IPL_DEPTH_SIGN 0x80000000\r
-\r
-#define IPL_DEPTH_1U 1\r
-#define IPL_DEPTH_8U 8\r
-#define IPL_DEPTH_16U 16\r
-#define IPL_DEPTH_32F 32\r
-\r
-#define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)\r
-#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)\r
-#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)\r
-\r
-#define IPL_DATA_ORDER_PIXEL 0\r
-#define IPL_DATA_ORDER_PLANE 1\r
-\r
-#define IPL_ORIGIN_TL 0\r
-#define IPL_ORIGIN_BL 1\r
-\r
-#define IPL_ALIGN_4BYTES 4\r
-#define IPL_ALIGN_8BYTES 8\r
-#define IPL_ALIGN_16BYTES 16\r
-#define IPL_ALIGN_32BYTES 32\r
-\r
-#define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES\r
-#define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES\r
-\r
-#define IPL_BORDER_CONSTANT 0\r
-#define IPL_BORDER_REPLICATE 1\r
-#define IPL_BORDER_REFLECT 2\r
-#define IPL_BORDER_WRAP 3\r
-\r
-typedef struct _IplImage\r
-{\r
- int nSize; /* sizeof(IplImage) */\r
- int ID; /* version (=0)*/\r
- int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */\r
- int alphaChannel; /* Ignored by OpenCV */\r
- int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,\r
- IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */\r
- char colorModel[4]; /* Ignored by OpenCV */\r
- char channelSeq[4]; /* ditto */\r
- int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels.\r
- cvCreateImage can only create interleaved images */\r
- int origin; /* 0 - top-left origin,\r
- 1 - bottom-left origin (Windows bitmaps style). */\r
- int align; /* Alignment of image rows (4 or 8).\r
- OpenCV ignores it and uses widthStep instead. */\r
- int width; /* Image width in pixels. */\r
- int height; /* Image height in pixels. */\r
- struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */\r
- struct _IplImage *maskROI; /* Must be NULL. */\r
- void *imageId; /* " " */\r
- struct _IplTileInfo *tileInfo; /* " " */\r
- int imageSize; /* Image data size in bytes\r
- (==image->height*image->widthStep\r
- in case of interleaved data)*/\r
- char *imageData; /* Pointer to aligned image data. */\r
- int widthStep; /* Size of aligned image row in bytes. */\r
- int BorderMode[4]; /* Ignored by OpenCV. */\r
- int BorderConst[4]; /* Ditto. */\r
- char *imageDataOrigin; /* Pointer to very origin of image data\r
- (not necessarily aligned) -\r
- needed for correct deallocation */\r
-}\r
-IplImage;\r
-\r
-typedef struct _IplTileInfo IplTileInfo;\r
-\r
-typedef struct _IplROI\r
-{\r
- int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/\r
- int xOffset;\r
- int yOffset;\r
- int width;\r
- int height;\r
-}\r
-IplROI;\r
-\r
-typedef struct _IplConvKernel\r
-{\r
- int nCols;\r
- int nRows;\r
- int anchorX;\r
- int anchorY;\r
- int *values;\r
- int nShiftR;\r
-}\r
-IplConvKernel;\r
-\r
-typedef struct _IplConvKernelFP\r
-{\r
- int nCols;\r
- int nRows;\r
- int anchorX;\r
- int anchorY;\r
- float *values;\r
-}\r
-IplConvKernelFP;\r
-\r
-#define IPL_IMAGE_HEADER 1\r
-#define IPL_IMAGE_DATA 2\r
-#define IPL_IMAGE_ROI 4\r
-\r
-#endif/*HAVE_IPL*/\r
-\r
-/* extra border mode */\r
-#define IPL_BORDER_REFLECT_101 4\r
-\r
-#define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))\r
-#define CV_TYPE_NAME_IMAGE "opencv-image"\r
-\r
-#define CV_IS_IMAGE_HDR(img) \\r
- ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))\r
-\r
-#define CV_IS_IMAGE(img) \\r
- (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)\r
-\r
-/* for storing double-precision\r
- floating point data in IplImage's */\r
-#define IPL_DEPTH_64F 64\r
-\r
-/* get reference to pixel at (col,row),\r
- for multi-channel images (col) should be multiplied by number of channels */\r
-#define CV_IMAGE_ELEM( image, elemtype, row, col ) \\r
- (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])\r
-\r
-/****************************************************************************************\\r
-* Matrix type (CvMat) *\r
-\****************************************************************************************/\r
-\r
-#define CV_CN_MAX 64\r
-#define CV_CN_SHIFT 3\r
-#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)\r
-\r
-#define CV_8U 0\r
-#define CV_8S 1\r
-#define CV_16U 2\r
-#define CV_16S 3\r
-#define CV_32S 4\r
-#define CV_32F 5\r
-#define CV_64F 6\r
-#define CV_USRTYPE1 7\r
-\r
-#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))\r
-#define CV_MAKE_TYPE CV_MAKETYPE\r
-\r
-#define CV_8UC1 CV_MAKETYPE(CV_8U,1)\r
-#define CV_8UC2 CV_MAKETYPE(CV_8U,2)\r
-#define CV_8UC3 CV_MAKETYPE(CV_8U,3)\r
-#define CV_8UC4 CV_MAKETYPE(CV_8U,4)\r
-#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))\r
-\r
-#define CV_8SC1 CV_MAKETYPE(CV_8S,1)\r
-#define CV_8SC2 CV_MAKETYPE(CV_8S,2)\r
-#define CV_8SC3 CV_MAKETYPE(CV_8S,3)\r
-#define CV_8SC4 CV_MAKETYPE(CV_8S,4)\r
-#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))\r
-\r
-#define CV_16UC1 CV_MAKETYPE(CV_16U,1)\r
-#define CV_16UC2 CV_MAKETYPE(CV_16U,2)\r
-#define CV_16UC3 CV_MAKETYPE(CV_16U,3)\r
-#define CV_16UC4 CV_MAKETYPE(CV_16U,4)\r
-#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))\r
-\r
-#define CV_16SC1 CV_MAKETYPE(CV_16S,1)\r
-#define CV_16SC2 CV_MAKETYPE(CV_16S,2)\r
-#define CV_16SC3 CV_MAKETYPE(CV_16S,3)\r
-#define CV_16SC4 CV_MAKETYPE(CV_16S,4)\r
-#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))\r
-\r
-#define CV_32SC1 CV_MAKETYPE(CV_32S,1)\r
-#define CV_32SC2 CV_MAKETYPE(CV_32S,2)\r
-#define CV_32SC3 CV_MAKETYPE(CV_32S,3)\r
-#define CV_32SC4 CV_MAKETYPE(CV_32S,4)\r
-#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))\r
-\r
-#define CV_32FC1 CV_MAKETYPE(CV_32F,1)\r
-#define CV_32FC2 CV_MAKETYPE(CV_32F,2)\r
-#define CV_32FC3 CV_MAKETYPE(CV_32F,3)\r
-#define CV_32FC4 CV_MAKETYPE(CV_32F,4)\r
-#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))\r
-\r
-#define CV_64FC1 CV_MAKETYPE(CV_64F,1)\r
-#define CV_64FC2 CV_MAKETYPE(CV_64F,2)\r
-#define CV_64FC3 CV_MAKETYPE(CV_64F,3)\r
-#define CV_64FC4 CV_MAKETYPE(CV_64F,4)\r
-#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))\r
-\r
-#define CV_AUTO_STEP 0x7fffffff\r
-#define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )\r
-\r
-#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)\r
-#define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)\r
-#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)\r
-#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)\r
-#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)\r
-#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK)\r
-#define CV_MAT_CONT_FLAG_SHIFT 14\r
-#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)\r
-#define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG)\r
-#define CV_IS_CONT_MAT CV_IS_MAT_CONT\r
-#define CV_MAT_TEMP_FLAG_SHIFT 15\r
-#define CV_MAT_TEMP_FLAG (1 << CV_MAT_TEMP_FLAG_SHIFT)\r
-#define CV_IS_TEMP_MAT(flags) ((flags) & CV_MAT_TEMP_FLAG)\r
-\r
-#define CV_MAGIC_MASK 0xFFFF0000\r
-#define CV_MAT_MAGIC_VAL 0x42420000\r
-#define CV_TYPE_NAME_MAT "opencv-matrix"\r
-\r
-typedef struct CvMat\r
-{\r
- int type;\r
- int step;\r
-\r
- /* for internal use only */\r
- int* refcount;\r
- int hdr_refcount;\r
-\r
- union\r
- {\r
- uchar* ptr;\r
- short* s;\r
- int* i;\r
- float* fl;\r
- double* db;\r
- } data;\r
-\r
-#ifdef __cplusplus\r
- union\r
- {\r
- int rows;\r
- int height;\r
- };\r
-\r
- union\r
- {\r
- int cols;\r
- int width;\r
- };\r
-#else\r
- int rows;\r
- int cols;\r
-#endif\r
-\r
-}\r
-CvMat;\r
-\r
-\r
-#define CV_IS_MAT_HDR(mat) \\r
- ((mat) != NULL && \\r
- (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \\r
- ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)\r
-\r
-#define CV_IS_MAT(mat) \\r
- (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL)\r
-\r
-#define CV_IS_MASK_ARR(mat) \\r
- (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)\r
-\r
-#define CV_ARE_TYPES_EQ(mat1, mat2) \\r
- ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)\r
-\r
-#define CV_ARE_CNS_EQ(mat1, mat2) \\r
- ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)\r
-\r
-#define CV_ARE_DEPTHS_EQ(mat1, mat2) \\r
- ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)\r
-\r
-#define CV_ARE_SIZES_EQ(mat1, mat2) \\r
- ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)\r
-\r
-#define CV_IS_MAT_CONST(mat) \\r
- (((mat)->rows|(mat)->cols) == 1)\r
-\r
-/* Size of each channel item,\r
- 0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */\r
-#define CV_ELEM_SIZE1(type) \\r
- ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)\r
-\r
-/* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */\r
-#define CV_ELEM_SIZE(type) \\r
- (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))\r
-\r
-/* Inline constructor. No data is allocated internally!!!\r
- * (Use together with cvCreateData, or use cvCreateMat instead to\r
- * get a matrix with allocated data):\r
- */\r
-CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL))\r
-{\r
- CvMat m;\r
-\r
- assert( (unsigned)CV_MAT_DEPTH(type) <= CV_64F );\r
- type = CV_MAT_TYPE(type);\r
- m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type;\r
- m.cols = cols;\r
- m.rows = rows;\r
- m.step = m.cols*CV_ELEM_SIZE(type);\r
- m.data.ptr = (uchar*)data;\r
- m.refcount = NULL;\r
- m.hdr_refcount = 0;\r
-\r
- return m;\r
-}\r
-\r
-\r
-#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \\r
- (assert( (unsigned)(row) < (unsigned)(mat).rows && \\r
- (unsigned)(col) < (unsigned)(mat).cols ), \\r
- (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))\r
-\r
-#define CV_MAT_ELEM_PTR( mat, row, col ) \\r
- CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )\r
-\r
-#define CV_MAT_ELEM( mat, elemtype, row, col ) \\r
- (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))\r
-\r
-\r
-CV_INLINE double cvmGet( const CvMat* mat, int row, int col )\r
-{\r
- int type;\r
-\r
- type = CV_MAT_TYPE(mat->type);\r
- assert( (unsigned)row < (unsigned)mat->rows &&\r
- (unsigned)col < (unsigned)mat->cols );\r
-\r
- if( type == CV_32FC1 )\r
- return ((float*)(mat->data.ptr + (size_t)mat->step*row))[col];\r
- else\r
- {\r
- assert( type == CV_64FC1 );\r
- return ((double*)(mat->data.ptr + (size_t)mat->step*row))[col];\r
- }\r
-}\r
-\r
-\r
-CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value )\r
-{\r
- int type;\r
- type = CV_MAT_TYPE(mat->type);\r
- assert( (unsigned)row < (unsigned)mat->rows &&\r
- (unsigned)col < (unsigned)mat->cols );\r
-\r
- if( type == CV_32FC1 )\r
- ((float*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;\r
- else\r
- {\r
- assert( type == CV_64FC1 );\r
- ((double*)(mat->data.ptr + (size_t)mat->step*row))[col] = (double)value;\r
- }\r
-}\r
-\r
-\r
-CV_INLINE int cvIplDepth( int type )\r
-{\r
- int depth = CV_MAT_DEPTH(type);\r
- return CV_ELEM_SIZE1(depth)*8 | (depth == CV_8S || depth == CV_16S ||\r
- depth == CV_32S ? IPL_DEPTH_SIGN : 0);\r
-}\r
-\r
-\r
-/****************************************************************************************\\r
-* Multi-dimensional dense array (CvMatND) *\r
-\****************************************************************************************/\r
-\r
-#define CV_MATND_MAGIC_VAL 0x42430000\r
-#define CV_TYPE_NAME_MATND "opencv-nd-matrix"\r
-\r
-#define CV_MAX_DIM 32\r
-#define CV_MAX_DIM_HEAP (1 << 16)\r
-\r
-typedef struct CvMatND\r
-{\r
- int type;\r
- int dims;\r
-\r
- int* refcount;\r
- int hdr_refcount;\r
-\r
- union\r
- {\r
- uchar* ptr;\r
- float* fl;\r
- double* db;\r
- int* i;\r
- short* s;\r
- } data;\r
-\r
- struct\r
- {\r
- int size;\r
- int step;\r
- }\r
- dim[CV_MAX_DIM];\r
-}\r
-CvMatND;\r
-\r
-#define CV_IS_MATND_HDR(mat) \\r
- ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)\r
-\r
-#define CV_IS_MATND(mat) \\r
- (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)\r
-\r
-\r
-/****************************************************************************************\\r
-* Multi-dimensional sparse array (CvSparseMat) *\r
-\****************************************************************************************/\r
-\r
-#define CV_SPARSE_MAT_MAGIC_VAL 0x42440000\r
-#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"\r
-\r
-struct CvSet;\r
-\r
-typedef struct CvSparseMat\r
-{\r
- int type;\r
- int dims;\r
- int* refcount;\r
- int hdr_refcount;\r
-\r
- struct CvSet* heap;\r
- void** hashtable;\r
- int hashsize;\r
- int valoffset;\r
- int idxoffset;\r
- int size[CV_MAX_DIM];\r
-}\r
-CvSparseMat;\r
-\r
-#define CV_IS_SPARSE_MAT_HDR(mat) \\r
- ((mat) != NULL && \\r
- (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)\r
-\r
-#define CV_IS_SPARSE_MAT(mat) \\r
- CV_IS_SPARSE_MAT_HDR(mat)\r
-\r
-/**************** iteration through a sparse array *****************/\r
-\r
-typedef struct CvSparseNode\r
-{\r
- unsigned hashval;\r
- struct CvSparseNode* next;\r
-}\r
-CvSparseNode;\r
-\r
-typedef struct CvSparseMatIterator\r
-{\r
- CvSparseMat* mat;\r
- CvSparseNode* node;\r
- int curidx;\r
-}\r
-CvSparseMatIterator;\r
-\r
-#define CV_NODE_VAL(mat,node) ((void*)((uchar*)(node) + (mat)->valoffset))\r
-#define CV_NODE_IDX(mat,node) ((int*)((uchar*)(node) + (mat)->idxoffset))\r
-\r
-/****************************************************************************************\\r
-* Histogram *\r
-\****************************************************************************************/\r
-\r
-typedef int CvHistType;\r
-\r
-#define CV_HIST_MAGIC_VAL 0x42450000\r
-#define CV_HIST_UNIFORM_FLAG (1 << 10)\r
-\r
-/* indicates whether bin ranges are set already or not */\r
-#define CV_HIST_RANGES_FLAG (1 << 11)\r
-\r
-#define CV_HIST_ARRAY 0\r
-#define CV_HIST_SPARSE 1\r
-#define CV_HIST_TREE CV_HIST_SPARSE\r
-\r
-/* should be used as a parameter only,\r
- it turns to CV_HIST_UNIFORM_FLAG of hist->type */\r
-#define CV_HIST_UNIFORM 1\r
-\r
-typedef struct CvHistogram\r
-{\r
- int type;\r
- CvArr* bins;\r
- float thresh[CV_MAX_DIM][2]; /* For uniform histograms. */\r
- float** thresh2; /* For non-uniform histograms. */\r
- CvMatND mat; /* Embedded matrix header for array histograms. */\r
-}\r
-CvHistogram;\r
-\r
-#define CV_IS_HIST( hist ) \\r
- ((hist) != NULL && \\r
- (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \\r
- (hist)->bins != NULL)\r
-\r
-#define CV_IS_UNIFORM_HIST( hist ) \\r
- (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)\r
-\r
-#define CV_IS_SPARSE_HIST( hist ) \\r
- CV_IS_SPARSE_MAT((hist)->bins)\r
-\r
-#define CV_HIST_HAS_RANGES( hist ) \\r
- (((hist)->type & CV_HIST_RANGES_FLAG) != 0)\r
-\r
-/****************************************************************************************\\r
-* Other supplementary data type definitions *\r
-\****************************************************************************************/\r
-\r
-/*************************************** CvRect *****************************************/\r
-\r
-typedef struct CvRect\r
-{\r
- int x;\r
- int y;\r
- int width;\r
- int height;\r
-}\r
-CvRect;\r
-\r
-CV_INLINE CvRect cvRect( int x, int y, int width, int height )\r
-{\r
- CvRect r;\r
-\r
- r.x = x;\r
- r.y = y;\r
- r.width = width;\r
- r.height = height;\r
-\r
- return r;\r
-}\r
-\r
-\r
-CV_INLINE IplROI cvRectToROI( CvRect rect, int coi )\r
-{\r
- IplROI roi;\r
- roi.xOffset = rect.x;\r
- roi.yOffset = rect.y;\r
- roi.width = rect.width;\r
- roi.height = rect.height;\r
- roi.coi = coi;\r
-\r
- return roi;\r
-}\r
-\r
-\r
-CV_INLINE CvRect cvROIToRect( IplROI roi )\r
-{\r
- return cvRect( roi.xOffset, roi.yOffset, roi.width, roi.height );\r
-}\r
-\r
-/*********************************** CvTermCriteria *************************************/\r
-\r
-#define CV_TERMCRIT_ITER 1\r
-#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER\r
-#define CV_TERMCRIT_EPS 2\r
-\r
-typedef struct CvTermCriteria\r
-{\r
- int type; /* may be combination of\r
- CV_TERMCRIT_ITER\r
- CV_TERMCRIT_EPS */\r
- int max_iter;\r
- double epsilon;\r
-}\r
-CvTermCriteria;\r
-\r
-CV_INLINE CvTermCriteria cvTermCriteria( int type, int max_iter, double epsilon )\r
-{\r
- CvTermCriteria t;\r
-\r
- t.type = type;\r
- t.max_iter = max_iter;\r
- t.epsilon = (float)epsilon;\r
-\r
- return t;\r
-}\r
-\r
-\r
-/******************************* CvPoint and variants ***********************************/\r
-\r
-typedef struct CvPoint\r
-{\r
- int x;\r
- int y;\r
-}\r
-CvPoint;\r
-\r
-\r
-CV_INLINE CvPoint cvPoint( int x, int y )\r
-{\r
- CvPoint p;\r
-\r
- p.x = x;\r
- p.y = y;\r
-\r
- return p;\r
-}\r
-\r
-\r
-typedef struct CvPoint2D32f\r
-{\r
- float x;\r
- float y;\r
-}\r
-CvPoint2D32f;\r
-\r
-\r
-CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y )\r
-{\r
- CvPoint2D32f p;\r
-\r
- p.x = (float)x;\r
- p.y = (float)y;\r
-\r
- return p;\r
-}\r
-\r
-\r
-CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )\r
-{\r
- return cvPoint2D32f( (float)point.x, (float)point.y );\r
-}\r
-\r
-\r
-CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point )\r
-{\r
- CvPoint ipt;\r
- ipt.x = cvRound(point.x);\r
- ipt.y = cvRound(point.y);\r
-\r
- return ipt;\r
-}\r
-\r
-\r
-typedef struct CvPoint3D32f\r
-{\r
- float x;\r
- float y;\r
- float z;\r
-}\r
-CvPoint3D32f;\r
-\r
-\r
-CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z )\r
-{\r
- CvPoint3D32f p;\r
-\r
- p.x = (float)x;\r
- p.y = (float)y;\r
- p.z = (float)z;\r
-\r
- return p;\r
-}\r
-\r
-\r
-typedef struct CvPoint2D64f\r
-{\r
- double x;\r
- double y;\r
-}\r
-CvPoint2D64f;\r
-\r
-\r
-CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y )\r
-{\r
- CvPoint2D64f p;\r
-\r
- p.x = x;\r
- p.y = y;\r
-\r
- return p;\r
-}\r
-\r
-\r
-typedef struct CvPoint3D64f\r
-{\r
- double x;\r
- double y;\r
- double z;\r
-}\r
-CvPoint3D64f;\r
-\r
-\r
-CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z )\r
-{\r
- CvPoint3D64f p;\r
-\r
- p.x = x;\r
- p.y = y;\r
- p.z = z;\r
-\r
- return p;\r
-}\r
-\r
-\r
-/******************************** CvSize's & CvBox **************************************/\r
-\r
-typedef struct\r
-{\r
- int width;\r
- int height;\r
-}\r
-CvSize;\r
-\r
-CV_INLINE CvSize cvSize( int width, int height )\r
-{\r
- CvSize s;\r
-\r
- s.width = width;\r
- s.height = height;\r
-\r
- return s;\r
-}\r
-\r
-typedef struct CvSize2D32f\r
-{\r
- float width;\r
- float height;\r
-}\r
-CvSize2D32f;\r
-\r
-\r
-CV_INLINE CvSize2D32f cvSize2D32f( double width, double height )\r
-{\r
- CvSize2D32f s;\r
-\r
- s.width = (float)width;\r
- s.height = (float)height;\r
-\r
- return s;\r
-}\r
-\r
-typedef struct CvBox2D\r
-{\r
- CvPoint2D32f center; /* Center of the box. */\r
- CvSize2D32f size; /* Box width and length. */\r
- float angle; /* Angle between the horizontal axis */\r
- /* and the first side (i.e. length) in degrees */\r
-}\r
-CvBox2D;\r
-\r
-\r
-/* Line iterator state: */\r
-typedef struct CvLineIterator\r
-{\r
- /* Pointer to the current point: */\r
- uchar* ptr;\r
-\r
- /* Bresenham algorithm state: */\r
- int err;\r
- int plus_delta;\r
- int minus_delta;\r
- int plus_step;\r
- int minus_step;\r
-}\r
-CvLineIterator;\r
-\r
-\r
-\r
-/************************************* CvSlice ******************************************/\r
-\r
-typedef struct CvSlice\r
-{\r
- int start_index, end_index;\r
-}\r
-CvSlice;\r
-\r
-CV_INLINE CvSlice cvSlice( int start, int end )\r
-{\r
- CvSlice slice;\r
- slice.start_index = start;\r
- slice.end_index = end;\r
-\r
- return slice;\r
-}\r
-\r
-#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff\r
-#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)\r
-\r
-\r
-/************************************* CvScalar *****************************************/\r
-\r
-typedef struct CvScalar\r
-{\r
- double val[4];\r
-}\r
-CvScalar;\r
-\r
-CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0),\r
- double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))\r
-{\r
- CvScalar scalar;\r
- scalar.val[0] = val0; scalar.val[1] = val1;\r
- scalar.val[2] = val2; scalar.val[3] = val3;\r
- return scalar;\r
-}\r
-\r
-\r
-CV_INLINE CvScalar cvRealScalar( double val0 )\r
-{\r
- CvScalar scalar;\r
- scalar.val[0] = val0;\r
- scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;\r
- return scalar;\r
-}\r
-\r
-CV_INLINE CvScalar cvScalarAll( double val0123 )\r
-{\r
- CvScalar scalar;\r
- scalar.val[0] = val0123;\r
- scalar.val[1] = val0123;\r
- scalar.val[2] = val0123;\r
- scalar.val[3] = val0123;\r
- return scalar;\r
-}\r
-\r
-/****************************************************************************************\\r
-* Dynamic Data structures *\r
-\****************************************************************************************/\r
-\r
-/******************************** Memory storage ****************************************/\r
-\r
-typedef struct CvMemBlock\r
-{\r
- struct CvMemBlock* prev;\r
- struct CvMemBlock* next;\r
-}\r
-CvMemBlock;\r
-\r
-#define CV_STORAGE_MAGIC_VAL 0x42890000\r
-\r
-typedef struct CvMemStorage\r
-{\r
- int signature;\r
- CvMemBlock* bottom; /* First allocated block. */\r
- CvMemBlock* top; /* Current memory block - top of the stack. */\r
- struct CvMemStorage* parent; /* We get new blocks from parent as needed. */\r
- int block_size; /* Block size. */\r
- int free_space; /* Remaining free space in current block. */\r
-}\r
-CvMemStorage;\r
-\r
-#define CV_IS_STORAGE(storage) \\r
- ((storage) != NULL && \\r
- (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)\r
-\r
-\r
-typedef struct CvMemStoragePos\r
-{\r
- CvMemBlock* top;\r
- int free_space;\r
-}\r
-CvMemStoragePos;\r
-\r
-\r
-/*********************************** Sequence *******************************************/\r
-\r
-typedef struct CvSeqBlock\r
-{\r
- struct CvSeqBlock* prev; /* Previous sequence block. */\r
- struct CvSeqBlock* next; /* Next sequence block. */\r
- int start_index; /* Index of the first element in the block + */\r
- /* sequence->first->start_index. */\r
- int count; /* Number of elements in the block. */\r
- schar* data; /* Pointer to the first element of the block. */\r
-}\r
-CvSeqBlock;\r
-\r
-\r
-#define CV_TREE_NODE_FIELDS(node_type) \\r
- int flags; /* Miscellaneous flags. */ \\r
- int header_size; /* Size of sequence header. */ \\r
- struct node_type* h_prev; /* Previous sequence. */ \\r
- struct node_type* h_next; /* Next sequence. */ \\r
- struct node_type* v_prev; /* 2nd previous sequence. */ \\r
- struct node_type* v_next /* 2nd next sequence. */\r
-\r
-/*\r
- Read/Write sequence.\r
- Elements can be dynamically inserted to or deleted from the sequence.\r
-*/\r
-#define CV_SEQUENCE_FIELDS() \\r
- CV_TREE_NODE_FIELDS(CvSeq); \\r
- int total; /* Total number of elements. */ \\r
- int elem_size; /* Size of sequence element in bytes. */ \\r
- schar* block_max; /* Maximal bound of the last block. */ \\r
- schar* ptr; /* Current write pointer. */ \\r
- int delta_elems; /* Grow seq this many at a time. */ \\r
- CvMemStorage* storage; /* Where the seq is stored. */ \\r
- CvSeqBlock* free_blocks; /* Free blocks list. */ \\r
- CvSeqBlock* first; /* Pointer to the first sequence block. */\r
-\r
-typedef struct CvSeq\r
-{\r
- CV_SEQUENCE_FIELDS()\r
-}\r
-CvSeq;\r
-\r
-#define CV_TYPE_NAME_SEQ "opencv-sequence"\r
-#define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"\r
-\r
-/*************************************** Set ********************************************/\r
-/*\r
- Set.\r
- Order is not preserved. There can be gaps between sequence elements.\r
- After the element has been inserted it stays in the same place all the time.\r
- The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.\r
-*/\r
-#define CV_SET_ELEM_FIELDS(elem_type) \\r
- int flags; \\r
- struct elem_type* next_free;\r
-\r
-typedef struct CvSetElem\r
-{\r
- CV_SET_ELEM_FIELDS(CvSetElem)\r
-}\r
-CvSetElem;\r
-\r
-#define CV_SET_FIELDS() \\r
- CV_SEQUENCE_FIELDS() \\r
- CvSetElem* free_elems; \\r
- int active_count;\r
-\r
-typedef struct CvSet\r
-{\r
- CV_SET_FIELDS()\r
-}\r
-CvSet;\r
-\r
-\r
-#define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)\r
-#define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))\r
-\r
-/* Checks whether the element pointed by ptr belongs to a set or not */\r
-#define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0)\r
-\r
-/************************************* Graph ********************************************/\r
-\r
-/*\r
- We represent a graph as a set of vertices.\r
- Vertices contain their adjacency lists (more exactly, pointers to first incoming or\r
- outcoming edge (or 0 if isolated vertex)). Edges are stored in another set.\r
- There is a singly-linked list of incoming/outcoming edges for each vertex.\r
-\r
- Each edge consists of\r
-\r
- o Two pointers to the starting and ending vertices\r
- (vtx[0] and vtx[1] respectively).\r
-\r
- A graph may be oriented or not. In the latter case, edges between\r
- vertex i to vertex j are not distinguished during search operations.\r
-\r
- o Two pointers to next edges for the starting and ending vertices, where\r
- next[0] points to the next edge in the vtx[0] adjacency list and\r
- next[1] points to the next edge in the vtx[1] adjacency list.\r
-*/\r
-#define CV_GRAPH_EDGE_FIELDS() \\r
- int flags; \\r
- float weight; \\r
- struct CvGraphEdge* next[2]; \\r
- struct CvGraphVtx* vtx[2];\r
-\r
-\r
-#define CV_GRAPH_VERTEX_FIELDS() \\r
- int flags; \\r
- struct CvGraphEdge* first;\r
-\r
-\r
-typedef struct CvGraphEdge\r
-{\r
- CV_GRAPH_EDGE_FIELDS()\r
-}\r
-CvGraphEdge;\r
-\r
-typedef struct CvGraphVtx\r
-{\r
- CV_GRAPH_VERTEX_FIELDS()\r
-}\r
-CvGraphVtx;\r
-\r
-typedef struct CvGraphVtx2D\r
-{\r
- CV_GRAPH_VERTEX_FIELDS()\r
- CvPoint2D32f* ptr;\r
-}\r
-CvGraphVtx2D;\r
-\r
-/*\r
- Graph is "derived" from the set (this is set a of vertices)\r
- and includes another set (edges)\r
-*/\r
-#define CV_GRAPH_FIELDS() \\r
- CV_SET_FIELDS() \\r
- CvSet* edges;\r
-\r
-typedef struct CvGraph\r
-{\r
- CV_GRAPH_FIELDS()\r
-}\r
-CvGraph;\r
-\r
-#define CV_TYPE_NAME_GRAPH "opencv-graph"\r
-\r
-/*********************************** Chain/Countour *************************************/\r
-\r
-typedef struct CvChain\r
-{\r
- CV_SEQUENCE_FIELDS()\r
- CvPoint origin;\r
-}\r
-CvChain;\r
-\r
-#define CV_CONTOUR_FIELDS() \\r
- CV_SEQUENCE_FIELDS() \\r
- CvRect rect; \\r
- int color; \\r
- int reserved[3];\r
-\r
-typedef struct CvContour\r
-{\r
- CV_CONTOUR_FIELDS()\r
-}\r
-CvContour;\r
-\r
-typedef CvContour CvPoint2DSeq;\r
-\r
-/****************************************************************************************\\r
-* Sequence types *\r
-\****************************************************************************************/\r
-\r
-#define CV_SEQ_MAGIC_VAL 0x42990000\r
-\r
-#define CV_IS_SEQ(seq) \\r
- ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)\r
-\r
-#define CV_SET_MAGIC_VAL 0x42980000\r
-#define CV_IS_SET(set) \\r
- ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)\r
-\r
-#define CV_SEQ_ELTYPE_BITS 9\r
-#define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)\r
-\r
-#define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */\r
-#define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */\r
-#define CV_SEQ_ELTYPE_GENERIC 0\r
-#define CV_SEQ_ELTYPE_PTR CV_USRTYPE1\r
-#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */\r
-#define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #(x,y) */\r
-#define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /* &next_o, &next_d, &vtx_o, &vtx_d */\r
-#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /* first_edge, &(x,y) */\r
-#define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */\r
-#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */\r
-#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */\r
-\r
-#define CV_SEQ_KIND_BITS 3\r
-#define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)\r
-\r
-/* types of sequences */\r
-#define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)\r
-#define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)\r
-#define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)\r
-\r
-/* types of sparse sequences (sets) */\r
-#define CV_SEQ_KIND_GRAPH (3 << CV_SEQ_ELTYPE_BITS)\r
-#define CV_SEQ_KIND_SUBDIV2D (4 << CV_SEQ_ELTYPE_BITS)\r
-\r
-#define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)\r
-\r
-/* flags for curves */\r
-#define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)\r
-#define CV_SEQ_FLAG_SIMPLE (2 << CV_SEQ_FLAG_SHIFT)\r
-#define CV_SEQ_FLAG_CONVEX (4 << CV_SEQ_FLAG_SHIFT)\r
-#define CV_SEQ_FLAG_HOLE (8 << CV_SEQ_FLAG_SHIFT)\r
-\r
-/* flags for graphs */\r
-#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)\r
-\r
-#define CV_GRAPH CV_SEQ_KIND_GRAPH\r
-#define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)\r
-\r
-/* point sets */\r
-#define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)\r
-#define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)\r
-#define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)\r
-#define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )\r
-#define CV_SEQ_CONTOUR CV_SEQ_POLYGON\r
-#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )\r
-\r
-/* chain-coded curves */\r
-#define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)\r
-#define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)\r
-\r
-/* binary tree for the contour */\r
-#define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)\r
-\r
-/* sequence of the connected components */\r
-#define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)\r
-\r
-/* sequence of the integer numbers */\r
-#define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)\r
-\r
-#define CV_SEQ_ELTYPE( seq ) ((seq)->flags & CV_SEQ_ELTYPE_MASK)\r
-#define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK )\r
-\r
-/* flag checking */\r
-#define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \\r
- (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))\r
-\r
-#define CV_IS_SEQ_CURVE( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)\r
-#define CV_IS_SEQ_CLOSED( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)\r
-#define CV_IS_SEQ_CONVEX( seq ) (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0)\r
-#define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)\r
-#define CV_IS_SEQ_SIMPLE( seq ) ((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \\r
- CV_IS_SEQ_CONVEX(seq))\r
-\r
-/* type checking macros */\r
-#define CV_IS_SEQ_POINT_SET( seq ) \\r
- ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))\r
-\r
-#define CV_IS_SEQ_POINT_SUBSET( seq ) \\r
- (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)\r
-\r
-#define CV_IS_SEQ_POLYLINE( seq ) \\r
- (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))\r
-\r
-#define CV_IS_SEQ_POLYGON( seq ) \\r
- (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))\r
-\r
-#define CV_IS_SEQ_CHAIN( seq ) \\r
- (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)\r
-\r
-#define CV_IS_SEQ_CONTOUR( seq ) \\r
- (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))\r
-\r
-#define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \\r
- (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))\r
-\r
-#define CV_IS_SEQ_POLYGON_TREE( seq ) \\r
- (CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && \\r
- CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE )\r
-\r
-#define CV_IS_GRAPH( seq ) \\r
- (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)\r
-\r
-#define CV_IS_GRAPH_ORIENTED( seq ) \\r
- (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)\r
-\r
-#define CV_IS_SUBDIV2D( seq ) \\r
- (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)\r
-\r
-/****************************************************************************************/\r
-/* Sequence writer & reader */\r
-/****************************************************************************************/\r
-\r
-#define CV_SEQ_WRITER_FIELDS() \\r
- int header_size; \\r
- CvSeq* seq; /* the sequence written */ \\r
- CvSeqBlock* block; /* current block */ \\r
- schar* ptr; /* pointer to free space */ \\r
- schar* block_min; /* pointer to the beginning of block*/\\r
- schar* block_max; /* pointer to the end of block */\r
-\r
-typedef struct CvSeqWriter\r
-{\r
- CV_SEQ_WRITER_FIELDS()\r
-}\r
-CvSeqWriter;\r
-\r
-\r
-#define CV_SEQ_READER_FIELDS() \\r
- int header_size; \\r
- CvSeq* seq; /* sequence, beign read */ \\r
- CvSeqBlock* block; /* current block */ \\r
- schar* ptr; /* pointer to element be read next */ \\r
- schar* block_min; /* pointer to the beginning of block */\\r
- schar* block_max; /* pointer to the end of block */ \\r
- int delta_index;/* = seq->first->start_index */ \\r
- schar* prev_elem; /* pointer to previous element */\r
-\r
-\r
-typedef struct CvSeqReader\r
-{\r
- CV_SEQ_READER_FIELDS()\r
-}\r
-CvSeqReader;\r
-\r
-/****************************************************************************************/\r
-/* Operations on sequences */\r
-/****************************************************************************************/\r
-\r
-#define CV_SEQ_ELEM( seq, elem_type, index ) \\r
-/* assert gives some guarantee that <seq> parameter is valid */ \\r
-( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && \\r
- (seq)->elem_size == sizeof(elem_type)), \\r
- (elem_type*)((seq)->first && (unsigned)index < \\r
- (unsigned)((seq)->first->count) ? \\r
- (seq)->first->data + (index) * sizeof(elem_type) : \\r
- cvGetSeqElem( (CvSeq*)(seq), (index) )))\r
-#define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) )\r
-\r
-/* Add element to sequence: */\r
-#define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) \\r
-{ \\r
- if( (writer).ptr >= (writer).block_max ) \\r
- { \\r
- cvCreateSeqBlock( &writer); \\r
- } \\r
- memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\\r
- (writer).ptr += (writer).seq->elem_size; \\r
-}\r
-\r
-#define CV_WRITE_SEQ_ELEM( elem, writer ) \\r
-{ \\r
- assert( (writer).seq->elem_size == sizeof(elem)); \\r
- if( (writer).ptr >= (writer).block_max ) \\r
- { \\r
- cvCreateSeqBlock( &writer); \\r
- } \\r
- assert( (writer).ptr <= (writer).block_max - sizeof(elem));\\r
- memcpy((writer).ptr, &(elem), sizeof(elem)); \\r
- (writer).ptr += sizeof(elem); \\r
-}\r
-\r
-\r
-/* Move reader position forward: */\r
-#define CV_NEXT_SEQ_ELEM( elem_size, reader ) \\r
-{ \\r
- if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \\r
- { \\r
- cvChangeSeqBlock( &(reader), 1 ); \\r
- } \\r
-}\r
-\r
-\r
-/* Move reader position backward: */\r
-#define CV_PREV_SEQ_ELEM( elem_size, reader ) \\r
-{ \\r
- if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \\r
- { \\r
- cvChangeSeqBlock( &(reader), -1 ); \\r
- } \\r
-}\r
-\r
-/* Read element and move read position forward: */\r
-#define CV_READ_SEQ_ELEM( elem, reader ) \\r
-{ \\r
- assert( (reader).seq->elem_size == sizeof(elem)); \\r
- memcpy( &(elem), (reader).ptr, sizeof((elem))); \\r
- CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) \\r
-}\r
-\r
-/* Read element and move read position backward: */\r
-#define CV_REV_READ_SEQ_ELEM( elem, reader ) \\r
-{ \\r
- assert( (reader).seq->elem_size == sizeof(elem)); \\r
- memcpy(&(elem), (reader).ptr, sizeof((elem))); \\r
- CV_PREV_SEQ_ELEM( sizeof(elem), reader ) \\r
-}\r
-\r
-\r
-#define CV_READ_CHAIN_POINT( _pt, reader ) \\r
-{ \\r
- (_pt) = (reader).pt; \\r
- if( (reader).ptr ) \\r
- { \\r
- CV_READ_SEQ_ELEM( (reader).code, (reader)); \\r
- assert( ((reader).code & ~7) == 0 ); \\r
- (reader).pt.x += (reader).deltas[(int)(reader).code][0]; \\r
- (reader).pt.y += (reader).deltas[(int)(reader).code][1]; \\r
- } \\r
-}\r
-\r
-#define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr)))\r
-#define CV_PREV_POINT( reader ) (*((CvPoint*)((reader).prev_elem)))\r
-\r
-#define CV_READ_EDGE( pt1, pt2, reader ) \\r
-{ \\r
- assert( sizeof(pt1) == sizeof(CvPoint) && \\r
- sizeof(pt2) == sizeof(CvPoint) && \\r
- reader.seq->elem_size == sizeof(CvPoint)); \\r
- (pt1) = CV_PREV_POINT( reader ); \\r
- (pt2) = CV_CURRENT_POINT( reader ); \\r
- (reader).prev_elem = (reader).ptr; \\r
- CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader)); \\r
-}\r
-\r
-/************ Graph macros ************/\r
-\r
-/* Return next graph edge for given vertex: */\r
-#define CV_NEXT_GRAPH_EDGE( edge, vertex ) \\r
- (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \\r
- (edge)->next[(edge)->vtx[1] == (vertex)])\r
-\r
-\r
-\r
-/****************************************************************************************\\r
-* Data structures for persistence (a.k.a serialization) functionality *\r
-\****************************************************************************************/\r
-\r
-/* "black box" file storage */\r
-typedef struct CvFileStorage CvFileStorage;\r
-\r
-/* Storage flags: */\r
-#define CV_STORAGE_READ 0\r
-#define CV_STORAGE_WRITE 1\r
-#define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE\r
-#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE\r
-#define CV_STORAGE_APPEND 2\r
-\r
-/* List of attributes: */\r
-typedef struct CvAttrList\r
-{\r
- const char** attr; /* NULL-terminated array of (attribute_name,attribute_value) pairs. */\r
- struct CvAttrList* next; /* Pointer to next chunk of the attributes list. */\r
-}\r
-CvAttrList;\r
-\r
-CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),\r
- CvAttrList* next CV_DEFAULT(NULL) )\r
-{\r
- CvAttrList l;\r
- l.attr = attr;\r
- l.next = next;\r
-\r
- return l;\r
-}\r
-\r
-struct CvTypeInfo;\r
-\r
-#define CV_NODE_NONE 0\r
-#define CV_NODE_INT 1\r
-#define CV_NODE_INTEGER CV_NODE_INT\r
-#define CV_NODE_REAL 2\r
-#define CV_NODE_FLOAT CV_NODE_REAL\r
-#define CV_NODE_STR 3\r
-#define CV_NODE_STRING CV_NODE_STR\r
-#define CV_NODE_REF 4 /* not used */\r
-#define CV_NODE_SEQ 5\r
-#define CV_NODE_MAP 6\r
-#define CV_NODE_TYPE_MASK 7\r
-\r
-#define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK)\r
-\r
-/* file node flags */\r
-#define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */\r
-#define CV_NODE_USER 16\r
-#define CV_NODE_EMPTY 32\r
-#define CV_NODE_NAMED 64\r
-\r
-#define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT)\r
-#define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL)\r
-#define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING)\r
-#define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)\r
-#define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP)\r
-#define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)\r
-#define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0)\r
-#define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0)\r
-#define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0)\r
-#define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0)\r
-\r
-#define CV_NODE_SEQ_SIMPLE 256\r
-#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)\r
-\r
-typedef struct CvString\r
-{\r
- int len;\r
- char* ptr;\r
-}\r
-CvString;\r
-\r
-/* All the keys (names) of elements in the readed file storage\r
- are stored in the hash to speed up the lookup operations: */\r
-typedef struct CvStringHashNode\r
-{\r
- unsigned hashval;\r
- CvString str;\r
- struct CvStringHashNode* next;\r
-}\r
-CvStringHashNode;\r
-\r
-typedef struct CvGenericHash CvFileNodeHash;\r
-\r
-/* Basic element of the file storage - scalar or collection: */\r
-typedef struct CvFileNode\r
-{\r
- int tag;\r
- struct CvTypeInfo* info; /* type information\r
- (only for user-defined object, for others it is 0) */\r
- union\r
- {\r
- double f; /* scalar floating-point number */\r
- int i; /* scalar integer number */\r
- CvString str; /* text string */\r
- CvSeq* seq; /* sequence (ordered collection of file nodes) */\r
- CvFileNodeHash* map; /* map (collection of named file nodes) */\r
- } data;\r
-}\r
-CvFileNode;\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );\r
-typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );\r
-typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );\r
-typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,\r
- const void* struct_ptr, CvAttrList attributes );\r
-typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-typedef struct CvTypeInfo\r
-{\r
- int flags;\r
- int header_size;\r
- struct CvTypeInfo* prev;\r
- struct CvTypeInfo* next;\r
- const char* type_name;\r
- CvIsInstanceFunc is_instance;\r
- CvReleaseFunc release;\r
- CvReadFunc read;\r
- CvWriteFunc write;\r
- CvCloneFunc clone;\r
-}\r
-CvTypeInfo;\r
-\r
-\r
-/**** System data types ******/\r
-\r
-typedef struct CvPluginFuncInfo\r
-{\r
- void** func_addr;\r
- void* default_func_addr;\r
- const char* func_names;\r
- int search_modules;\r
- int loaded_from;\r
-}\r
-CvPluginFuncInfo;\r
-\r
-typedef struct CvModuleInfo\r
-{\r
- struct CvModuleInfo* next;\r
- const char* name;\r
- const char* version;\r
- CvPluginFuncInfo* func_tab;\r
-}\r
-CvModuleInfo;\r
-\r
-#endif /*_CXCORE_TYPES_H_*/\r
-\r
-/* End of file. */\r
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_CORE_TYPES_H__
+#define __OPENCV_CORE_TYPES_H__
+
+#if !defined _CRT_SECURE_NO_DEPRECATE && _MSC_VER > 1300
+#define _CRT_SECURE_NO_DEPRECATE /* to avoid multiple Visual Studio 2005 warnings */
+#endif
+
+
+#ifndef SKIP_INCLUDES
+ #include <assert.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <float.h>
+
+#if !defined _MSC_VER && !defined __BORLANDC__
+ #include <stdint.h>
+#endif
+
+ #if defined __ICL
+ #define CV_ICC __ICL
+ #elif defined __ICC
+ #define CV_ICC __ICC
+ #elif defined __ECL
+ #define CV_ICC __ECL
+ #elif defined __ECC
+ #define CV_ICC __ECC
+ #elif defined __INTEL_COMPILER
+ #define CV_ICC __INTEL_COMPILER
+ #endif
+
+ #if (_MSC_VER >= 1400 && defined _M_X64) || (__GNUC__ >= 4 && defined __x86_64__)
+ #if defined WIN64
+ #include <intrin.h>
+ #endif
+ #include <emmintrin.h>
+ #endif
+
+ #if defined __BORLANDC__
+ #include <fastmath.h>
+ #else
+ #include <math.h>
+ #endif
+
+ #ifdef HAVE_IPL
+ #ifndef __IPL_H__
+ #if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
+ #include <ipl.h>
+ #else
+ #include <ipl/ipl.h>
+ #endif
+ #endif
+ #elif defined __IPL_H__
+ #define HAVE_IPL
+ #endif
+#endif // SKIP_INCLUDES
+
+#if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
+ #define CV_CDECL __cdecl
+ #define CV_STDCALL __stdcall
+#else
+ #define CV_CDECL
+ #define CV_STDCALL
+#endif
+
+#ifndef CV_EXTERN_C
+ #ifdef __cplusplus
+ #define CV_EXTERN_C extern "C"
+ #define CV_DEFAULT(val) = val
+ #else
+ #define CV_EXTERN_C
+ #define CV_DEFAULT(val)
+ #endif
+#endif
+
+#ifndef CV_EXTERN_C_FUNCPTR
+ #ifdef __cplusplus
+ #define CV_EXTERN_C_FUNCPTR(x) extern "C" { typedef x; }
+ #else
+ #define CV_EXTERN_C_FUNCPTR(x) typedef x
+ #endif
+#endif
+
+#ifndef CV_INLINE
+#if defined __cplusplus
+ #define CV_INLINE inline
+#elif (defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64 || defined WINCE) && !defined __GNUC__
+ #define CV_INLINE __inline
+#else
+ #define CV_INLINE static
+#endif
+#endif /* CV_INLINE */
+
+#if (defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64 || defined WINCE) && defined CVAPI_EXPORTS
+ #define CV_EXPORTS __declspec(dllexport)
+#else
+ #define CV_EXPORTS
+#endif
+
+#ifndef CVAPI
+ #define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL
+#endif
+
+#if defined _MSC_VER || defined __BORLANDC__
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+#else
+typedef int64_t int64;
+typedef uint64_t uint64;
+#endif
+
+#ifndef HAVE_IPL
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+#endif
+
+typedef signed char schar;
+
+/* CvArr* is used to pass arbitrary
+ * array-like data structures
+ * into functions where the particular
+ * array type is recognized at runtime:
+ */
+typedef void CvArr;
+
+typedef union Cv32suf
+{
+ int i;
+ unsigned u;
+ float f;
+}
+Cv32suf;
+
+typedef union Cv64suf
+{
+ int64 i;
+ uint64 u;
+ double f;
+}
+Cv64suf;
+
+/****************************************************************************************\
+* Common macros and inline functions *
+\****************************************************************************************/
+
+#define CV_PI 3.1415926535897932384626433832795
+#define CV_LOG2 0.69314718055994530941723212145818
+
+#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
+
+#ifndef MIN
+#define MIN(a,b) ((a) > (b) ? (b) : (a))
+#endif
+
+#ifndef MAX
+#define MAX(a,b) ((a) < (b) ? (b) : (a))
+#endif
+
+/* min & max without jumps */
+#define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))
+
+#define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))
+
+/* absolute value without jumps */
+#ifndef __cplusplus
+#define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))
+#else
+#define CV_IABS(a) abs(a)
+#endif
+#define CV_CMP(a,b) (((a) > (b)) - ((a) < (b)))
+#define CV_SIGN(a) CV_CMP((a),0)
+
+CV_INLINE int cvRound( double value )
+{
+#if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && !defined __APPLE__)
+ __m128d t = _mm_set_sd( value );
+ return _mm_cvtsd_si32(t);
+#elif defined _MSC_VER && defined _M_IX86
+ int t;
+ __asm
+ {
+ fld value;
+ fistp t;
+ }
+ return t;
+#elif defined HAVE_LRINT || defined CV_ICC || defined __GNUC__
+ return (int)lrint(value);
+#else
+ // while this is not IEEE754-compliant rounding, it's usually a good enough approximation
+ return (int)(value + (value >= 0 ? 0.5 : -0.5));
+#endif
+}
+
+
+CV_INLINE int cvFloor( double value )
+{
+#ifdef __GNUC__
+ int i = (int)value;
+ return i - (i > value);
+#elif defined _MSC_VER && defined _M_X64
+ __m128d t = _mm_set_sd( value );
+ int i = _mm_cvtsd_si32(t);
+ return i - _mm_movemask_pd(_mm_cmplt_sd(t, _mm_cvtsi32_sd(t,i)));
+#else
+ int i = cvRound(value);
+ Cv32suf diff;
+ diff.f = (float)(value - i);
+ return i - (diff.i < 0);
+#endif
+}
+
+
+CV_INLINE int cvCeil( double value )
+{
+#ifdef __GNUC__
+ int i = (int)value;
+ return i + (i < value);
+#elif defined _MSC_VER && defined _M_X64
+ __m128d t = _mm_set_sd( value );
+ int i = _mm_cvtsd_si32(t);
+ return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i), t));
+#else
+ int i = cvRound(value);
+ Cv32suf diff;
+ diff.f = (float)(i - value);
+ return i + (diff.i < 0);
+#endif
+}
+
+#define cvInvSqrt(value) ((float)(1./sqrt(value)))
+#define cvSqrt(value) ((float)sqrt(value))
+
+CV_INLINE int cvIsNaN( double value )
+{
+#if 1/*defined _MSC_VER || defined __BORLANDC__
+ return _isnan(value);
+#elif defined __GNUC__
+ return isnan(value);
+#else*/
+ Cv64suf ieee754;
+ ieee754.f = value;
+ return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +
+ ((unsigned)ieee754.u != 0) > 0x7ff00000;
+#endif
+}
+
+
+CV_INLINE int cvIsInf( double value )
+{
+#if 1/*defined _MSC_VER || defined __BORLANDC__
+ return !_finite(value);
+#elif defined __GNUC__
+ return isinf(value);
+#else*/
+ Cv64suf ieee754;
+ ieee754.f = value;
+ return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&
+ (unsigned)ieee754.u == 0;
+#endif
+}
+
+
+/*************** Random number generation *******************/
+
+typedef uint64 CvRNG;
+
+CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))
+{
+ CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;
+ return rng;
+}
+
+/* Return random 32-bit unsigned integer: */
+CV_INLINE unsigned cvRandInt( CvRNG* rng )
+{
+ uint64 temp = *rng;
+ temp = (uint64)(unsigned)temp*4164903690U + (temp >> 32);
+ *rng = temp;
+ return (unsigned)temp;
+}
+
+/* Returns random floating-point number between 0 and 1: */
+CV_INLINE double cvRandReal( CvRNG* rng )
+{
+ return cvRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */;
+}
+
+/****************************************************************************************\
+* Image type (IplImage) *
+\****************************************************************************************/
+
+#ifndef HAVE_IPL
+
+/*
+ * The following definitions (until #endif)
+ * is an extract from IPL headers.
+ * Copyright (c) 1995 Intel Corporation.
+ */
+#define IPL_DEPTH_SIGN 0x80000000
+
+#define IPL_DEPTH_1U 1
+#define IPL_DEPTH_8U 8
+#define IPL_DEPTH_16U 16
+#define IPL_DEPTH_32F 32
+
+#define IPL_DEPTH_8S (IPL_DEPTH_SIGN| 8)
+#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)
+#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)
+
+#define IPL_DATA_ORDER_PIXEL 0
+#define IPL_DATA_ORDER_PLANE 1
+
+#define IPL_ORIGIN_TL 0
+#define IPL_ORIGIN_BL 1
+
+#define IPL_ALIGN_4BYTES 4
+#define IPL_ALIGN_8BYTES 8
+#define IPL_ALIGN_16BYTES 16
+#define IPL_ALIGN_32BYTES 32
+
+#define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES
+#define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES
+
+#define IPL_BORDER_CONSTANT 0
+#define IPL_BORDER_REPLICATE 1
+#define IPL_BORDER_REFLECT 2
+#define IPL_BORDER_WRAP 3
+
+typedef struct _IplImage
+{
+ int nSize; /* sizeof(IplImage) */
+ int ID; /* version (=0)*/
+ int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */
+ int alphaChannel; /* Ignored by OpenCV */
+ int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,
+ IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */
+ char colorModel[4]; /* Ignored by OpenCV */
+ char channelSeq[4]; /* ditto */
+ int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels.
+ cvCreateImage can only create interleaved images */
+ int origin; /* 0 - top-left origin,
+ 1 - bottom-left origin (Windows bitmaps style). */
+ int align; /* Alignment of image rows (4 or 8).
+ OpenCV ignores it and uses widthStep instead. */
+ int width; /* Image width in pixels. */
+ int height; /* Image height in pixels. */
+ struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */
+ struct _IplImage *maskROI; /* Must be NULL. */
+ void *imageId; /* " " */
+ struct _IplTileInfo *tileInfo; /* " " */
+ int imageSize; /* Image data size in bytes
+ (==image->height*image->widthStep
+ in case of interleaved data)*/
+ char *imageData; /* Pointer to aligned image data. */
+ int widthStep; /* Size of aligned image row in bytes. */
+ int BorderMode[4]; /* Ignored by OpenCV. */
+ int BorderConst[4]; /* Ditto. */
+ char *imageDataOrigin; /* Pointer to very origin of image data
+ (not necessarily aligned) -
+ needed for correct deallocation */
+}
+IplImage;
+
+typedef struct _IplTileInfo IplTileInfo;
+
+typedef struct _IplROI
+{
+ int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/
+ int xOffset;
+ int yOffset;
+ int width;
+ int height;
+}
+IplROI;
+
+typedef struct _IplConvKernel
+{
+ int nCols;
+ int nRows;
+ int anchorX;
+ int anchorY;
+ int *values;
+ int nShiftR;
+}
+IplConvKernel;
+
+typedef struct _IplConvKernelFP
+{
+ int nCols;
+ int nRows;
+ int anchorX;
+ int anchorY;
+ float *values;
+}
+IplConvKernelFP;
+
+#define IPL_IMAGE_HEADER 1
+#define IPL_IMAGE_DATA 2
+#define IPL_IMAGE_ROI 4
+
+#endif/*HAVE_IPL*/
+
+/* extra border mode */
+#define IPL_BORDER_REFLECT_101 4
+
+#define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))
+#define CV_TYPE_NAME_IMAGE "opencv-image"
+
+#define CV_IS_IMAGE_HDR(img) \
+ ((img) != NULL && ((const IplImage*)(img))->nSize == sizeof(IplImage))
+
+#define CV_IS_IMAGE(img) \
+ (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL)
+
+/* for storing double-precision
+ floating point data in IplImage's */
+#define IPL_DEPTH_64F 64
+
+/* get reference to pixel at (col,row),
+ for multi-channel images (col) should be multiplied by number of channels */
+#define CV_IMAGE_ELEM( image, elemtype, row, col ) \
+ (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])
+
+/****************************************************************************************\
+* Matrix type (CvMat) *
+\****************************************************************************************/
+
+#define CV_CN_MAX 64
+#define CV_CN_SHIFT 3
+#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)
+
+#define CV_8U 0
+#define CV_8S 1
+#define CV_16U 2
+#define CV_16S 3
+#define CV_32S 4
+#define CV_32F 5
+#define CV_64F 6
+#define CV_USRTYPE1 7
+
+#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)
+#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)
+
+#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
+#define CV_MAKE_TYPE CV_MAKETYPE
+
+#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
+#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
+#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
+#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
+#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
+
+#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
+#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
+#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
+#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
+#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
+
+#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
+#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
+#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
+#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
+#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
+
+#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
+#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
+#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
+#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
+#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
+
+#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
+#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
+#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
+#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
+#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
+
+#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
+#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
+#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
+#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
+#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
+
+#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
+#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
+#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
+#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
+#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
+
+#define CV_AUTO_STEP 0x7fffffff
+#define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )
+
+#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)
+#define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
+#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)
+#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK)
+#define CV_MAT_CONT_FLAG_SHIFT 14
+#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)
+#define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG)
+#define CV_IS_CONT_MAT CV_IS_MAT_CONT
+#define CV_MAT_TEMP_FLAG_SHIFT 15
+#define CV_MAT_TEMP_FLAG (1 << CV_MAT_TEMP_FLAG_SHIFT)
+#define CV_IS_TEMP_MAT(flags) ((flags) & CV_MAT_TEMP_FLAG)
+
+#define CV_MAGIC_MASK 0xFFFF0000
+#define CV_MAT_MAGIC_VAL 0x42420000
+#define CV_TYPE_NAME_MAT "opencv-matrix"
+
+typedef struct CvMat
+{
+ int type;
+ int step;
+
+ /* for internal use only */
+ int* refcount;
+ int hdr_refcount;
+
+ union
+ {
+ uchar* ptr;
+ short* s;
+ int* i;
+ float* fl;
+ double* db;
+ } data;
+
+#ifdef __cplusplus
+ union
+ {
+ int rows;
+ int height;
+ };
+
+ union
+ {
+ int cols;
+ int width;
+ };
+#else
+ int rows;
+ int cols;
+#endif
+
+}
+CvMat;
+
+
+#define CV_IS_MAT_HDR(mat) \
+ ((mat) != NULL && \
+ (((const CvMat*)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL && \
+ ((const CvMat*)(mat))->cols > 0 && ((const CvMat*)(mat))->rows > 0)
+
+#define CV_IS_MAT(mat) \
+ (CV_IS_MAT_HDR(mat) && ((const CvMat*)(mat))->data.ptr != NULL)
+
+#define CV_IS_MASK_ARR(mat) \
+ (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)
+
+#define CV_ARE_TYPES_EQ(mat1, mat2) \
+ ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)
+
+#define CV_ARE_CNS_EQ(mat1, mat2) \
+ ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)
+
+#define CV_ARE_DEPTHS_EQ(mat1, mat2) \
+ ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)
+
+#define CV_ARE_SIZES_EQ(mat1, mat2) \
+ ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)
+
+#define CV_IS_MAT_CONST(mat) \
+ (((mat)->rows|(mat)->cols) == 1)
+
+/* Size of each channel item,
+ 0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */
+#define CV_ELEM_SIZE1(type) \
+ ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)
+
+/* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */
+#define CV_ELEM_SIZE(type) \
+ (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))
+
+#define IPL2CV_DEPTH(depth) \
+ ((((CV_8U)+(CV_16U<<4)+(CV_32F<<8)+(CV_64F<<16)+(CV_8S<<20)+ \
+ (CV_16S<<24)+(CV_32S<<28)) >> ((((depth) & 0xF0) >> 2) + \
+ (((depth) & IPL_DEPTH_SIGN) ? 20 : 0))) & 15)
+
+/* Inline constructor. No data is allocated internally!!!
+ * (Use together with cvCreateData, or use cvCreateMat instead to
+ * get a matrix with allocated data):
+ */
+CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL))
+{
+ CvMat m;
+
+ assert( (unsigned)CV_MAT_DEPTH(type) <= CV_64F );
+ type = CV_MAT_TYPE(type);
+ m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type;
+ m.cols = cols;
+ m.rows = rows;
+ m.step = m.cols*CV_ELEM_SIZE(type);
+ m.data.ptr = (uchar*)data;
+ m.refcount = NULL;
+ m.hdr_refcount = 0;
+
+ return m;
+}
+
+
+#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \
+ (assert( (unsigned)(row) < (unsigned)(mat).rows && \
+ (unsigned)(col) < (unsigned)(mat).cols ), \
+ (mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))
+
+#define CV_MAT_ELEM_PTR( mat, row, col ) \
+ CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )
+
+#define CV_MAT_ELEM( mat, elemtype, row, col ) \
+ (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))
+
+
+CV_INLINE double cvmGet( const CvMat* mat, int row, int col )
+{
+ int type;
+
+ type = CV_MAT_TYPE(mat->type);
+ assert( (unsigned)row < (unsigned)mat->rows &&
+ (unsigned)col < (unsigned)mat->cols );
+
+ if( type == CV_32FC1 )
+ return ((float*)(mat->data.ptr + (size_t)mat->step*row))[col];
+ else
+ {
+ assert( type == CV_64FC1 );
+ return ((double*)(mat->data.ptr + (size_t)mat->step*row))[col];
+ }
+}
+
+
+CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value )
+{
+ int type;
+ type = CV_MAT_TYPE(mat->type);
+ assert( (unsigned)row < (unsigned)mat->rows &&
+ (unsigned)col < (unsigned)mat->cols );
+
+ if( type == CV_32FC1 )
+ ((float*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;
+ else
+ {
+ assert( type == CV_64FC1 );
+ ((double*)(mat->data.ptr + (size_t)mat->step*row))[col] = (double)value;
+ }
+}
+
+
+CV_INLINE int cvIplDepth( int type )
+{
+ int depth = CV_MAT_DEPTH(type);
+ return CV_ELEM_SIZE1(depth)*8 | (depth == CV_8S || depth == CV_16S ||
+ depth == CV_32S ? IPL_DEPTH_SIGN : 0);
+}
+
+
+/****************************************************************************************\
+* Multi-dimensional dense array (CvMatND) *
+\****************************************************************************************/
+
+#define CV_MATND_MAGIC_VAL 0x42430000
+#define CV_TYPE_NAME_MATND "opencv-nd-matrix"
+
+#define CV_MAX_DIM 32
+#define CV_MAX_DIM_HEAP (1 << 16)
+
+typedef struct CvMatND
+{
+ int type;
+ int dims;
+
+ int* refcount;
+ int hdr_refcount;
+
+ union
+ {
+ uchar* ptr;
+ float* fl;
+ double* db;
+ int* i;
+ short* s;
+ } data;
+
+ struct
+ {
+ int size;
+ int step;
+ }
+ dim[CV_MAX_DIM];
+}
+CvMatND;
+
+#define CV_IS_MATND_HDR(mat) \
+ ((mat) != NULL && (((const CvMatND*)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)
+
+#define CV_IS_MATND(mat) \
+ (CV_IS_MATND_HDR(mat) && ((const CvMatND*)(mat))->data.ptr != NULL)
+
+
+/****************************************************************************************\
+* Multi-dimensional sparse array (CvSparseMat) *
+\****************************************************************************************/
+
+#define CV_SPARSE_MAT_MAGIC_VAL 0x42440000
+#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
+
+struct CvSet;
+
+typedef struct CvSparseMat
+{
+ int type;
+ int dims;
+ int* refcount;
+ int hdr_refcount;
+
+ struct CvSet* heap;
+ void** hashtable;
+ int hashsize;
+ int valoffset;
+ int idxoffset;
+ int size[CV_MAX_DIM];
+}
+CvSparseMat;
+
+#define CV_IS_SPARSE_MAT_HDR(mat) \
+ ((mat) != NULL && \
+ (((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)
+
+#define CV_IS_SPARSE_MAT(mat) \
+ CV_IS_SPARSE_MAT_HDR(mat)
+
+/**************** iteration through a sparse array *****************/
+
+typedef struct CvSparseNode
+{
+ unsigned hashval;
+ struct CvSparseNode* next;
+}
+CvSparseNode;
+
+typedef struct CvSparseMatIterator
+{
+ CvSparseMat* mat;
+ CvSparseNode* node;
+ int curidx;
+}
+CvSparseMatIterator;
+
+#define CV_NODE_VAL(mat,node) ((void*)((uchar*)(node) + (mat)->valoffset))
+#define CV_NODE_IDX(mat,node) ((int*)((uchar*)(node) + (mat)->idxoffset))
+
+/****************************************************************************************\
+* Histogram *
+\****************************************************************************************/
+
+typedef int CvHistType;
+
+#define CV_HIST_MAGIC_VAL 0x42450000
+#define CV_HIST_UNIFORM_FLAG (1 << 10)
+
+/* indicates whether bin ranges are set already or not */
+#define CV_HIST_RANGES_FLAG (1 << 11)
+
+#define CV_HIST_ARRAY 0
+#define CV_HIST_SPARSE 1
+#define CV_HIST_TREE CV_HIST_SPARSE
+
+/* should be used as a parameter only,
+ it turns to CV_HIST_UNIFORM_FLAG of hist->type */
+#define CV_HIST_UNIFORM 1
+
+typedef struct CvHistogram
+{
+ int type;
+ CvArr* bins;
+ float thresh[CV_MAX_DIM][2]; /* For uniform histograms. */
+ float** thresh2; /* For non-uniform histograms. */
+ CvMatND mat; /* Embedded matrix header for array histograms. */
+}
+CvHistogram;
+
+#define CV_IS_HIST( hist ) \
+ ((hist) != NULL && \
+ (((CvHistogram*)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL && \
+ (hist)->bins != NULL)
+
+#define CV_IS_UNIFORM_HIST( hist ) \
+ (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)
+
+#define CV_IS_SPARSE_HIST( hist ) \
+ CV_IS_SPARSE_MAT((hist)->bins)
+
+#define CV_HIST_HAS_RANGES( hist ) \
+ (((hist)->type & CV_HIST_RANGES_FLAG) != 0)
+
+/****************************************************************************************\
+* Other supplementary data type definitions *
+\****************************************************************************************/
+
+/*************************************** CvRect *****************************************/
+
+typedef struct CvRect
+{
+ int x;
+ int y;
+ int width;
+ int height;
+}
+CvRect;
+
+CV_INLINE CvRect cvRect( int x, int y, int width, int height )
+{
+ CvRect r;
+
+ r.x = x;
+ r.y = y;
+ r.width = width;
+ r.height = height;
+
+ return r;
+}
+
+
+CV_INLINE IplROI cvRectToROI( CvRect rect, int coi )
+{
+ IplROI roi;
+ roi.xOffset = rect.x;
+ roi.yOffset = rect.y;
+ roi.width = rect.width;
+ roi.height = rect.height;
+ roi.coi = coi;
+
+ return roi;
+}
+
+
+CV_INLINE CvRect cvROIToRect( IplROI roi )
+{
+ return cvRect( roi.xOffset, roi.yOffset, roi.width, roi.height );
+}
+
+/*********************************** CvTermCriteria *************************************/
+
+#define CV_TERMCRIT_ITER 1
+#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER
+#define CV_TERMCRIT_EPS 2
+
+typedef struct CvTermCriteria
+{
+ int type; /* may be combination of
+ CV_TERMCRIT_ITER
+ CV_TERMCRIT_EPS */
+ int max_iter;
+ double epsilon;
+}
+CvTermCriteria;
+
+CV_INLINE CvTermCriteria cvTermCriteria( int type, int max_iter, double epsilon )
+{
+ CvTermCriteria t;
+
+ t.type = type;
+ t.max_iter = max_iter;
+ t.epsilon = (float)epsilon;
+
+ return t;
+}
+
+
+/******************************* CvPoint and variants ***********************************/
+
+typedef struct CvPoint
+{
+ int x;
+ int y;
+}
+CvPoint;
+
+
+CV_INLINE CvPoint cvPoint( int x, int y )
+{
+ CvPoint p;
+
+ p.x = x;
+ p.y = y;
+
+ return p;
+}
+
+
+typedef struct CvPoint2D32f
+{
+ float x;
+ float y;
+}
+CvPoint2D32f;
+
+
+CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y )
+{
+ CvPoint2D32f p;
+
+ p.x = (float)x;
+ p.y = (float)y;
+
+ return p;
+}
+
+
+CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )
+{
+ return cvPoint2D32f( (float)point.x, (float)point.y );
+}
+
+
+CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point )
+{
+ CvPoint ipt;
+ ipt.x = cvRound(point.x);
+ ipt.y = cvRound(point.y);
+
+ return ipt;
+}
+
+
+typedef struct CvPoint3D32f
+{
+ float x;
+ float y;
+ float z;
+}
+CvPoint3D32f;
+
+
+CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z )
+{
+ CvPoint3D32f p;
+
+ p.x = (float)x;
+ p.y = (float)y;
+ p.z = (float)z;
+
+ return p;
+}
+
+
+typedef struct CvPoint2D64f
+{
+ double x;
+ double y;
+}
+CvPoint2D64f;
+
+
+CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y )
+{
+ CvPoint2D64f p;
+
+ p.x = x;
+ p.y = y;
+
+ return p;
+}
+
+
+typedef struct CvPoint3D64f
+{
+ double x;
+ double y;
+ double z;
+}
+CvPoint3D64f;
+
+
+CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z )
+{
+ CvPoint3D64f p;
+
+ p.x = x;
+ p.y = y;
+ p.z = z;
+
+ return p;
+}
+
+
+/******************************** CvSize's & CvBox **************************************/
+
+typedef struct
+{
+ int width;
+ int height;
+}
+CvSize;
+
+CV_INLINE CvSize cvSize( int width, int height )
+{
+ CvSize s;
+
+ s.width = width;
+ s.height = height;
+
+ return s;
+}
+
+typedef struct CvSize2D32f
+{
+ float width;
+ float height;
+}
+CvSize2D32f;
+
+
+CV_INLINE CvSize2D32f cvSize2D32f( double width, double height )
+{
+ CvSize2D32f s;
+
+ s.width = (float)width;
+ s.height = (float)height;
+
+ return s;
+}
+
+typedef struct CvBox2D
+{
+ CvPoint2D32f center; /* Center of the box. */
+ CvSize2D32f size; /* Box width and length. */
+ float angle; /* Angle between the horizontal axis */
+ /* and the first side (i.e. length) in degrees */
+}
+CvBox2D;
+
+
+/* Line iterator state: */
+typedef struct CvLineIterator
+{
+ /* Pointer to the current point: */
+ uchar* ptr;
+
+ /* Bresenham algorithm state: */
+ int err;
+ int plus_delta;
+ int minus_delta;
+ int plus_step;
+ int minus_step;
+}
+CvLineIterator;
+
+
+
+/************************************* CvSlice ******************************************/
+
+typedef struct CvSlice
+{
+ int start_index, end_index;
+}
+CvSlice;
+
+CV_INLINE CvSlice cvSlice( int start, int end )
+{
+ CvSlice slice;
+ slice.start_index = start;
+ slice.end_index = end;
+
+ return slice;
+}
+
+#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
+#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
+
+
+/************************************* CvScalar *****************************************/
+
+typedef struct CvScalar
+{
+ double val[4];
+}
+CvScalar;
+
+CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0),
+ double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))
+{
+ CvScalar scalar;
+ scalar.val[0] = val0; scalar.val[1] = val1;
+ scalar.val[2] = val2; scalar.val[3] = val3;
+ return scalar;
+}
+
+
+CV_INLINE CvScalar cvRealScalar( double val0 )
+{
+ CvScalar scalar;
+ scalar.val[0] = val0;
+ scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
+ return scalar;
+}
+
+CV_INLINE CvScalar cvScalarAll( double val0123 )
+{
+ CvScalar scalar;
+ scalar.val[0] = val0123;
+ scalar.val[1] = val0123;
+ scalar.val[2] = val0123;
+ scalar.val[3] = val0123;
+ return scalar;
+}
+
+/****************************************************************************************\
+* Dynamic Data structures *
+\****************************************************************************************/
+
+/******************************** Memory storage ****************************************/
+
+typedef struct CvMemBlock
+{
+ struct CvMemBlock* prev;
+ struct CvMemBlock* next;
+}
+CvMemBlock;
+
+#define CV_STORAGE_MAGIC_VAL 0x42890000
+
+typedef struct CvMemStorage
+{
+ int signature;
+ CvMemBlock* bottom; /* First allocated block. */
+ CvMemBlock* top; /* Current memory block - top of the stack. */
+ struct CvMemStorage* parent; /* We get new blocks from parent as needed. */
+ int block_size; /* Block size. */
+ int free_space; /* Remaining free space in current block. */
+}
+CvMemStorage;
+
+#define CV_IS_STORAGE(storage) \
+ ((storage) != NULL && \
+ (((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)
+
+
+typedef struct CvMemStoragePos
+{
+ CvMemBlock* top;
+ int free_space;
+}
+CvMemStoragePos;
+
+
+/*********************************** Sequence *******************************************/
+
+typedef struct CvSeqBlock
+{
+ struct CvSeqBlock* prev; /* Previous sequence block. */
+ struct CvSeqBlock* next; /* Next sequence block. */
+ int start_index; /* Index of the first element in the block + */
+ /* sequence->first->start_index. */
+ int count; /* Number of elements in the block. */
+ schar* data; /* Pointer to the first element of the block. */
+}
+CvSeqBlock;
+
+
+#define CV_TREE_NODE_FIELDS(node_type) \
+ int flags; /* Miscellaneous flags. */ \
+ int header_size; /* Size of sequence header. */ \
+ struct node_type* h_prev; /* Previous sequence. */ \
+ struct node_type* h_next; /* Next sequence. */ \
+ struct node_type* v_prev; /* 2nd previous sequence. */ \
+ struct node_type* v_next /* 2nd next sequence. */
+
+/*
+ Read/Write sequence.
+ Elements can be dynamically inserted to or deleted from the sequence.
+*/
+#define CV_SEQUENCE_FIELDS() \
+ CV_TREE_NODE_FIELDS(CvSeq); \
+ int total; /* Total number of elements. */ \
+ int elem_size; /* Size of sequence element in bytes. */ \
+ schar* block_max; /* Maximal bound of the last block. */ \
+ schar* ptr; /* Current write pointer. */ \
+ int delta_elems; /* Grow seq this many at a time. */ \
+ CvMemStorage* storage; /* Where the seq is stored. */ \
+ CvSeqBlock* free_blocks; /* Free blocks list. */ \
+ CvSeqBlock* first; /* Pointer to the first sequence block. */
+
+typedef struct CvSeq
+{
+ CV_SEQUENCE_FIELDS()
+}
+CvSeq;
+
+#define CV_TYPE_NAME_SEQ "opencv-sequence"
+#define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
+
+/*************************************** Set ********************************************/
+/*
+ Set.
+ Order is not preserved. There can be gaps between sequence elements.
+ After the element has been inserted it stays in the same place all the time.
+ The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.
+*/
+#define CV_SET_ELEM_FIELDS(elem_type) \
+ int flags; \
+ struct elem_type* next_free;
+
+typedef struct CvSetElem
+{
+ CV_SET_ELEM_FIELDS(CvSetElem)
+}
+CvSetElem;
+
+#define CV_SET_FIELDS() \
+ CV_SEQUENCE_FIELDS() \
+ CvSetElem* free_elems; \
+ int active_count;
+
+typedef struct CvSet
+{
+ CV_SET_FIELDS()
+}
+CvSet;
+
+
+#define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)
+#define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1))
+
+/* Checks whether the element pointed by ptr belongs to a set or not */
+#define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0)
+
+/************************************* Graph ********************************************/
+
+/*
+ We represent a graph as a set of vertices.
+ Vertices contain their adjacency lists (more exactly, pointers to first incoming or
+ outcoming edge (or 0 if isolated vertex)). Edges are stored in another set.
+ There is a singly-linked list of incoming/outcoming edges for each vertex.
+
+ Each edge consists of
+
+ o Two pointers to the starting and ending vertices
+ (vtx[0] and vtx[1] respectively).
+
+ A graph may be oriented or not. In the latter case, edges between
+ vertex i to vertex j are not distinguished during search operations.
+
+ o Two pointers to next edges for the starting and ending vertices, where
+ next[0] points to the next edge in the vtx[0] adjacency list and
+ next[1] points to the next edge in the vtx[1] adjacency list.
+*/
+#define CV_GRAPH_EDGE_FIELDS() \
+ int flags; \
+ float weight; \
+ struct CvGraphEdge* next[2]; \
+ struct CvGraphVtx* vtx[2];
+
+
+#define CV_GRAPH_VERTEX_FIELDS() \
+ int flags; \
+ struct CvGraphEdge* first;
+
+
+typedef struct CvGraphEdge
+{
+ CV_GRAPH_EDGE_FIELDS()
+}
+CvGraphEdge;
+
+typedef struct CvGraphVtx
+{
+ CV_GRAPH_VERTEX_FIELDS()
+}
+CvGraphVtx;
+
+typedef struct CvGraphVtx2D
+{
+ CV_GRAPH_VERTEX_FIELDS()
+ CvPoint2D32f* ptr;
+}
+CvGraphVtx2D;
+
+/*
+ Graph is "derived" from the set (this is set a of vertices)
+ and includes another set (edges)
+*/
+#define CV_GRAPH_FIELDS() \
+ CV_SET_FIELDS() \
+ CvSet* edges;
+
+typedef struct CvGraph
+{
+ CV_GRAPH_FIELDS()
+}
+CvGraph;
+
+#define CV_TYPE_NAME_GRAPH "opencv-graph"
+
+/*********************************** Chain/Countour *************************************/
+
+typedef struct CvChain
+{
+ CV_SEQUENCE_FIELDS()
+ CvPoint origin;
+}
+CvChain;
+
+#define CV_CONTOUR_FIELDS() \
+ CV_SEQUENCE_FIELDS() \
+ CvRect rect; \
+ int color; \
+ int reserved[3];
+
+typedef struct CvContour
+{
+ CV_CONTOUR_FIELDS()
+}
+CvContour;
+
+typedef CvContour CvPoint2DSeq;
+
+/****************************************************************************************\
+* Sequence types *
+\****************************************************************************************/
+
+#define CV_SEQ_MAGIC_VAL 0x42990000
+
+#define CV_IS_SEQ(seq) \
+ ((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)
+
+#define CV_SET_MAGIC_VAL 0x42980000
+#define CV_IS_SET(set) \
+ ((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)
+
+#define CV_SEQ_ELTYPE_BITS 9
+#define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)
+
+#define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */
+#define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */
+#define CV_SEQ_ELTYPE_GENERIC 0
+#define CV_SEQ_ELTYPE_PTR CV_USRTYPE1
+#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */
+#define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #(x,y) */
+#define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /* &next_o, &next_d, &vtx_o, &vtx_d */
+#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /* first_edge, &(x,y) */
+#define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */
+#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */
+#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */
+
+#define CV_SEQ_KIND_BITS 3
+#define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)
+
+/* types of sequences */
+#define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)
+#define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)
+#define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)
+
+/* types of sparse sequences (sets) */
+#define CV_SEQ_KIND_GRAPH (3 << CV_SEQ_ELTYPE_BITS)
+#define CV_SEQ_KIND_SUBDIV2D (4 << CV_SEQ_ELTYPE_BITS)
+
+#define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)
+
+/* flags for curves */
+#define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)
+#define CV_SEQ_FLAG_SIMPLE (2 << CV_SEQ_FLAG_SHIFT)
+#define CV_SEQ_FLAG_CONVEX (4 << CV_SEQ_FLAG_SHIFT)
+#define CV_SEQ_FLAG_HOLE (8 << CV_SEQ_FLAG_SHIFT)
+
+/* flags for graphs */
+#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)
+
+#define CV_GRAPH CV_SEQ_KIND_GRAPH
+#define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)
+
+/* point sets */
+#define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)
+#define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)
+#define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)
+#define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )
+#define CV_SEQ_CONTOUR CV_SEQ_POLYGON
+#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON )
+
+/* chain-coded curves */
+#define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)
+#define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)
+
+/* binary tree for the contour */
+#define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)
+
+/* sequence of the connected components */
+#define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)
+
+/* sequence of the integer numbers */
+#define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)
+
+#define CV_SEQ_ELTYPE( seq ) ((seq)->flags & CV_SEQ_ELTYPE_MASK)
+#define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK )
+
+/* flag checking */
+#define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \
+ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))
+
+#define CV_IS_SEQ_CURVE( seq ) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)
+#define CV_IS_SEQ_CLOSED( seq ) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)
+#define CV_IS_SEQ_CONVEX( seq ) (((seq)->flags & CV_SEQ_FLAG_CONVEX) != 0)
+#define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
+#define CV_IS_SEQ_SIMPLE( seq ) ((((seq)->flags & CV_SEQ_FLAG_SIMPLE) != 0) || \
+ CV_IS_SEQ_CONVEX(seq))
+
+/* type checking macros */
+#define CV_IS_SEQ_POINT_SET( seq ) \
+ ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))
+
+#define CV_IS_SEQ_POINT_SUBSET( seq ) \
+ (CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)
+
+#define CV_IS_SEQ_POLYLINE( seq ) \
+ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))
+
+#define CV_IS_SEQ_POLYGON( seq ) \
+ (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))
+
+#define CV_IS_SEQ_CHAIN( seq ) \
+ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)
+
+#define CV_IS_SEQ_CONTOUR( seq ) \
+ (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))
+
+#define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \
+ (CV_IS_SEQ_CHAIN( seq ) && CV_IS_SEQ_CLOSED( seq ))
+
+#define CV_IS_SEQ_POLYGON_TREE( seq ) \
+ (CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR && \
+ CV_SEQ_KIND( seq ) == CV_SEQ_KIND_BIN_TREE )
+
+#define CV_IS_GRAPH( seq ) \
+ (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)
+
+#define CV_IS_GRAPH_ORIENTED( seq ) \
+ (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)
+
+#define CV_IS_SUBDIV2D( seq ) \
+ (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)
+
+/****************************************************************************************/
+/* Sequence writer & reader */
+/****************************************************************************************/
+
+#define CV_SEQ_WRITER_FIELDS() \
+ int header_size; \
+ CvSeq* seq; /* the sequence written */ \
+ CvSeqBlock* block; /* current block */ \
+ schar* ptr; /* pointer to free space */ \
+ schar* block_min; /* pointer to the beginning of block*/\
+ schar* block_max; /* pointer to the end of block */
+
+typedef struct CvSeqWriter
+{
+ CV_SEQ_WRITER_FIELDS()
+}
+CvSeqWriter;
+
+
+#define CV_SEQ_READER_FIELDS() \
+ int header_size; \
+ CvSeq* seq; /* sequence, beign read */ \
+ CvSeqBlock* block; /* current block */ \
+ schar* ptr; /* pointer to element be read next */ \
+ schar* block_min; /* pointer to the beginning of block */\
+ schar* block_max; /* pointer to the end of block */ \
+ int delta_index;/* = seq->first->start_index */ \
+ schar* prev_elem; /* pointer to previous element */
+
+
+typedef struct CvSeqReader
+{
+ CV_SEQ_READER_FIELDS()
+}
+CvSeqReader;
+
+/****************************************************************************************/
+/* Operations on sequences */
+/****************************************************************************************/
+
+#define CV_SEQ_ELEM( seq, elem_type, index ) \
+/* assert gives some guarantee that <seq> parameter is valid */ \
+( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && \
+ (seq)->elem_size == sizeof(elem_type)), \
+ (elem_type*)((seq)->first && (unsigned)index < \
+ (unsigned)((seq)->first->count) ? \
+ (seq)->first->data + (index) * sizeof(elem_type) : \
+ cvGetSeqElem( (CvSeq*)(seq), (index) )))
+#define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) )
+
+/* Add element to sequence: */
+#define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) \
+{ \
+ if( (writer).ptr >= (writer).block_max ) \
+ { \
+ cvCreateSeqBlock( &writer); \
+ } \
+ memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);\
+ (writer).ptr += (writer).seq->elem_size; \
+}
+
+#define CV_WRITE_SEQ_ELEM( elem, writer ) \
+{ \
+ assert( (writer).seq->elem_size == sizeof(elem)); \
+ if( (writer).ptr >= (writer).block_max ) \
+ { \
+ cvCreateSeqBlock( &writer); \
+ } \
+ assert( (writer).ptr <= (writer).block_max - sizeof(elem));\
+ memcpy((writer).ptr, &(elem), sizeof(elem)); \
+ (writer).ptr += sizeof(elem); \
+}
+
+
+/* Move reader position forward: */
+#define CV_NEXT_SEQ_ELEM( elem_size, reader ) \
+{ \
+ if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \
+ { \
+ cvChangeSeqBlock( &(reader), 1 ); \
+ } \
+}
+
+
+/* Move reader position backward: */
+#define CV_PREV_SEQ_ELEM( elem_size, reader ) \
+{ \
+ if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \
+ { \
+ cvChangeSeqBlock( &(reader), -1 ); \
+ } \
+}
+
+/* Read element and move read position forward: */
+#define CV_READ_SEQ_ELEM( elem, reader ) \
+{ \
+ assert( (reader).seq->elem_size == sizeof(elem)); \
+ memcpy( &(elem), (reader).ptr, sizeof((elem))); \
+ CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) \
+}
+
+/* Read element and move read position backward: */
+#define CV_REV_READ_SEQ_ELEM( elem, reader ) \
+{ \
+ assert( (reader).seq->elem_size == sizeof(elem)); \
+ memcpy(&(elem), (reader).ptr, sizeof((elem))); \
+ CV_PREV_SEQ_ELEM( sizeof(elem), reader ) \
+}
+
+
+#define CV_READ_CHAIN_POINT( _pt, reader ) \
+{ \
+ (_pt) = (reader).pt; \
+ if( (reader).ptr ) \
+ { \
+ CV_READ_SEQ_ELEM( (reader).code, (reader)); \
+ assert( ((reader).code & ~7) == 0 ); \
+ (reader).pt.x += (reader).deltas[(int)(reader).code][0]; \
+ (reader).pt.y += (reader).deltas[(int)(reader).code][1]; \
+ } \
+}
+
+#define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr)))
+#define CV_PREV_POINT( reader ) (*((CvPoint*)((reader).prev_elem)))
+
+#define CV_READ_EDGE( pt1, pt2, reader ) \
+{ \
+ assert( sizeof(pt1) == sizeof(CvPoint) && \
+ sizeof(pt2) == sizeof(CvPoint) && \
+ reader.seq->elem_size == sizeof(CvPoint)); \
+ (pt1) = CV_PREV_POINT( reader ); \
+ (pt2) = CV_CURRENT_POINT( reader ); \
+ (reader).prev_elem = (reader).ptr; \
+ CV_NEXT_SEQ_ELEM( sizeof(CvPoint), (reader)); \
+}
+
+/************ Graph macros ************/
+
+/* Return next graph edge for given vertex: */
+#define CV_NEXT_GRAPH_EDGE( edge, vertex ) \
+ (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \
+ (edge)->next[(edge)->vtx[1] == (vertex)])
+
+
+
+/****************************************************************************************\
+* Data structures for persistence (a.k.a serialization) functionality *
+\****************************************************************************************/
+
+/* "black box" file storage */
+typedef struct CvFileStorage CvFileStorage;
+
+/* Storage flags: */
+#define CV_STORAGE_READ 0
+#define CV_STORAGE_WRITE 1
+#define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE
+#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE
+#define CV_STORAGE_APPEND 2
+
+/* List of attributes: */
+typedef struct CvAttrList
+{
+ const char** attr; /* NULL-terminated array of (attribute_name,attribute_value) pairs. */
+ struct CvAttrList* next; /* Pointer to next chunk of the attributes list. */
+}
+CvAttrList;
+
+CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),
+ CvAttrList* next CV_DEFAULT(NULL) )
+{
+ CvAttrList l;
+ l.attr = attr;
+ l.next = next;
+
+ return l;
+}
+
+struct CvTypeInfo;
+
+#define CV_NODE_NONE 0
+#define CV_NODE_INT 1
+#define CV_NODE_INTEGER CV_NODE_INT
+#define CV_NODE_REAL 2
+#define CV_NODE_FLOAT CV_NODE_REAL
+#define CV_NODE_STR 3
+#define CV_NODE_STRING CV_NODE_STR
+#define CV_NODE_REF 4 /* not used */
+#define CV_NODE_SEQ 5
+#define CV_NODE_MAP 6
+#define CV_NODE_TYPE_MASK 7
+
+#define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK)
+
+/* file node flags */
+#define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */
+#define CV_NODE_USER 16
+#define CV_NODE_EMPTY 32
+#define CV_NODE_NAMED 64
+
+#define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT)
+#define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL)
+#define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING)
+#define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)
+#define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP)
+#define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)
+#define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0)
+#define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0)
+#define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0)
+#define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0)
+
+#define CV_NODE_SEQ_SIMPLE 256
+#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)
+
+typedef struct CvString
+{
+ int len;
+ char* ptr;
+}
+CvString;
+
+/* All the keys (names) of elements in the readed file storage
+ are stored in the hash to speed up the lookup operations: */
+typedef struct CvStringHashNode
+{
+ unsigned hashval;
+ CvString str;
+ struct CvStringHashNode* next;
+}
+CvStringHashNode;
+
+typedef struct CvGenericHash CvFileNodeHash;
+
+/* Basic element of the file storage - scalar or collection: */
+typedef struct CvFileNode
+{
+ int tag;
+ struct CvTypeInfo* info; /* type information
+ (only for user-defined object, for others it is 0) */
+ union
+ {
+ double f; /* scalar floating-point number */
+ int i; /* scalar integer number */
+ CvString str; /* text string */
+ CvSeq* seq; /* sequence (ordered collection of file nodes) */
+ CvFileNodeHash* map; /* map (collection of named file nodes) */
+ } data;
+}
+CvFileNode;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
+typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
+typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );
+typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,
+ const void* struct_ptr, CvAttrList attributes );
+typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );
+#ifdef __cplusplus
+}
+#endif
+
+typedef struct CvTypeInfo
+{
+ int flags;
+ int header_size;
+ struct CvTypeInfo* prev;
+ struct CvTypeInfo* next;
+ const char* type_name;
+ CvIsInstanceFunc is_instance;
+ CvReleaseFunc release;
+ CvReadFunc read;
+ CvWriteFunc write;
+ CvCloneFunc clone;
+}
+CvTypeInfo;
+
+
+/**** System data types ******/
+
+typedef struct CvPluginFuncInfo
+{
+ void** func_addr;
+ void* default_func_addr;
+ const char* func_names;
+ int search_modules;
+ int loaded_from;
+}
+CvPluginFuncInfo;
+
+typedef struct CvModuleInfo
+{
+ struct CvModuleInfo* next;
+ const char* name;
+ const char* version;
+ CvPluginFuncInfo* func_tab;
+}
+CvModuleInfo;
+
+#endif /*_CXCORE_TYPES_H_*/
+
+/* End of file. */
projects / opencv.git / blobdiff