/*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.
|
// Copyright (C) 2013, OpenCV Foundation, 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
|
|
#ifdef HAVE_IPL
|
# ifndef __IPL_H__
|
# if defined _WIN32
|
# include <ipl.h>
|
# else
|
# include <ipl/ipl.h>
|
# endif
|
# endif
|
#elif defined __IPL_H__
|
# define HAVE_IPL
|
#endif
|
|
#include "opencv2/core/cvdef.h"
|
|
#ifndef SKIP_INCLUDES
|
#include <assert.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <float.h>
|
#endif // SKIP_INCLUDES
|
|
#if defined _WIN32
|
# define CV_CDECL __cdecl
|
# define CV_STDCALL __stdcall
|
#else
|
# define CV_CDECL
|
# define CV_STDCALL
|
#endif
|
|
#ifndef CV_DEFAULT
|
# ifdef __cplusplus
|
# define CV_DEFAULT(val) = val
|
# else
|
# 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 CVAPI
|
# define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL
|
#endif
|
|
#ifndef CV_IMPL
|
# define CV_IMPL CV_EXTERN_C
|
#endif
|
|
#ifdef __cplusplus
|
# include "opencv2/core.hpp"
|
#endif
|
|
/** @addtogroup core_c
|
@{
|
*/
|
|
/** @brief This is the "metatype" used *only* as a function parameter.
|
|
It denotes that the function accepts arrays of multiple types, such as IplImage*, CvMat* or even
|
CvSeq* sometimes. The particular array type is determined at runtime by analyzing the first 4
|
bytes of the header. In C++ interface the role of CvArr is played by InputArray and OutputArray.
|
*/
|
typedef void CvArr;
|
|
typedef int CVStatus;
|
|
/** @see cv::Error::Code */
|
enum {
|
CV_StsOk= 0, /**< everything is ok */
|
CV_StsBackTrace= -1, /**< pseudo error for back trace */
|
CV_StsError= -2, /**< unknown /unspecified error */
|
CV_StsInternal= -3, /**< internal error (bad state) */
|
CV_StsNoMem= -4, /**< insufficient memory */
|
CV_StsBadArg= -5, /**< function arg/param is bad */
|
CV_StsBadFunc= -6, /**< unsupported function */
|
CV_StsNoConv= -7, /**< iter. didn't converge */
|
CV_StsAutoTrace= -8, /**< tracing */
|
CV_HeaderIsNull= -9, /**< image header is NULL */
|
CV_BadImageSize= -10, /**< image size is invalid */
|
CV_BadOffset= -11, /**< offset is invalid */
|
CV_BadDataPtr= -12, /**/
|
CV_BadStep= -13, /**< image step is wrong, this may happen for a non-continuous matrix */
|
CV_BadModelOrChSeq= -14, /**/
|
CV_BadNumChannels= -15, /**< bad number of channels, for example, some functions accept only single channel matrices */
|
CV_BadNumChannel1U= -16, /**/
|
CV_BadDepth= -17, /**< input image depth is not supported by the function */
|
CV_BadAlphaChannel= -18, /**/
|
CV_BadOrder= -19, /**< number of dimensions is out of range */
|
CV_BadOrigin= -20, /**< incorrect input origin */
|
CV_BadAlign= -21, /**< incorrect input align */
|
CV_BadCallBack= -22, /**/
|
CV_BadTileSize= -23, /**/
|
CV_BadCOI= -24, /**< input COI is not supported */
|
CV_BadROISize= -25, /**< incorrect input roi */
|
CV_MaskIsTiled= -26, /**/
|
CV_StsNullPtr= -27, /**< null pointer */
|
CV_StsVecLengthErr= -28, /**< incorrect vector length */
|
CV_StsFilterStructContentErr= -29, /**< incorrect filter structure content */
|
CV_StsKernelStructContentErr= -30, /**< incorrect transform kernel content */
|
CV_StsFilterOffsetErr= -31, /**< incorrect filter offset value */
|
CV_StsBadSize= -201, /**< the input/output structure size is incorrect */
|
CV_StsDivByZero= -202, /**< division by zero */
|
CV_StsInplaceNotSupported= -203, /**< in-place operation is not supported */
|
CV_StsObjectNotFound= -204, /**< request can't be completed */
|
CV_StsUnmatchedFormats= -205, /**< formats of input/output arrays differ */
|
CV_StsBadFlag= -206, /**< flag is wrong or not supported */
|
CV_StsBadPoint= -207, /**< bad CvPoint */
|
CV_StsBadMask= -208, /**< bad format of mask (neither 8uC1 nor 8sC1)*/
|
CV_StsUnmatchedSizes= -209, /**< sizes of input/output structures do not match */
|
CV_StsUnsupportedFormat= -210, /**< the data format/type is not supported by the function*/
|
CV_StsOutOfRange= -211, /**< some of parameters are out of range */
|
CV_StsParseError= -212, /**< invalid syntax/structure of the parsed file */
|
CV_StsNotImplemented= -213, /**< the requested function/feature is not implemented */
|
CV_StsBadMemBlock= -214, /**< an allocated block has been corrupted */
|
CV_StsAssert= -215, /**< assertion failed */
|
CV_GpuNotSupported= -216, /**< no CUDA support */
|
CV_GpuApiCallError= -217, /**< GPU API call error */
|
CV_OpenGlNotSupported= -218, /**< no OpenGL support */
|
CV_OpenGlApiCallError= -219, /**< OpenGL API call error */
|
CV_OpenCLApiCallError= -220, /**< OpenCL API call error */
|
CV_OpenCLDoubleNotSupported= -221,
|
CV_OpenCLInitError= -222, /**< OpenCL initialization error */
|
CV_OpenCLNoAMDBlasFft= -223
|
};
|
|
/****************************************************************************************\
|
* Common macros and inline functions *
|
\****************************************************************************************/
|
|
#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
|
|
/** 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)
|
|
#define cvInvSqrt(value) ((float)(1./sqrt(value)))
|
#define cvSqrt(value) ((float)sqrt(value))
|
|
|
/*************** Random number generation *******************/
|
|
typedef uint64 CvRNG;
|
|
#define CV_RNG_COEFF 4164903690U
|
|
/** @brief Initializes a random number generator state.
|
|
The function initializes a random number generator and returns the state. The pointer to the state
|
can be then passed to the cvRandInt, cvRandReal and cvRandArr functions. In the current
|
implementation a multiply-with-carry generator is used.
|
@param seed 64-bit value used to initiate a random sequence
|
@sa the C++ class RNG replaced CvRNG.
|
*/
|
CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))
|
{
|
CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;
|
return rng;
|
}
|
|
/** @brief Returns a 32-bit unsigned integer and updates RNG.
|
|
The function returns a uniformly-distributed random 32-bit unsigned integer and updates the RNG
|
state. It is similar to the rand() function from the C runtime library, except that OpenCV functions
|
always generates a 32-bit random number, regardless of the platform.
|
@param rng CvRNG state initialized by cvRNG.
|
*/
|
CV_INLINE unsigned cvRandInt( CvRNG* rng )
|
{
|
uint64 temp = *rng;
|
temp = (uint64)(unsigned)temp*CV_RNG_COEFF + (temp >> 32);
|
*rng = temp;
|
return (unsigned)temp;
|
}
|
|
/** @brief Returns a floating-point random number and updates RNG.
|
|
The function returns a uniformly-distributed random floating-point number between 0 and 1 (1 is not
|
included).
|
@param rng RNG state initialized by cvRNG
|
*/
|
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
|
|
/** The IplImage is taken from the Intel Image Processing Library, in which the format is native. OpenCV
|
only supports a subset of possible IplImage formats, as outlined in the parameter list above.
|
|
In addition to the above restrictions, OpenCV handles ROIs differently. OpenCV functions require
|
that the image size or ROI size of all source and destination images match exactly. On the other
|
hand, the Intel Image Processing Library processes the area of intersection between the source and
|
destination images (or ROIs), allowing them to vary independently.
|
*/
|
typedef struct
|
#ifdef __cplusplus
|
CV_EXPORTS
|
#endif
|
_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 */
|
|
#ifdef __cplusplus
|
_IplImage() {}
|
_IplImage(const cv::Mat& m);
|
#endif
|
}
|
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_BORDER_TRANSPARENT 5
|
|
#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_AUTO_STEP 0x7fffffff
|
#define CV_WHOLE_ARR cvSlice( 0, 0x3fffffff )
|
|
#define CV_MAGIC_MASK 0xFFFF0000
|
#define CV_MAT_MAGIC_VAL 0x42420000
|
#define CV_TYPE_NAME_MAT "opencv-matrix"
|
|
/** Matrix elements are stored row by row. Element (i, j) (i - 0-based row index, j - 0-based column
|
index) of a matrix can be retrieved or modified using CV_MAT_ELEM macro:
|
|
uchar pixval = CV_MAT_ELEM(grayimg, uchar, i, j)
|
CV_MAT_ELEM(cameraMatrix, float, 0, 2) = image.width*0.5f;
|
|
To access multiple-channel matrices, you can use
|
CV_MAT_ELEM(matrix, type, i, j\*nchannels + channel_idx).
|
|
@deprecated CvMat is now obsolete; consider using Mat instead.
|
*/
|
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
|
|
|
#ifdef __cplusplus
|
CvMat() {}
|
CvMat(const CvMat& m) { memcpy(this, &m, sizeof(CvMat));}
|
CvMat(const cv::Mat& m);
|
#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_HDR_Z(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)
|
|
#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;
|
}
|
|
#ifdef __cplusplus
|
inline CvMat::CvMat(const cv::Mat& m)
|
{
|
CV_DbgAssert(m.dims <= 2);
|
*this = cvMat(m.rows, m.dims == 1 ? 1 : m.cols, m.type(), m.data);
|
step = (int)m.step[0];
|
type = (type & ~cv::Mat::CONTINUOUS_FLAG) | (m.flags & cv::Mat::CONTINUOUS_FLAG);
|
}
|
#endif
|
|
|
#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)))
|
|
/** @brief Returns the particular element of single-channel floating-point matrix.
|
|
The function is a fast replacement for cvGetReal2D in the case of single-channel floating-point
|
matrices. It is faster because it is inline, it does fewer checks for array type and array element
|
type, and it checks for the row and column ranges only in debug mode.
|
@param mat Input matrix
|
@param row The zero-based index of row
|
@param col The zero-based index of column
|
*/
|
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*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col];
|
else
|
{
|
assert( type == CV_64FC1 );
|
return ((double*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col];
|
}
|
}
|
|
/** @brief Sets a specific element of a single-channel floating-point matrix.
|
|
The function is a fast replacement for cvSetReal2D in the case of single-channel floating-point
|
matrices. It is faster because it is inline, it does fewer checks for array type and array element
|
type, and it checks for the row and column ranges only in debug mode.
|
@param mat The matrix
|
@param row The zero-based index of row
|
@param col The zero-based index of column
|
@param value The new value of the matrix element
|
*/
|
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*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col] = (float)value;
|
else
|
{
|
assert( type == CV_64FC1 );
|
((double*)(void*)(mat->data.ptr + (size_t)mat->step*row))[col] = 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 1024
|
|
/**
|
@deprecated consider using cv::Mat instead
|
*/
|
typedef struct
|
#ifdef __cplusplus
|
CV_EXPORTS
|
#endif
|
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];
|
|
#ifdef __cplusplus
|
CvMatND() {}
|
CvMatND(const cv::Mat& m);
|
#endif
|
}
|
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
|
#ifdef __cplusplus
|
CV_EXPORTS
|
#endif
|
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];
|
|
#ifdef __cplusplus
|
void copyToSparseMat(cv::SparseMat& m) const;
|
#endif
|
}
|
CvSparseMat;
|
|
#ifdef __cplusplus
|
CV_EXPORTS CvSparseMat* cvCreateSparseMat(const cv::SparseMat& m);
|
#endif
|
|
#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 *****************************************/
|
/** @sa Rect_ */
|
typedef struct CvRect
|
{
|
int x;
|
int y;
|
int width;
|
int height;
|
|
#ifdef __cplusplus
|
CvRect(int _x = 0, int _y = 0, int w = 0, int h = 0): x(_x), y(_y), width(w), height(h) {}
|
template<typename _Tp>
|
CvRect(const cv::Rect_<_Tp>& r): x(cv::saturate_cast<int>(r.x)), y(cv::saturate_cast<int>(r.y)), width(cv::saturate_cast<int>(r.width)), height(cv::saturate_cast<int>(r.height)) {}
|
template<typename _Tp>
|
operator cv::Rect_<_Tp>() const { return cv::Rect_<_Tp>((_Tp)x, (_Tp)y, (_Tp)width, (_Tp)height); }
|
#endif
|
}
|
CvRect;
|
|
/** constructs CvRect structure. */
|
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
|
|
/** @sa TermCriteria
|
*/
|
typedef struct CvTermCriteria
|
{
|
int type; /**< may be combination of
|
CV_TERMCRIT_ITER
|
CV_TERMCRIT_EPS */
|
int max_iter;
|
double epsilon;
|
|
#ifdef __cplusplus
|
CvTermCriteria(int _type = 0, int _iter = 0, double _eps = 0) : type(_type), max_iter(_iter), epsilon(_eps) {}
|
CvTermCriteria(const cv::TermCriteria& t) : type(t.type), max_iter(t.maxCount), epsilon(t.epsilon) {}
|
operator cv::TermCriteria() const { return cv::TermCriteria(type, max_iter, epsilon); }
|
#endif
|
|
}
|
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;
|
|
#ifdef __cplusplus
|
CvPoint(int _x = 0, int _y = 0): x(_x), y(_y) {}
|
template<typename _Tp>
|
CvPoint(const cv::Point_<_Tp>& pt): x((int)pt.x), y((int)pt.y) {}
|
template<typename _Tp>
|
operator cv::Point_<_Tp>() const { return cv::Point_<_Tp>(cv::saturate_cast<_Tp>(x), cv::saturate_cast<_Tp>(y)); }
|
#endif
|
}
|
CvPoint;
|
|
/** constructs CvPoint structure. */
|
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;
|
|
#ifdef __cplusplus
|
CvPoint2D32f(float _x = 0, float _y = 0): x(_x), y(_y) {}
|
template<typename _Tp>
|
CvPoint2D32f(const cv::Point_<_Tp>& pt): x((float)pt.x), y((float)pt.y) {}
|
template<typename _Tp>
|
operator cv::Point_<_Tp>() const { return cv::Point_<_Tp>(cv::saturate_cast<_Tp>(x), cv::saturate_cast<_Tp>(y)); }
|
#endif
|
}
|
CvPoint2D32f;
|
|
/** constructs CvPoint2D32f structure. */
|
CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y )
|
{
|
CvPoint2D32f p;
|
|
p.x = (float)x;
|
p.y = (float)y;
|
|
return p;
|
}
|
|
/** converts CvPoint to CvPoint2D32f. */
|
CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point )
|
{
|
return cvPoint2D32f( (float)point.x, (float)point.y );
|
}
|
|
/** converts CvPoint2D32f to CvPoint. */
|
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;
|
|
#ifdef __cplusplus
|
CvPoint3D32f(float _x = 0, float _y = 0, float _z = 0): x(_x), y(_y), z(_z) {}
|
template<typename _Tp>
|
CvPoint3D32f(const cv::Point3_<_Tp>& pt): x((float)pt.x), y((float)pt.y), z((float)pt.z) {}
|
template<typename _Tp>
|
operator cv::Point3_<_Tp>() const { return cv::Point3_<_Tp>(cv::saturate_cast<_Tp>(x), cv::saturate_cast<_Tp>(y), cv::saturate_cast<_Tp>(z)); }
|
#endif
|
}
|
CvPoint3D32f;
|
|
/** constructs CvPoint3D32f structure. */
|
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;
|
|
/** constructs CvPoint2D64f structure.*/
|
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;
|
|
/** constructs CvPoint3D64f structure. */
|
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 CvSize
|
{
|
int width;
|
int height;
|
|
#ifdef __cplusplus
|
CvSize(int w = 0, int h = 0): width(w), height(h) {}
|
template<typename _Tp>
|
CvSize(const cv::Size_<_Tp>& sz): width(cv::saturate_cast<int>(sz.width)), height(cv::saturate_cast<int>(sz.height)) {}
|
template<typename _Tp>
|
operator cv::Size_<_Tp>() const { return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width), cv::saturate_cast<_Tp>(height)); }
|
#endif
|
}
|
CvSize;
|
|
/** constructs CvSize structure. */
|
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;
|
|
#ifdef __cplusplus
|
CvSize2D32f(float w = 0, float h = 0): width(w), height(h) {}
|
template<typename _Tp>
|
CvSize2D32f(const cv::Size_<_Tp>& sz): width(cv::saturate_cast<float>(sz.width)), height(cv::saturate_cast<float>(sz.height)) {}
|
template<typename _Tp>
|
operator cv::Size_<_Tp>() const { return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width), cv::saturate_cast<_Tp>(height)); }
|
#endif
|
}
|
CvSize2D32f;
|
|
/** constructs CvSize2D32f structure. */
|
CV_INLINE CvSize2D32f cvSize2D32f( double width, double height )
|
{
|
CvSize2D32f s;
|
|
s.width = (float)width;
|
s.height = (float)height;
|
|
return s;
|
}
|
|
/** @sa RotatedRect
|
*/
|
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 */
|
|
#ifdef __cplusplus
|
CvBox2D(CvPoint2D32f c = CvPoint2D32f(), CvSize2D32f s = CvSize2D32f(), float a = 0) : center(c), size(s), angle(a) {}
|
CvBox2D(const cv::RotatedRect& rr) : center(rr.center), size(rr.size), angle(rr.angle) {}
|
operator cv::RotatedRect() const { return cv::RotatedRect(center, size, angle); }
|
#endif
|
}
|
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 ******************************************/
|
#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
|
#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
|
|
typedef struct CvSlice
|
{
|
int start_index, end_index;
|
|
#if defined(__cplusplus) && !defined(__CUDACC__)
|
CvSlice(int start = 0, int end = 0) : start_index(start), end_index(end) {}
|
CvSlice(const cv::Range& r) { *this = (r.start != INT_MIN && r.end != INT_MAX) ? CvSlice(r.start, r.end) : CvSlice(0, CV_WHOLE_SEQ_END_INDEX); }
|
operator cv::Range() const { return (start_index == 0 && end_index == CV_WHOLE_SEQ_END_INDEX ) ? cv::Range::all() : cv::Range(start_index, end_index); }
|
#endif
|
}
|
CvSlice;
|
|
CV_INLINE CvSlice cvSlice( int start, int end )
|
{
|
CvSlice slice;
|
slice.start_index = start;
|
slice.end_index = end;
|
|
return slice;
|
}
|
|
|
|
/************************************* CvScalar *****************************************/
|
/** @sa Scalar_
|
*/
|
typedef struct CvScalar
|
{
|
double val[4];
|
|
#ifdef __cplusplus
|
CvScalar() {}
|
CvScalar(double d0, double d1 = 0, double d2 = 0, double d3 = 0) { val[0] = d0; val[1] = d1; val[2] = d2; val[3] = d3; }
|
template<typename _Tp>
|
CvScalar(const cv::Scalar_<_Tp>& s) { val[0] = s.val[0]; val[1] = s.val[1]; val[2] = s.val[2]; val[3] = s.val[3]; }
|
template<typename _Tp>
|
operator cv::Scalar_<_Tp>() const { return cv::Scalar_<_Tp>(cv::saturate_cast<_Tp>(val[0]), cv::saturate_cast<_Tp>(val[1]), cv::saturate_cast<_Tp>(val[2]), cv::saturate_cast<_Tp>(val[3])); }
|
template<typename _Tp, int cn>
|
CvScalar(const cv::Vec<_Tp, cn>& v)
|
{
|
int i;
|
for( i = 0; i < (cn < 4 ? cn : 4); i++ ) val[i] = v.val[i];
|
for( ; i < 4; i++ ) val[i] = 0;
|
}
|
#endif
|
}
|
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 ********************************************/
|
/** @brief 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 ********************************************/
|
|
/** @name 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:
|
|
- 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.
|
|
- 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.
|
|
@see CvGraphEdge, CvGraphVtx, CvGraphVtx2D, CvGraph
|
@{
|
*/
|
#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 12
|
#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 2
|
#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 (1 << CV_SEQ_ELTYPE_BITS)
|
#define CV_SEQ_KIND_SUBDIV2D (2 << 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 (0 << CV_SEQ_FLAG_SHIFT)
|
#define CV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)
|
#define CV_SEQ_FLAG_HOLE (2 << 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 ) 0
|
#define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
|
#define CV_IS_SEQ_SIMPLE( seq ) 1
|
|
/** 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
|
#define CV_STORAGE_MEMORY 4
|
#define CV_STORAGE_FORMAT_MASK (7<<3)
|
#define CV_STORAGE_FORMAT_AUTO 0
|
#define CV_STORAGE_FORMAT_XML 8
|
#define CV_STORAGE_FORMAT_YAML 16
|
#define CV_STORAGE_FORMAT_JSON 24
|
#define CV_STORAGE_BASE64 64
|
#define CV_STORAGE_WRITE_BASE64 (CV_STORAGE_BASE64 | CV_STORAGE_WRITE)
|
|
/** @brief List of attributes. :
|
|
In the current implementation, attributes are used to pass extra parameters when writing user
|
objects (see cvWrite). XML attributes inside tags are not supported, aside from the object type
|
specification (type_id attribute).
|
@see cvAttrList, cvAttrValue
|
*/
|
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;
|
|
/** initializes CvAttrList structure */
|
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
|
|
/** @brief Type information
|
|
The structure contains information about one of the standard or user-defined types. Instances of the
|
type may or may not contain a pointer to the corresponding CvTypeInfo structure. In any case, there
|
is a way to find the type info structure for a given object using the cvTypeOf function.
|
Alternatively, type info can be found by type name using cvFindType, which is used when an object
|
is read from file storage. The user can register a new type with cvRegisterType that adds the type
|
information structure into the beginning of the type list. Thus, it is possible to create
|
specialized types from generic standard types and override the basic methods.
|
*/
|
typedef struct CvTypeInfo
|
{
|
int flags; /**< not used */
|
int header_size; /**< sizeof(CvTypeInfo) */
|
struct CvTypeInfo* prev; /**< previous registered type in the list */
|
struct CvTypeInfo* next; /**< next registered type in the list */
|
const char* type_name; /**< type name, written to file storage */
|
CvIsInstanceFunc is_instance; /**< checks if the passed object belongs to the type */
|
CvReleaseFunc release; /**< releases object (memory etc.) */
|
CvReadFunc read; /**< reads object from file storage */
|
CvWriteFunc write; /**< writes object to file storage */
|
CvCloneFunc clone; /**< creates a copy of the object */
|
}
|
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 /*OPENCV_CORE_TYPES_H*/
|
|
/* End of file. */
|
