Community Core Vision (Beta)

/*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.

//

//

//                        Intel License Agreement

//                For Open Source Computer Vision Library

//

// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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 _CXCORE_TYPES_H_

#define _CXCORE_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 __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

  #endif

  #if defined WIN32 && (!defined WIN64 || defined EM64T) && \

      (_MSC_VER >= 1400 || defined CV_ICC) \

      || (defined __SSE2__ && defined __GNUC__ && __GNUC__ >= 4)

    #include <emmintrin.h>

    #define CV_SSE2 1

  #else

    #define CV_SSE2 0

  #endif

  #if defined __BORLANDC__

    #include <fastmath.h>

  #elif defined WIN64 && !defined EM64T && defined CV_ICC

    #include <mathimf.h>

  #else

    #include <math.h>

  #endif

  #ifdef HAVE_IPL

      #ifndef __IPL_H__

          #if defined WIN32 || 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 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 WIN64) && !defined __GNUC__

    #define CV_INLINE __inline

#else

    #define CV_INLINE static

#endif

#endif /* CV_INLINE */

#if (defined WIN32 || defined WIN64) && 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 long long int64;

typedef unsigned long long 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 CV_SSE2

    __m128d t = _mm_load_sd( &value );

    return _mm_cvtsd_si32(t);

#elif defined WIN32 && !defined WIN64 && defined _MSC_VER

    int t;

    __asm

    {

        fld value;

        fistp t;

    }

    return t;

#elif (defined HAVE_LRINT) || (defined WIN64 && !defined EM64T && defined CV_ICC)

    return (int)lrint(value);

#else

    /*

     the algorithm was taken from Agner Fog's optimization guide

     at http://www.agner.org/assem

     */

    Cv64suf temp;

    temp.f = value + 6755399441055744.0;

    return (int)temp.u;

#endif

}

CV_INLINE  int  cvFloor( double value )

{

#if CV_SSE2

    __m128d t = _mm_load_sd( &value );

    int i = _mm_cvtsd_si32(t);

    return i - _mm_movemask_pd(_mm_cmplt_sd(t,_mm_cvtsi32_sd(t,i)));

#else

    int temp = cvRound(value);

    Cv32suf diff;

    diff.f = (float)(value - temp);

    return temp - (diff.i < 0);

#endif

}

CV_INLINE  int  cvCeil( double value )

{

#if CV_SSE2

    __m128d t = _mm_load_sd( &value );

    int i = _mm_cvtsd_si32(t);

    return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i),t));

#else

    int temp = cvRound(value);

    Cv32suf diff;

    diff.f = (float)(temp - value);

    return temp + (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*1554115554 + (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_MAKETYPE(depth,cn) ((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_DEPTH_MASK       (CV_DEPTH_MAX - 1)

#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)

#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))

/* 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 = rows > 1 ? m.cols*CV_ELEM_SIZE(type) : 0;

    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 cvCvToIplDepth( 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) \