-/*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_H_
-#define _CXCORE_H_
-
-#ifdef __IPL_H__
-#define HAVE_IPL
-#endif
-
-#ifndef SKIP_INCLUDES
- #if defined HAVE_IPL && !defined __IPL_H__
- #ifndef _INC_WINDOWS
- #define CV_PRETEND_WINDOWS
- #define _INC_WINDOWS
- typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;
- typedef int BOOL;
- #endif
- #if defined WIN32 || defined WIN64
- #include "ipl.h"
- #else
- #include "ipl/ipl.h"
- #endif
- #ifdef CV_PRETEND_WINDOWS
- #undef _INC_WINDOWS
- #endif
- #endif
-#endif // SKIP_INCLUDES
-
-#include "cxtypes.h"
-#include "cxerror.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/****************************************************************************************\
-* Array allocation, deallocation, initialization and access to elements *
-\****************************************************************************************/
-
-/* <malloc> wrapper.
- If there is no enough memory, the function
- (as well as other OpenCV functions that call cvAlloc)
- raises an error. */
-CVAPI(void*) cvAlloc( size_t size );
-
-/* <free> wrapper.
- Here and further all the memory releasing functions
- (that all call cvFree) take double pointer in order to
- to clear pointer to the data after releasing it.
- Passing pointer to NULL pointer is Ok: nothing happens in this case
-*/
-CVAPI(void) cvFree_( void* ptr );
-#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
-
-/* Allocates and initializes IplImage header */
-CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
-
-/* Inializes IplImage header */
-CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,
- int channels, int origin CV_DEFAULT(0),
- int align CV_DEFAULT(4));
-
-/* Creates IPL image (header and data) */
-CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
-
-/* Releases (i.e. deallocates) IPL image header */
-CVAPI(void) cvReleaseImageHeader( IplImage** image );
-
-/* Releases IPL image header and data */
-CVAPI(void) cvReleaseImage( IplImage** image );
-
-/* Creates a copy of IPL image (widthStep may differ) */
-CVAPI(IplImage*) cvCloneImage( const IplImage* image );
-
-/* Sets a Channel Of Interest (only a few functions support COI) -
- use cvCopy to extract the selected channel and/or put it back */
-CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
-
-/* Retrieves image Channel Of Interest */
-CVAPI(int) cvGetImageCOI( const IplImage* image );
-
-/* Sets image ROI (region of interest) (COI is not changed) */
-CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
-
-/* Resets image ROI and COI */
-CVAPI(void) cvResetImageROI( IplImage* image );
-
-/* Retrieves image ROI */
-CVAPI(CvRect) cvGetImageROI( const IplImage* image );
-
-/* Allocates and initalizes CvMat header */
-CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
-
-#define CV_AUTOSTEP 0x7fffffff
-
-/* Initializes CvMat header */
-CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,
- int type, void* data CV_DEFAULT(NULL),
- int step CV_DEFAULT(CV_AUTOSTEP) );
-
-/* Allocates and initializes CvMat header and allocates data */
-CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
-
-/* Releases CvMat header and deallocates matrix data
- (reference counting is used for data) */
-CVAPI(void) cvReleaseMat( CvMat** mat );
-
-/* Decrements CvMat data reference counter and deallocates the data if
- it reaches 0 */
-CV_INLINE void cvDecRefData( CvArr* arr )
-{
- if( CV_IS_MAT( arr ))
- {
- CvMat* mat = (CvMat*)arr;
- mat->data.ptr = NULL;
- if( mat->refcount != NULL && --*mat->refcount == 0 )
- cvFree( &mat->refcount );
- mat->refcount = NULL;
- }
- else if( CV_IS_MATND( arr ))
- {
- CvMatND* mat = (CvMatND*)arr;
- mat->data.ptr = NULL;
- if( mat->refcount != NULL && --*mat->refcount == 0 )
- cvFree( &mat->refcount );
- mat->refcount = NULL;
- }
-}
-
-/* Increments CvMat data reference counter */
-CV_INLINE int cvIncRefData( CvArr* arr )
-{
- int refcount = 0;
- if( CV_IS_MAT( arr ))
- {
- CvMat* mat = (CvMat*)arr;
- if( mat->refcount != NULL )
- refcount = ++*mat->refcount;
- }
- else if( CV_IS_MATND( arr ))
- {
- CvMatND* mat = (CvMatND*)arr;
- if( mat->refcount != NULL )
- refcount = ++*mat->refcount;
- }
- return refcount;
-}
-
-
-/* Creates an exact copy of the input matrix (except, may be, step value) */
-CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
-
-
-/* Makes a new matrix from <rect> subrectangle of input array.
- No data is copied */
-CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
-#define cvGetSubArr cvGetSubRect
-
-/* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
- (end_row is not included into the span). */
-CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,
- int start_row, int end_row,
- int delta_row CV_DEFAULT(1));
-
-CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )
-{
- return cvGetRows( arr, submat, row, row + 1, 1 );
-}
-
-
-/* Selects column span of the input array: arr(:,start_col:end_col)
- (end_col is not included into the span) */
-CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,
- int start_col, int end_col );
-
-CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )
-{
- return cvGetCols( arr, submat, col, col + 1 );
-}
-
-/* Select a diagonal of the input array.
- (diag = 0 means the main diagonal, >0 means a diagonal above the main one,
- <0 - below the main one).
- The diagonal will be represented as a column (nx1 matrix). */
-CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,
- int diag CV_DEFAULT(0));
-
-/* low-level scalar <-> raw data conversion functions */
-CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,
- int extend_to_12 CV_DEFAULT(0) );
-
-CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
-
-/* Allocates and initializes CvMatND header */
-CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
-
-/* Allocates and initializes CvMatND header and allocates data */
-CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
-
-/* Initializes preallocated CvMatND header */
-CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,
- int type, void* data CV_DEFAULT(NULL) );
-
-/* Releases CvMatND */
-CV_INLINE void cvReleaseMatND( CvMatND** mat )
-{
- cvReleaseMat( (CvMat**)mat );
-}
-
-/* Creates a copy of CvMatND (except, may be, steps) */
-CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
-
-/* Allocates and initializes CvSparseMat header and allocates data */
-CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
-
-/* Releases CvSparseMat */
-CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
-
-/* Creates a copy of CvSparseMat (except, may be, zero items) */
-CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
-
-/* Initializes sparse array iterator
- (returns the first node or NULL if the array is empty) */
-CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,
- CvSparseMatIterator* mat_iterator );
-
-// returns next sparse array node (or NULL if there is no more nodes)
-CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )
-{
- if( mat_iterator->node->next )
- return mat_iterator->node = mat_iterator->node->next;
- else
- {
- int idx;
- for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )
- {
- CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];
- if( node )
- {
- mat_iterator->curidx = idx;
- return mat_iterator->node = node;
- }
- }
- return NULL;
- }
-}
-
-/**************** matrix iterator: used for n-ary operations on dense arrays *********/
-
-#define CV_MAX_ARR 10
-
-typedef struct CvNArrayIterator
-{
- int count; /* number of arrays */
- int dims; /* number of dimensions to iterate */
- CvSize size; /* maximal common linear size: { width = size, height = 1 } */
- uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */
- int stack[CV_MAX_DIM]; /* for internal use */
- CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the
- matrices that are processed */
-}
-CvNArrayIterator;
-
-#define CV_NO_DEPTH_CHECK 1
-#define CV_NO_CN_CHECK 2
-#define CV_NO_SIZE_CHECK 4
-
-/* initializes iterator that traverses through several arrays simulteneously
- (the function together with cvNextArraySlice is used for
- N-ari element-wise operations) */
-CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,
- const CvArr* mask, CvMatND* stubs,
- CvNArrayIterator* array_iterator,
- int flags CV_DEFAULT(0) );
-
-/* returns zero value if iteration is finished, non-zero (slice length) otherwise */
-CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
-
-
-/* Returns type of array elements:
- CV_8UC1 ... CV_64FC4 ... */
-CVAPI(int) cvGetElemType( const CvArr* arr );
-
-/* Retrieves number of an array dimensions and
- optionally sizes of the dimensions */
-CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
-
-
-/* Retrieves size of a particular array dimension.
- For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)
- and cvGetDimSize(arr,1) returns number of columns (image width) */
-CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
-
-
-/* ptr = &arr(idx0,idx1,...). All indexes are zero-based,
- the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */
-CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
-CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
-CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,
- int* type CV_DEFAULT(NULL));
-
-/* For CvMat or IplImage number of indices should be 2
- (row index (y) goes first, column index (x) goes next).
- For CvMatND or CvSparseMat number of infices should match number of <dims> and
- indices order should match the array dimension order. */
-CVAPI(uchar*) cvPtrND( const CvArr* arr, int* idx, int* type CV_DEFAULT(NULL),
- int create_node CV_DEFAULT(1),
- unsigned* precalc_hashval CV_DEFAULT(NULL));
-
-/* value = arr(idx0,idx1,...) */
-CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
-CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
-CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
-CVAPI(CvScalar) cvGetND( const CvArr* arr, int* idx );
-
-/* for 1-channel arrays */
-CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
-CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
-CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
-CVAPI(double) cvGetRealND( const CvArr* arr, int* idx );
-
-/* arr(idx0,idx1,...) = value */
-CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
-CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
-CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
-CVAPI(void) cvSetND( CvArr* arr, int* idx, CvScalar value );
-
-/* for 1-channel arrays */
-CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
-CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
-CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
- int idx1, int idx2, double value );
-CVAPI(void) cvSetRealND( CvArr* arr, int* idx, double value );
-
-/* clears element of ND dense array,
- in case of sparse arrays it deletes the specified node */
-CVAPI(void) cvClearND( CvArr* arr, int* idx );
-
-/* Converts CvArr (IplImage or CvMat,...) to CvMat.
- If the last parameter is non-zero, function can
- convert multi(>2)-dimensional array to CvMat as long as
- the last array's dimension is continous. The resultant
- matrix will be have appropriate (a huge) number of rows */
-CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
- int* coi CV_DEFAULT(NULL),
- int allowND CV_DEFAULT(0));
-
-/* Converts CvArr (IplImage or CvMat) to IplImage */
-CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
-
-
-/* Changes a shape of multi-dimensional array.
- new_cn == 0 means that number of channels remains unchanged.
- new_dims == 0 means that number and sizes of dimensions remain the same
- (unless they need to be changed to set the new number of channels)
- if new_dims == 1, there is no need to specify new dimension sizes
- The resultant configuration should be achievable w/o data copying.
- If the resultant array is sparse, CvSparseMat header should be passed
- to the function else if the result is 1 or 2 dimensional,
- CvMat header should be passed to the function
- else CvMatND header should be passed */
-CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,
- int sizeof_header, CvArr* header,
- int new_cn, int new_dims, int* new_sizes );
-
-#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \
- cvReshapeMatND( (arr), sizeof(*(header)), (header), \
- (new_cn), (new_dims), (new_sizes))
-
-CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,
- int new_cn, int new_rows CV_DEFAULT(0) );
-
-/* Repeats source 2d array several times in both horizontal and
- vertical direction to fill destination array */
-CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
-
-/* Allocates array data */
-CVAPI(void) cvCreateData( CvArr* arr );
-
-/* Releases array data */
-CVAPI(void) cvReleaseData( CvArr* arr );
-
-/* Attaches user data to the array header. The step is reffered to
- the pre-last dimension. That is, all the planes of the array
- must be joint (w/o gaps) */
-CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
-
-/* Retrieves raw data of CvMat, IplImage or CvMatND.
- In the latter case the function raises an error if
- the array can not be represented as a matrix */
-CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,
- int* step CV_DEFAULT(NULL),
- CvSize* roi_size CV_DEFAULT(NULL));
-
-/* Returns width and height of array in elements */
-CVAPI(CvSize) cvGetSize( const CvArr* arr );
-
-/* Copies source array to destination array */
-CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL) );
-
-/* Sets all or "masked" elements of input array
- to the same value*/
-CVAPI(void) cvSet( CvArr* arr, CvScalar value,
- const CvArr* mask CV_DEFAULT(NULL) );
-
-/* Clears all the array elements (sets them to 0) */
-CVAPI(void) cvSetZero( CvArr* arr );
-#define cvZero cvSetZero
-
-
-/* Splits a multi-channel array into the set of single-channel arrays or
- extracts particular [color] plane */
-CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,
- CvArr* dst2, CvArr* dst3 );
-
-/* Merges a set of single-channel arrays into the single multi-channel array
- or inserts one particular [color] plane to the array */
-CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,
- const CvArr* src2, const CvArr* src3,
- CvArr* dst );
-
-/* Copies several channels from input arrays to
- certain channels of output arrays */
-CVAPI(void) cvMixChannels( const CvArr** src, int src_count,
- CvArr** dst, int dst_count,
- const int* from_to, int pair_count );
-
-/* Performs linear transformation on every source array element:
- dst(x,y,c) = scale*src(x,y,c)+shift.
- Arbitrary combination of input and output array depths are allowed
- (number of channels must be the same), thus the function can be used
- for type conversion */
-CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst,
- double scale CV_DEFAULT(1),
- double shift CV_DEFAULT(0) );
-#define cvCvtScale cvConvertScale
-#define cvScale cvConvertScale
-#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )
-
-
-/* Performs linear transformation on every source array element,
- stores absolute value of the result:
- dst(x,y,c) = abs(scale*src(x,y,c)+shift).
- destination array must have 8u type.
- In other cases one may use cvConvertScale + cvAbsDiffS */
-CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst,
- double scale CV_DEFAULT(1),
- double shift CV_DEFAULT(0) );
-#define cvCvtScaleAbs cvConvertScaleAbs
-
-
-/* checks termination criteria validity and
- sets eps to default_eps (if it is not set),
- max_iter to default_max_iters (if it is not set)
-*/
-CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,
- double default_eps,
- int default_max_iters );
-
-/****************************************************************************************\
-* Arithmetic, logic and comparison operations *
-\****************************************************************************************/
-
-/* dst(mask) = src1(mask) + src2(mask) */
-CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(mask) = src(mask) + value */
-CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(mask) = src1(mask) - src2(mask) */
-CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(mask) = src(mask) - value = src(mask) + (-value) */
-CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL))
-{
- cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),
- dst, mask );
-}
-
-/* dst(mask) = value - src(mask) */
-CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,
- const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src1(idx) * src2(idx) * scale
- (scaled element-wise multiplication of 2 arrays) */
-CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,
- CvArr* dst, double scale CV_DEFAULT(1) );
-
-/* element-wise division/inversion with scaling:
- dst(idx) = src1(idx) * scale / src2(idx)
- or dst(idx) = scale / src2(idx) if src1 == 0 */
-CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,
- CvArr* dst, double scale CV_DEFAULT(1));
-
-/* dst = src1 * scale + src2 */
-CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,
- const CvArr* src2, CvArr* dst );
-#define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
-
-/* dst = src1 * alpha + src2 * beta + gamma */
-CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,
- const CvArr* src2, double beta,
- double gamma, CvArr* dst );
-
-/* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */
-CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
-
-/* dst(idx) = src1(idx) & src2(idx) */
-CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src(idx) & value */
-CVAPI(void) cvAndS( const CvArr* src, CvScalar value,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src1(idx) | src2(idx) */
-CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src(idx) | value */
-CVAPI(void) cvOrS( const CvArr* src, CvScalar value,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src1(idx) ^ src2(idx) */
-CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = src(idx) ^ value */
-CVAPI(void) cvXorS( const CvArr* src, CvScalar value,
- CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
-
-/* dst(idx) = ~src(idx) */
-CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
-
-/* dst(idx) = lower(idx) <= src(idx) < upper(idx) */
-CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,
- const CvArr* upper, CvArr* dst );
-
-/* dst(idx) = lower <= src(idx) < upper */
-CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,
- CvScalar upper, CvArr* dst );
-
-#define CV_CMP_EQ 0
-#define CV_CMP_GT 1
-#define CV_CMP_GE 2
-#define CV_CMP_LT 3
-#define CV_CMP_LE 4
-#define CV_CMP_NE 5
-
-/* The comparison operation support single-channel arrays only.
- Destination image should be 8uC1 or 8sC1 */
-
-/* dst(idx) = src1(idx) _cmp_op_ src2(idx) */
-CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
-
-/* dst(idx) = src1(idx) _cmp_op_ value */
-CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
-
-/* dst(idx) = min(src1(idx),src2(idx)) */
-CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/* dst(idx) = max(src1(idx),src2(idx)) */
-CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/* dst(idx) = min(src(idx),value) */
-CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
-
-/* dst(idx) = max(src(idx),value) */
-CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
-
-/* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
-CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/* dst(x,y,c) = abs(src(x,y,c) - value(c)) */
-CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
-#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))
-
-/****************************************************************************************\
-* Math operations *
-\****************************************************************************************/
-
-/* Does cartesian->polar coordinates conversion.
- Either of output components (magnitude or angle) is optional */
-CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,
- CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),
- int angle_in_degrees CV_DEFAULT(0));
-
-/* Does polar->cartesian coordinates conversion.
- Either of output components (magnitude or angle) is optional.
- If magnitude is missing it is assumed to be all 1's */
-CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,
- CvArr* x, CvArr* y,
- int angle_in_degrees CV_DEFAULT(0));
-
-/* Does powering: dst(idx) = src(idx)^power */
-CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
-
-/* Does exponention: dst(idx) = exp(src(idx)).
- Overflow is not handled yet. Underflow is handled.
- Maximal relative error is ~7e-6 for single-precision input */
-CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
-
-/* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
- Logarithm of 0 gives large negative number(~-700)
- Maximal relative error is ~3e-7 for single-precision output
-*/
-CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
-
-/* Fast arctangent calculation */
-CVAPI(float) cvFastArctan( float y, float x );
-
-/* Fast cubic root calculation */
-CVAPI(float) cvCbrt( float value );
-
-/* Checks array values for NaNs, Infs or simply for too large numbers
- (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
- no runtime errors is raised (function returns zero value in case of "bad" values).
- Otherwise cvError is called */
-#define CV_CHECK_RANGE 1
-#define CV_CHECK_QUIET 2
-CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),
- double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
-#define cvCheckArray cvCheckArr
-
-#define CV_RAND_UNI 0
-#define CV_RAND_NORMAL 1
-CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,
- CvScalar param1, CvScalar param2 );
-
-/* Finds real roots of a cubic equation */
-CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
-
-/****************************************************************************************\
-* Matrix operations *
-\****************************************************************************************/
-
-/* Calculates cross product of two 3d vectors */
-CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
-
-/* Matrix transform: dst = A*B + C, C is optional */
-#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )
-#define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst))
-
-#define CV_GEMM_A_T 1
-#define CV_GEMM_B_T 2
-#define CV_GEMM_C_T 4
-/* Extended matrix transform:
- dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
-CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,
- const CvArr* src3, double beta, CvArr* dst,
- int tABC CV_DEFAULT(0));
-#define cvMatMulAddEx cvGEMM
-
-/* Transforms each element of source array and stores
- resultant vectors in destination array */
-CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,
- const CvMat* transmat,
- const CvMat* shiftvec CV_DEFAULT(NULL));
-#define cvMatMulAddS cvTransform
-
-/* Does perspective transform on every element of input array */
-CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,
- const CvMat* mat );
-
-/* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */
-CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,
- const CvArr* delta CV_DEFAULT(NULL) );
-
-/* Tranposes matrix. Square matrices can be transposed in-place */
-CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
-#define cvT cvTranspose
-
-
-/* Mirror array data around horizontal (flip=0),
- vertical (flip=1) or both(flip=-1) axises:
- cvFlip(src) flips images vertically and sequences horizontally (inplace) */
-CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),
- int flip_mode CV_DEFAULT(0));
-#define cvMirror cvFlip
-
-
-#define CV_SVD_MODIFY_A 1
-#define CV_SVD_U_T 2
-#define CV_SVD_V_T 4
-
-/* Performs Singular Value Decomposition of a matrix */
-CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),
- CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
-
-/* Performs Singular Value Back Substitution (solves A*X = B):
- flags must be the same as in cvSVD */
-CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U,
- const CvArr* V, const CvArr* B,
- CvArr* X, int flags );
-
-#define CV_LU 0
-#define CV_SVD 1
-#define CV_SVD_SYM 2
-/* Inverts matrix */
-CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,
- int method CV_DEFAULT(CV_LU));
-#define cvInv cvInvert
-
-/* Solves linear system (src1)*(dst) = (src2)
- (returns 0 if src1 is a singular and CV_LU method is used) */
-CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,
- int method CV_DEFAULT(CV_LU));
-
-/* Calculates determinant of input matrix */
-CVAPI(double) cvDet( const CvArr* mat );
-
-/* Calculates trace of the matrix (sum of elements on the main diagonal) */
-CVAPI(CvScalar) cvTrace( const CvArr* mat );
-
-/* Finds eigen values and vectors of a symmetric matrix */
-CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects,
- CvArr* evals, double eps CV_DEFAULT(0));
-
-/* Makes an identity matrix (mat_ij = i == j) */
-CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
-
-/* Calculates covariation matrix for a set of vectors */
-/* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */
-#define CV_COVAR_SCRAMBLED 0
-
-/* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */
-#define CV_COVAR_NORMAL 1
-
-/* do not calc average (i.e. mean vector) - use the input vector instead
- (useful for calculating covariance matrix by parts) */
-#define CV_COVAR_USE_AVG 2
-
-/* scale the covariance matrix coefficients by number of the vectors */
-#define CV_COVAR_SCALE 4
-
-CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,
- CvArr* cov_mat, CvArr* avg, int flags );
-
-/* Calculates Mahalanobis(weighted) distance */
-CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, CvArr* mat );
-#define cvMahalonobis cvMahalanobis
-
-/****************************************************************************************\
-* Array Statistics *
-\****************************************************************************************/
-
-/* Finds sum of array elements */
-CVAPI(CvScalar) cvSum( const CvArr* arr );
-
-/* Calculates number of non-zero pixels */
-CVAPI(int) cvCountNonZero( const CvArr* arr );
-
-/* Calculates mean value of array elements */
-CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
-
-/* Calculates mean and standard deviation of pixel values */
-CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,
- const CvArr* mask CV_DEFAULT(NULL) );
-
-/* Finds global minimum, maximum and their positions */
-CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,
- CvPoint* min_loc CV_DEFAULT(NULL),
- CvPoint* max_loc CV_DEFAULT(NULL),
- const CvArr* mask CV_DEFAULT(NULL) );
-
-/* types of array norm */
-#define CV_C 1
-#define CV_L1 2
-#define CV_L2 4
-#define CV_NORM_MASK 7
-#define CV_RELATIVE 8
-#define CV_DIFF 16
-
-#define CV_DIFF_C (CV_DIFF | CV_C)
-#define CV_DIFF_L1 (CV_DIFF | CV_L1)
-#define CV_DIFF_L2 (CV_DIFF | CV_L2)
-#define CV_RELATIVE_C (CV_RELATIVE | CV_C)
-#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)
-#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)
-
-/* Finds norm, difference norm or relative difference norm for an array (or two arrays) */
-CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),
- int norm_type CV_DEFAULT(CV_L2),
- const CvArr* mask CV_DEFAULT(NULL) );
-
-/****************************************************************************************\
-* Discrete Linear Transforms and Related Functions *
-\****************************************************************************************/
-
-#define CV_DXT_FORWARD 0
-#define CV_DXT_INVERSE 1
-#define CV_DXT_SCALE 2 /* divide result by size of array */
-#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
-#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
-#define CV_DXT_ROWS 4 /* transform each row individually */
-#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */
-
-/* Discrete Fourier Transform:
- complex->complex,
- real->ccs (forward),
- ccs->real (inverse) */
-CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,
- int nonzero_rows CV_DEFAULT(0) );
-#define cvFFT cvDFT
-
-/* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */
-CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,
- CvArr* dst, int flags );
-
-/* Finds optimal DFT vector size >= size0 */
-CVAPI(int) cvGetOptimalDFTSize( int size0 );
-
-/* Discrete Cosine Transform */
-CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
-
-/****************************************************************************************\
-* Dynamic data structures *
-\****************************************************************************************/
-
-/* Calculates length of sequence slice (with support of negative indices). */
-CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
-
-
-/* Creates new memory storage.
- block_size == 0 means that default,
- somewhat optimal size, is used (currently, it is 64K) */
-CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
-
-
-/* Creates a memory storage that will borrow memory blocks from parent storage */
-CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
-
-
-/* Releases memory storage. All the children of a parent must be released before
- the parent. A child storage returns all the blocks to parent when it is released */
-CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
-
-
-/* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)
- to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...
- do not free any memory.
- A child storage returns all the blocks to the parent when it is cleared */
-CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
-
-/* Remember a storage "free memory" position */
-CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
-
-/* Restore a storage "free memory" position */
-CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
-
-/* Allocates continuous buffer of the specified size in the storage */
-CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
-
-/* Allocates string in memory storage */
-CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
- int len CV_DEFAULT(-1) );
-
-/* Creates new empty sequence that will reside in the specified storage */
-CVAPI(CvSeq*) cvCreateSeq( int seq_flags, int header_size,
- int elem_size, CvMemStorage* storage );
-
-/* Changes default size (granularity) of sequence blocks.
- The default size is ~1Kbyte */
-CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
-
-
-/* Adds new element to the end of sequence. Returns pointer to the element */
-CVAPI(char*) cvSeqPush( CvSeq* seq, void* element CV_DEFAULT(NULL));
-
-
-/* Adds new element to the beginning of sequence. Returns pointer to it */
-CVAPI(char*) cvSeqPushFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
-
-
-/* Removes the last element from sequence and optionally saves it */
-CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
-
-
-/* Removes the first element from sequence and optioanally saves it */
-CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
-
-
-#define CV_FRONT 1
-#define CV_BACK 0
-/* Adds several new elements to the end of sequence */
-CVAPI(void) cvSeqPushMulti( CvSeq* seq, void* elements,
- int count, int in_front CV_DEFAULT(0) );
-
-/* Removes several elements from the end of sequence and optionally saves them */
-CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,
- int count, int in_front CV_DEFAULT(0) );
-
-/* Inserts a new element in the middle of sequence.
- cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
-CVAPI(char*) cvSeqInsert( CvSeq* seq, int before_index,
- void* element CV_DEFAULT(NULL));
-
-/* Removes specified sequence element */
-CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
-
-
-/* Removes all the elements from the sequence. The freed memory
- can be reused later only by the same sequence unless cvClearMemStorage
- or cvRestoreMemStoragePos is called */
-CVAPI(void) cvClearSeq( CvSeq* seq );
-
-
-/* Retrives pointer to specified sequence element.
- Negative indices are supported and mean counting from the end
- (e.g -1 means the last sequence element) */
-CVAPI(char*) cvGetSeqElem( const CvSeq* seq, int index );
-
-/* Calculates index of the specified sequence element.
- Returns -1 if element does not belong to the sequence */
-CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
- CvSeqBlock** block CV_DEFAULT(NULL) );
-
-/* Initializes sequence writer. The new elements will be added to the end of sequence */
-CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
-
-
-/* Combination of cvCreateSeq and cvStartAppendToSeq */
-CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,
- int elem_size, CvMemStorage* storage,
- CvSeqWriter* writer );
-
-/* Closes sequence writer, updates sequence header and returns pointer
- to the resultant sequence
- (which may be useful if the sequence was created using cvStartWriteSeq))
-*/
-CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
-
-
-/* Updates sequence header. May be useful to get access to some of previously
- written elements via cvGetSeqElem or sequence reader */
-CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
-
-
-/* Initializes sequence reader.
- The sequence can be read in forward or backward direction */
-CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,
- int reverse CV_DEFAULT(0) );
-
-
-/* Returns current sequence reader position (currently observed sequence element) */
-CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
-
-
-/* Changes sequence reader position. It may seek to an absolute or
- to relative to the current position */
-CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,
- int is_relative CV_DEFAULT(0));
-
-/* Copies sequence content to a continuous piece of memory */
-CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
- CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
-
-/* Creates sequence header for array.
- After that all the operations on sequences that do not alter the content
- can be applied to the resultant sequence */
-CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
- int elem_size, void* elements, int total,
- CvSeq* seq, CvSeqBlock* block );
-
-/* Extracts sequence slice (with or without copying sequence elements) */
-CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
- CvMemStorage* storage CV_DEFAULT(NULL),
- int copy_data CV_DEFAULT(0));
-
-CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
-{
- return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
-}
-
-/* Removes sequence slice */
-CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
-
-/* Inserts a sequence or array into another sequence */
-CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
-
-/* a < b ? -1 : a > b ? 1 : 0 */
-typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );
-
-/* Sorts sequence in-place given element comparison function */
-CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
-
-/* Finds element in a [sorted] sequence */
-CVAPI(char*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
- int is_sorted, int* elem_idx,
- void* userdata CV_DEFAULT(NULL) );
-
-/* Reverses order of sequence elements in-place */
-CVAPI(void) cvSeqInvert( CvSeq* seq );
-
-/* Splits sequence into one or more equivalence classes using the specified criteria */
-CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
- CvSeq** labels, CvCmpFunc is_equal, void* userdata );
-
-/************ Internal sequence functions ************/
-CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
-CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
-
-
-/* Creates a new set */
-CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,
- int elem_size, CvMemStorage* storage );
-
-/* Adds new element to the set and returns pointer to it */
-CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),
- CvSetElem** inserted_elem CV_DEFAULT(NULL) );
-
-/* Fast variant of cvSetAdd */
-CV_INLINE CvSetElem* cvSetNew( CvSet* set_header )
-{
- CvSetElem* elem = set_header->free_elems;
- if( elem )
- {
- set_header->free_elems = elem->next_free;
- elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
- set_header->active_count++;
- }
- else
- cvSetAdd( set_header, NULL, (CvSetElem**)&elem );
- return elem;
-}
-
-/* Removes set element given its pointer */
-CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem )
-{
- CvSetElem* _elem = (CvSetElem*)elem;
- assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );
- _elem->next_free = set_header->free_elems;
- _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
- set_header->free_elems = _elem;
- set_header->active_count--;
-}
-
-/* Removes element from the set by its index */
-CVAPI(void) cvSetRemove( CvSet* set_header, int index );
-
-/* Returns a set element by index. If the element doesn't belong to the set,
- NULL is returned */
-CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index )
-{
- CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );
- return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;
-}
-
-/* Removes all the elements from the set */
-CVAPI(void) cvClearSet( CvSet* set_header );
-
-/* Creates new graph */
-CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,
- int vtx_size, int edge_size,
- CvMemStorage* storage );
-
-/* Adds new vertex to the graph */
-CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),
- CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
-
-
-/* Removes vertex from the graph together with all incident edges */
-CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
-CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
-
-
-/* Link two vertices specifed by indices or pointers if they
- are not connected or return pointer to already existing edge
- connecting the vertices.
- Functions return 1 if a new edge was created, 0 otherwise */
-CVAPI(int) cvGraphAddEdge( CvGraph* graph,
- int start_idx, int end_idx,
- const CvGraphEdge* edge CV_DEFAULT(NULL),
- CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
-
-CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph,
- CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,
- const CvGraphEdge* edge CV_DEFAULT(NULL),
- CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
-
-/* Remove edge connecting two vertices */
-CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
-CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,
- CvGraphVtx* end_vtx );
-
-/* Find edge connecting two vertices */
-CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
-CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,
- const CvGraphVtx* start_vtx,
- const CvGraphVtx* end_vtx );
-#define cvGraphFindEdge cvFindGraphEdge
-#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
-
-/* Remove all vertices and edges from the graph */
-CVAPI(void) cvClearGraph( CvGraph* graph );
-
-
-/* Count number of edges incident to the vertex */
-CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
-CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
-
-
-/* Retrieves graph vertex by given index */
-#define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))
-
-/* Retrieves index of a graph vertex given its pointer */
-#define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
-
-/* Retrieves index of a graph edge given its pointer */
-#define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
-
-#define cvGraphGetVtxCount( graph ) ((graph)->active_count)
-#define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)
-
-#define CV_GRAPH_VERTEX 1
-#define CV_GRAPH_TREE_EDGE 2
-#define CV_GRAPH_BACK_EDGE 4
-#define CV_GRAPH_FORWARD_EDGE 8
-#define CV_GRAPH_CROSS_EDGE 16
-#define CV_GRAPH_ANY_EDGE 30
-#define CV_GRAPH_NEW_TREE 32
-#define CV_GRAPH_BACKTRACKING 64
-#define CV_GRAPH_OVER -1
-
-#define CV_GRAPH_ALL_ITEMS -1
-
-/* flags for graph vertices and edges */
-#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)
-#define CV_IS_GRAPH_VERTEX_VISITED(vtx) \
- (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
-#define CV_IS_GRAPH_EDGE_VISITED(edge) \
- (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
-#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)
-#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)
-
-typedef struct CvGraphScanner
-{
- CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */
- CvGraphVtx* dst; /* current graph edge destination vertex */
- CvGraphEdge* edge; /* current edge */
-
- CvGraph* graph; /* the graph */
- CvSeq* stack; /* the graph vertex stack */
- int index; /* the lower bound of certainly visited vertices */
- int mask; /* event mask */
-}
-CvGraphScanner;
-
-/* Creates new graph scanner. */
-CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,
- CvGraphVtx* vtx CV_DEFAULT(NULL),
- int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
-
-/* Releases graph scanner. */
-CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
-
-/* Get next graph element */
-CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
-
-/* Creates a copy of graph */
-CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
-
-/****************************************************************************************\
-* Drawing *
-\****************************************************************************************/
-
-/****************************************************************************************\
-* Drawing functions work with images/matrices of arbitrary type. *
-* For color images the channel order is BGR[A] *
-* Antialiasing is supported only for 8-bit image now. *
-* All the functions include parameter color that means rgb value (that may be *
-* constructed with CV_RGB macro) for color images and brightness *
-* for grayscale images. *
-* If a drawn figure is partially or completely outside of the image, it is clipped.*
-\****************************************************************************************/
-
-#define CV_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 )
-#define CV_FILLED -1
-
-#define CV_AA 16
-
-/* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
-CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
- CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-/* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
- if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
-CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
- CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8),
- int shift CV_DEFAULT(0));
-
-/* Draws a circle with specified center and radius.
- Thickness works in the same way as with cvRectangle */
-CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius,
- CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
- depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
- is rotated by <angle>. All the angles are in degrees */
-CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
- double angle, double start_angle, double end_angle,
- CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
- int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
-{
- CvSize axes;
- axes.width = cvRound(box.size.height*0.5);
- axes.height = cvRound(box.size.width*0.5);
-
- cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle*180/CV_PI,
- 0, 360, color, thickness, line_type, shift );
-}
-
-/* Fills convex or monotonous polygon. */
-CVAPI(void) cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts, CvScalar color,
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/* Fills an area bounded by one or more arbitrary polygons */
-CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours, CvScalar color,
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-/* Draws one or more polygonal curves */
-CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours,
- int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-/* Clips the line segment connecting *pt1 and *pt2
- by the rectangular window
- (0<=x<img_size.width, 0<=y<img_size.height). */
-CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
-
-/* Initializes line iterator. Initially, line_iterator->ptr will point
- to pt1 (or pt2, see left_to_right description) location in the image.
- Returns the number of pixels on the line between the ending points. */
-CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
- CvLineIterator* line_iterator,
- int connectivity CV_DEFAULT(8),
- int left_to_right CV_DEFAULT(0));
-
-/* Moves iterator to the next line point */
-#define CV_NEXT_LINE_POINT( line_iterator ) \
-{ \
- int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
- (line_iterator).err += (line_iterator).minus_delta + \
- ((line_iterator).plus_delta & _line_iterator_mask); \
- (line_iterator).ptr += (line_iterator).minus_step + \
- ((line_iterator).plus_step & _line_iterator_mask); \
-}
-
-
-/* basic font types */
-#define CV_FONT_HERSHEY_SIMPLEX 0
-#define CV_FONT_HERSHEY_PLAIN 1
-#define CV_FONT_HERSHEY_DUPLEX 2
-#define CV_FONT_HERSHEY_COMPLEX 3
-#define CV_FONT_HERSHEY_TRIPLEX 4
-#define CV_FONT_HERSHEY_COMPLEX_SMALL 5
-#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6
-#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7
-
-/* font flags */
-#define CV_FONT_ITALIC 16
-
-#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX
-
-/* Font structure */
-typedef struct CvFont
-{
- int font_face; /* =CV_FONT_* */
- const int* ascii; /* font data and metrics */
- const int* greek;
- const int* cyrillic;
- float hscale, vscale;
- float shear; /* slope coefficient: 0 - normal, >0 - italic */
- int thickness; /* letters thickness */
- float dx; /* horizontal interval between letters */
- int line_type;
-}
-CvFont;
-
-/* Initializes font structure used further in cvPutText */
-CVAPI(void) cvInitFont( CvFont* font, int font_face,
- double hscale, double vscale,
- double shear CV_DEFAULT(0),
- int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8));
-
-/* Renders text stroke with specified font and color at specified location.
- CvFont should be initialized with cvInitFont */
-CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org,
- const CvFont* font, CvScalar color );
-
-/* Calculates bounding box of text stroke (useful for alignment) */
-CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font,
- CvSize* text_size, int* baseline );
-
-/* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as
- packed color value, otherwise the first channels (depending on arrtype)
- of destination scalar are set to the same value = <color> */
-CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype );
-
-/* Returns the polygon points which make up the given ellipse. The ellipse is define by
- the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep
- of the ellipse arc can be done by spcifying arc_start and arc_end to be something
- other than 0 and 360, respectively. The input array 'pts' must be large enough to
- hold the result. The total number of points stored into 'pts' is returned by this
- function. */
-CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
- int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
-
-/* Draws contour outlines or filled interiors on the image */
-CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour,
- CvScalar external_color, CvScalar hole_color,
- int max_level, int thickness CV_DEFAULT(1),
- int line_type CV_DEFAULT(8),
- CvPoint offset CV_DEFAULT(cvPoint(0,0)));
-
-/* Does look-up transformation. Elements of the source array
- (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */
-CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
-
-
-/******************* Iteration through the sequence tree *****************/
-typedef struct CvTreeNodeIterator
-{
- const void* node;
- int level;
- int max_level;
-}
-CvTreeNodeIterator;
-
-CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,
- const void* first, int max_level );
-CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
-CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
-
-/* Inserts sequence into tree with specified "parent" sequence.
- If parent is equal to frame (e.g. the most external contour),
- then added contour will have null pointer to parent. */
-CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
-
-/* Removes contour from tree (together with the contour children). */
-CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
-
-/* Gathers pointers to all the sequences,
- accessible from the <first>, to the single sequence */
-CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,
- CvMemStorage* storage );
-
-/* The function implements the K-means algorithm for clustering an array of sample
- vectors in a specified number of classes */
-CVAPI(void) cvKMeans2( const CvArr* samples, int cluster_count,
- CvArr* labels, CvTermCriteria termcrit );
-
-/****************************************************************************************\
-* System functions *
-\****************************************************************************************/
-
-/* Add the function pointers table with associated information to the IPP primitives list */
-CVAPI(int) cvRegisterModule( const CvModuleInfo* module_info );
-
-/* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */
-CVAPI(int) cvUseOptimized( int on_off );
-
-/* Retrieves information about the registered modules and loaded optimized plugins */
-CVAPI(void) cvGetModuleInfo( const char* module_name,
- const char** version,
- const char** loaded_addon_plugins );
-
-/* Get current OpenCV error status */
-CVAPI(int) cvGetErrStatus( void );
-
-/* Sets error status silently */
-CVAPI(void) cvSetErrStatus( int status );
-
-#define CV_ErrModeLeaf 0 /* Print error and exit program */
-#define CV_ErrModeParent 1 /* Print error and continue */
-#define CV_ErrModeSilent 2 /* Don't print and continue */
-
-/* Retrives current error processing mode */
-CVAPI(int) cvGetErrMode( void );
-
-/* Sets error processing mode, returns previously used mode */
-CVAPI(int) cvSetErrMode( int mode );
-
-/* Sets error status and performs some additonal actions (displaying message box,
- writing message to stderr, terminating application etc.)
- depending on the current error mode */
-CVAPI(void) cvError( int status, const char* func_name,
- const char* err_msg, const char* file_name, int line );
-
-/* Retrieves textual description of the error given its code */
-CVAPI(const char*) cvErrorStr( int status );
-
-/* Retrieves detailed information about the last error occured */
-CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,
- const char** filename, int* line );
-
-/* Maps IPP error codes to the counterparts from OpenCV */
-CVAPI(int) cvErrorFromIppStatus( int ipp_status );
-
-typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,
- const char* err_msg, const char* file_name, int line, void* userdata );
-
-/* Assigns a new error-handling function */
-CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,
- void* userdata CV_DEFAULT(NULL),
- void** prev_userdata CV_DEFAULT(NULL) );
-
-/*
- Output to:
- cvNulDevReport - nothing
- cvStdErrReport - console(fprintf(stderr,...))
- cvGuiBoxReport - MessageBox(WIN32)
-*/
-CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
-
-CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
-
-CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,
- const char* file_name, int line, void* userdata );
-
-typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);
-typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);
-
-/* Set user-defined memory managment functions (substitutors for malloc and free) that
- will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */
-CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),
- CvFreeFunc free_func CV_DEFAULT(NULL),
- void* userdata CV_DEFAULT(NULL));
-
-
-typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)
- (int,int,int,char*,char*,int,int,int,int,int,
- IplROI*,IplImage*,void*,IplTileInfo*);
-typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);
-typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);
-typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);
-typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);
-
-/* Makes OpenCV use IPL functions for IplImage allocation/deallocation */
-CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,
- Cv_iplAllocateImageData allocate_data,
- Cv_iplDeallocate deallocate,
- Cv_iplCreateROI create_roi,
- Cv_iplCloneImage clone_image );
-
-#define CV_TURN_ON_IPL_COMPATIBILITY() \
- cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \
- iplDeallocate, iplCreateROI, iplCloneImage )
-
-/****************************************************************************************\
-* Data Persistence *
-\****************************************************************************************/
-
-/********************************** High-level functions ********************************/
-
-/* opens existing or creates new file storage */
-CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename,
- CvMemStorage* memstorage,
- int flags );
-
-/* closes file storage and deallocates buffers */
-CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
-
-/* returns attribute value or 0 (NULL) if there is no such attribute */
-CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
-
-/* starts writing compound structure (map or sequence) */
-CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
- int struct_flags, const char* type_name CV_DEFAULT(NULL),
- CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/* finishes writing compound structure */
-CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
-
-/* writes an integer */
-CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
-
-/* writes a floating-point number */
-CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
-
-/* writes a string */
-CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
- const char* str, int quote CV_DEFAULT(0) );
-
-/* writes a comment */
-CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
- int eol_comment );
-
-/* writes instance of a standard type (matrix, image, sequence, graph etc.)
- or user-defined type */
-CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
- CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/* starts the next stream */
-CVAPI(void) cvStartNextStream( CvFileStorage* fs );
-
-/* helper function: writes multiple integer or floating-point numbers */
-CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
- int len, const char* dt );
-
-/* returns the hash entry corresponding to the specified literal key string or 0
- if there is no such a key in the storage */
-CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
- int len CV_DEFAULT(-1),
- int create_missing CV_DEFAULT(0));
-
-/* returns file node with the specified key within the specified map
- (collection of named nodes) */
-CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
- int stream_index CV_DEFAULT(0) );
-
-/* returns file node with the specified key within the specified map
- (collection of named nodes) */
-CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
- const CvStringHashNode* key,
- int create_missing CV_DEFAULT(0) );
-
-/* this is a slower version of cvGetFileNode that takes the key as a literal string */
-CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
- const CvFileNode* map,
- const char* name );
-
-CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
-{
- return !node ? default_value :
- CV_NODE_IS_INT(node->tag) ? node->data.i :
- CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
-}
-
-
-CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, int default_value CV_DEFAULT(0) )
-{
- return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-
-CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
-{
- return !node ? default_value :
- CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
- CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
-}
-
-
-CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, double default_value CV_DEFAULT(0.) )
-{
- return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-
-CV_INLINE const char* cvReadString( const CvFileNode* node,
- const char* default_value CV_DEFAULT(NULL) )
-{
- return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
-}
-
-
-CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
- const char* name, const char* default_value CV_DEFAULT(NULL) )
-{
- return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-
-/* decodes standard or user-defined object and returns it */
-CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
- CvAttrList* attributes CV_DEFAULT(NULL));
-
-/* decodes standard or user-defined object and returns it */
-CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
- const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
-{
- return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
-}
-
-
-/* starts reading data from sequence or scalar numeric node */
-CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
- CvSeqReader* reader );
-
-/* reads multiple numbers and stores them to array */
-CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
- int count, void* dst, const char* dt );
-
-/* combination of two previous functions for easier reading of whole sequences */
-CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
- void* dst, const char* dt );
-
-/* writes a copy of file node to file storage */
-CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
- const CvFileNode* node, int embed );
-
-/* returns name of file node */
-CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
-
-/*********************************** Adding own types ***********************************/
-
-CVAPI(void) cvRegisterType( const CvTypeInfo* info );
-CVAPI(void) cvUnregisterType( const char* type_name );
-CVAPI(CvTypeInfo*) cvFirstType(void);
-CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
-CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
-
-/* universal functions */
-CVAPI(void) cvRelease( void** struct_ptr );
-CVAPI(void*) cvClone( const void* struct_ptr );
-
-/* simple API for reading/writing data */
-CVAPI(void) cvSave( const char* filename, const void* struct_ptr,
- const char* name CV_DEFAULT(NULL),
- const char* comment CV_DEFAULT(NULL),
- CvAttrList attributes CV_DEFAULT(cvAttrList()));
-CVAPI(void*) cvLoad( const char* filename,
- CvMemStorage* memstorage CV_DEFAULT(NULL),
- const char* name CV_DEFAULT(NULL),
- const char** real_name CV_DEFAULT(NULL) );
-
-/*********************************** Measuring Execution Time ***************************/
-
-/* helper functions for RNG initialization and accurate time measurement:
- uses internal clock counter on x86 */
-CVAPI(int64) cvGetTickCount( void );
-CVAPI(double) cvGetTickFrequency( void );
-
-/*********************************** Multi-Threading ************************************/
-
-/* retrieve/set the number of threads used in OpenMP implementations */
-CVAPI(int) cvGetNumThreads();
-CVAPI(void) cvSetNumThreads( int threads );
-/* get index of the thread being executed */
-CVAPI(int) cvGetThreadNum();
-
-#ifdef __cplusplus
-}
-
-#include "cxcore.hpp"
-#endif
-
-#endif /*_CXCORE_H_*/
+/*M///////////////////////////////////////////////////////////////////////////////////////\r
+//\r
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
+//\r
+// By downloading, copying, installing or using the software you agree to this license.\r
+// If you do not agree to this license, do not download, install,\r
+// copy or use the software.\r
+//\r
+//\r
+// License Agreement\r
+// For Open Source Computer Vision Library\r
+//\r
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.\r
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.\r
+// Third party copyrights are property of their respective owners.\r
+//\r
+// Redistribution and use in source and binary forms, with or without modification,\r
+// are permitted provided that the following conditions are met:\r
+//\r
+// * Redistribution's of source code must retain the above copyright notice,\r
+// this list of conditions and the following disclaimer.\r
+//\r
+// * Redistribution's in binary form must reproduce the above copyright notice,\r
+// this list of conditions and the following disclaimer in the documentation\r
+// and/or other materials provided with the distribution.\r
+//\r
+// * The name of the copyright holders may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// This software is provided by the copyright holders and contributors "as is" and\r
+// any express or implied warranties, including, but not limited to, the implied\r
+// warranties of merchantability and fitness for a particular purpose are disclaimed.\r
+// In no event shall the Intel Corporation or contributors be liable for any direct,\r
+// indirect, incidental, special, exemplary, or consequential damages\r
+// (including, but not limited to, procurement of substitute goods or services;\r
+// loss of use, data, or profits; or business interruption) however caused\r
+// and on any theory of liability, whether in contract, strict liability,\r
+// or tort (including negligence or otherwise) arising in any way out of\r
+// the use of this software, even if advised of the possibility of such damage.\r
+//\r
+//M*/\r
+\r
+\r
+#ifndef __OPENCV_CORE_H__\r
+#define __OPENCV_CORE_H__\r
+\r
+#ifdef __IPL_H__\r
+#define HAVE_IPL\r
+#endif\r
+\r
+#ifndef SKIP_INCLUDES\r
+ #if defined HAVE_IPL && !defined __IPL_H__\r
+ #ifndef _INC_WINDOWS\r
+ #define CV_PRETEND_WINDOWS\r
+ #define _INC_WINDOWS\r
+ typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;\r
+ typedef int BOOL;\r
+ #endif\r
+ #if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64\r
+ #include "ipl.h"\r
+ #else\r
+ #include "ipl/ipl.h"\r
+ #endif\r
+ #ifdef CV_PRETEND_WINDOWS\r
+ #undef _INC_WINDOWS\r
+ #endif\r
+ #endif\r
+#endif // SKIP_INCLUDES\r
+\r
+#include "cxtypes.h"\r
+#include "cxerror.h"\r
+#include "cvver.h"\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/****************************************************************************************\\r
+* Array allocation, deallocation, initialization and access to elements *\r
+\****************************************************************************************/\r
+\r
+/* <malloc> wrapper.\r
+ If there is no enough memory, the function\r
+ (as well as other OpenCV functions that call cvAlloc)\r
+ raises an error. */\r
+CVAPI(void*) cvAlloc( size_t size );\r
+\r
+/* <free> wrapper.\r
+ Here and further all the memory releasing functions\r
+ (that all call cvFree) take double pointer in order to\r
+ to clear pointer to the data after releasing it.\r
+ Passing pointer to NULL pointer is Ok: nothing happens in this case\r
+*/\r
+CVAPI(void) cvFree_( void* ptr );\r
+#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)\r
+\r
+/* Allocates and initializes IplImage header */\r
+CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );\r
+\r
+/* Inializes IplImage header */\r
+CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth,\r
+ int channels, int origin CV_DEFAULT(0),\r
+ int align CV_DEFAULT(4));\r
+\r
+/* Creates IPL image (header and data) */\r
+CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );\r
+\r
+/* Releases (i.e. deallocates) IPL image header */\r
+CVAPI(void) cvReleaseImageHeader( IplImage** image );\r
+\r
+/* Releases IPL image header and data */\r
+CVAPI(void) cvReleaseImage( IplImage** image );\r
+\r
+/* Creates a copy of IPL image (widthStep may differ) */\r
+CVAPI(IplImage*) cvCloneImage( const IplImage* image );\r
+\r
+/* Sets a Channel Of Interest (only a few functions support COI) -\r
+ use cvCopy to extract the selected channel and/or put it back */\r
+CVAPI(void) cvSetImageCOI( IplImage* image, int coi );\r
+\r
+/* Retrieves image Channel Of Interest */\r
+CVAPI(int) cvGetImageCOI( const IplImage* image );\r
+\r
+/* Sets image ROI (region of interest) (COI is not changed) */\r
+CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );\r
+\r
+/* Resets image ROI and COI */\r
+CVAPI(void) cvResetImageROI( IplImage* image );\r
+\r
+/* Retrieves image ROI */\r
+CVAPI(CvRect) cvGetImageROI( const IplImage* image );\r
+\r
+/* Allocates and initalizes CvMat header */\r
+CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );\r
+\r
+#define CV_AUTOSTEP 0x7fffffff\r
+\r
+/* Initializes CvMat header */\r
+CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols,\r
+ int type, void* data CV_DEFAULT(NULL),\r
+ int step CV_DEFAULT(CV_AUTOSTEP) );\r
+\r
+/* Allocates and initializes CvMat header and allocates data */\r
+CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );\r
+\r
+/* Releases CvMat header and deallocates matrix data\r
+ (reference counting is used for data) */\r
+CVAPI(void) cvReleaseMat( CvMat** mat );\r
+\r
+/* Decrements CvMat data reference counter and deallocates the data if\r
+ it reaches 0 */\r
+CV_INLINE void cvDecRefData( CvArr* arr )\r
+{\r
+ if( CV_IS_MAT( arr ))\r
+ {\r
+ CvMat* mat = (CvMat*)arr;\r
+ mat->data.ptr = NULL;\r
+ if( mat->refcount != NULL && --*mat->refcount == 0 )\r
+ cvFree( &mat->refcount );\r
+ mat->refcount = NULL;\r
+ }\r
+ else if( CV_IS_MATND( arr ))\r
+ {\r
+ CvMatND* mat = (CvMatND*)arr;\r
+ mat->data.ptr = NULL;\r
+ if( mat->refcount != NULL && --*mat->refcount == 0 )\r
+ cvFree( &mat->refcount );\r
+ mat->refcount = NULL;\r
+ }\r
+}\r
+\r
+/* Increments CvMat data reference counter */\r
+CV_INLINE int cvIncRefData( CvArr* arr )\r
+{\r
+ int refcount = 0;\r
+ if( CV_IS_MAT( arr ))\r
+ {\r
+ CvMat* mat = (CvMat*)arr;\r
+ if( mat->refcount != NULL )\r
+ refcount = ++*mat->refcount;\r
+ }\r
+ else if( CV_IS_MATND( arr ))\r
+ {\r
+ CvMatND* mat = (CvMatND*)arr;\r
+ if( mat->refcount != NULL )\r
+ refcount = ++*mat->refcount;\r
+ }\r
+ return refcount;\r
+}\r
+\r
+\r
+/* Creates an exact copy of the input matrix (except, may be, step value) */\r
+CVAPI(CvMat*) cvCloneMat( const CvMat* mat );\r
+\r
+\r
+/* Makes a new matrix from <rect> subrectangle of input array.\r
+ No data is copied */\r
+CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );\r
+#define cvGetSubArr cvGetSubRect\r
+\r
+/* Selects row span of the input array: arr(start_row:delta_row:end_row,:)\r
+ (end_row is not included into the span). */\r
+CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat,\r
+ int start_row, int end_row,\r
+ int delta_row CV_DEFAULT(1));\r
+\r
+CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row )\r
+{\r
+ return cvGetRows( arr, submat, row, row + 1, 1 );\r
+}\r
+\r
+\r
+/* Selects column span of the input array: arr(:,start_col:end_col)\r
+ (end_col is not included into the span) */\r
+CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat,\r
+ int start_col, int end_col );\r
+\r
+CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col )\r
+{\r
+ return cvGetCols( arr, submat, col, col + 1 );\r
+}\r
+\r
+/* Select a diagonal of the input array.\r
+ (diag = 0 means the main diagonal, >0 means a diagonal above the main one,\r
+ <0 - below the main one).\r
+ The diagonal will be represented as a column (nx1 matrix). */\r
+CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat,\r
+ int diag CV_DEFAULT(0));\r
+\r
+/* low-level scalar <-> raw data conversion functions */\r
+CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type,\r
+ int extend_to_12 CV_DEFAULT(0) );\r
+\r
+CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );\r
+\r
+/* Allocates and initializes CvMatND header */\r
+CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );\r
+\r
+/* Allocates and initializes CvMatND header and allocates data */\r
+CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );\r
+\r
+/* Initializes preallocated CvMatND header */\r
+CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,\r
+ int type, void* data CV_DEFAULT(NULL) );\r
+\r
+/* Releases CvMatND */\r
+CV_INLINE void cvReleaseMatND( CvMatND** mat )\r
+{\r
+ cvReleaseMat( (CvMat**)mat );\r
+}\r
+\r
+/* Creates a copy of CvMatND (except, may be, steps) */\r
+CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );\r
+\r
+/* Allocates and initializes CvSparseMat header and allocates data */\r
+CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );\r
+\r
+/* Releases CvSparseMat */\r
+CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );\r
+\r
+/* Creates a copy of CvSparseMat (except, may be, zero items) */\r
+CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );\r
+\r
+/* Initializes sparse array iterator\r
+ (returns the first node or NULL if the array is empty) */\r
+CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat,\r
+ CvSparseMatIterator* mat_iterator );\r
+\r
+// returns next sparse array node (or NULL if there is no more nodes)\r
+CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator )\r
+{\r
+ if( mat_iterator->node->next )\r
+ return mat_iterator->node = mat_iterator->node->next;\r
+ else\r
+ {\r
+ int idx;\r
+ for( idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize; idx++ )\r
+ {\r
+ CvSparseNode* node = (CvSparseNode*)mat_iterator->mat->hashtable[idx];\r
+ if( node )\r
+ {\r
+ mat_iterator->curidx = idx;\r
+ return mat_iterator->node = node;\r
+ }\r
+ }\r
+ return NULL;\r
+ }\r
+}\r
+\r
+/**************** matrix iterator: used for n-ary operations on dense arrays *********/\r
+\r
+#define CV_MAX_ARR 10\r
+\r
+typedef struct CvNArrayIterator\r
+{\r
+ int count; /* number of arrays */\r
+ int dims; /* number of dimensions to iterate */\r
+ CvSize size; /* maximal common linear size: { width = size, height = 1 } */\r
+ uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */\r
+ int stack[CV_MAX_DIM]; /* for internal use */\r
+ CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the\r
+ matrices that are processed */\r
+}\r
+CvNArrayIterator;\r
+\r
+#define CV_NO_DEPTH_CHECK 1\r
+#define CV_NO_CN_CHECK 2\r
+#define CV_NO_SIZE_CHECK 4\r
+\r
+/* initializes iterator that traverses through several arrays simulteneously\r
+ (the function together with cvNextArraySlice is used for\r
+ N-ari element-wise operations) */\r
+CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs,\r
+ const CvArr* mask, CvMatND* stubs,\r
+ CvNArrayIterator* array_iterator,\r
+ int flags CV_DEFAULT(0) );\r
+\r
+/* returns zero value if iteration is finished, non-zero (slice length) otherwise */\r
+CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );\r
+\r
+\r
+/* Returns type of array elements:\r
+ CV_8UC1 ... CV_64FC4 ... */\r
+CVAPI(int) cvGetElemType( const CvArr* arr );\r
+\r
+/* Retrieves number of an array dimensions and\r
+ optionally sizes of the dimensions */\r
+CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );\r
+\r
+\r
+/* Retrieves size of a particular array dimension.\r
+ For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height)\r
+ and cvGetDimSize(arr,1) returns number of columns (image width) */\r
+CVAPI(int) cvGetDimSize( const CvArr* arr, int index );\r
+\r
+\r
+/* ptr = &arr(idx0,idx1,...). All indexes are zero-based,\r
+ the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */\r
+CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));\r
+CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );\r
+CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2,\r
+ int* type CV_DEFAULT(NULL));\r
+\r
+/* For CvMat or IplImage number of indices should be 2\r
+ (row index (y) goes first, column index (x) goes next).\r
+ For CvMatND or CvSparseMat number of infices should match number of <dims> and\r
+ indices order should match the array dimension order. */\r
+CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL),\r
+ int create_node CV_DEFAULT(1),\r
+ unsigned* precalc_hashval CV_DEFAULT(NULL));\r
+\r
+/* value = arr(idx0,idx1,...) */\r
+CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );\r
+CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );\r
+CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );\r
+CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );\r
+\r
+/* for 1-channel arrays */\r
+CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );\r
+CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );\r
+CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );\r
+CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );\r
+\r
+/* arr(idx0,idx1,...) = value */\r
+CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );\r
+CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );\r
+CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );\r
+CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );\r
+\r
+/* for 1-channel arrays */\r
+CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );\r
+CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );\r
+CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,\r
+ int idx1, int idx2, double value );\r
+CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );\r
+\r
+/* clears element of ND dense array,\r
+ in case of sparse arrays it deletes the specified node */\r
+CVAPI(void) cvClearND( CvArr* arr, const int* idx );\r
+\r
+/* Converts CvArr (IplImage or CvMat,...) to CvMat.\r
+ If the last parameter is non-zero, function can\r
+ convert multi(>2)-dimensional array to CvMat as long as\r
+ the last array's dimension is continous. The resultant\r
+ matrix will be have appropriate (a huge) number of rows */\r
+CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,\r
+ int* coi CV_DEFAULT(NULL),\r
+ int allowND CV_DEFAULT(0));\r
+\r
+/* Converts CvArr (IplImage or CvMat) to IplImage */\r
+CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );\r
+\r
+\r
+/* Changes a shape of multi-dimensional array.\r
+ new_cn == 0 means that number of channels remains unchanged.\r
+ new_dims == 0 means that number and sizes of dimensions remain the same\r
+ (unless they need to be changed to set the new number of channels)\r
+ if new_dims == 1, there is no need to specify new dimension sizes\r
+ The resultant configuration should be achievable w/o data copying.\r
+ If the resultant array is sparse, CvSparseMat header should be passed\r
+ to the function else if the result is 1 or 2 dimensional,\r
+ CvMat header should be passed to the function\r
+ else CvMatND header should be passed */\r
+CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr,\r
+ int sizeof_header, CvArr* header,\r
+ int new_cn, int new_dims, int* new_sizes );\r
+\r
+#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes ) \\r
+ cvReshapeMatND( (arr), sizeof(*(header)), (header), \\r
+ (new_cn), (new_dims), (new_sizes))\r
+\r
+CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header,\r
+ int new_cn, int new_rows CV_DEFAULT(0) );\r
+\r
+/* Repeats source 2d array several times in both horizontal and\r
+ vertical direction to fill destination array */\r
+CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );\r
+\r
+/* Allocates array data */\r
+CVAPI(void) cvCreateData( CvArr* arr );\r
+\r
+/* Releases array data */\r
+CVAPI(void) cvReleaseData( CvArr* arr );\r
+\r
+/* Attaches user data to the array header. The step is reffered to\r
+ the pre-last dimension. That is, all the planes of the array\r
+ must be joint (w/o gaps) */\r
+CVAPI(void) cvSetData( CvArr* arr, void* data, int step );\r
+\r
+/* Retrieves raw data of CvMat, IplImage or CvMatND.\r
+ In the latter case the function raises an error if\r
+ the array can not be represented as a matrix */\r
+CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data,\r
+ int* step CV_DEFAULT(NULL),\r
+ CvSize* roi_size CV_DEFAULT(NULL));\r
+\r
+/* Returns width and height of array in elements */\r
+CVAPI(CvSize) cvGetSize( const CvArr* arr );\r
+\r
+/* Copies source array to destination array */\r
+CVAPI(void) cvCopy( const CvArr* src, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+/* Sets all or "masked" elements of input array\r
+ to the same value*/\r
+CVAPI(void) cvSet( CvArr* arr, CvScalar value,\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+/* Clears all the array elements (sets them to 0) */\r
+CVAPI(void) cvSetZero( CvArr* arr );\r
+#define cvZero cvSetZero\r
+\r
+\r
+/* Splits a multi-channel array into the set of single-channel arrays or\r
+ extracts particular [color] plane */\r
+CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,\r
+ CvArr* dst2, CvArr* dst3 );\r
+\r
+/* Merges a set of single-channel arrays into the single multi-channel array\r
+ or inserts one particular [color] plane to the array */\r
+CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1,\r
+ const CvArr* src2, const CvArr* src3,\r
+ CvArr* dst );\r
+\r
+/* Copies several channels from input arrays to\r
+ certain channels of output arrays */\r
+CVAPI(void) cvMixChannels( const CvArr** src, int src_count,\r
+ CvArr** dst, int dst_count,\r
+ const int* from_to, int pair_count );\r
+\r
+/* Performs linear transformation on every source array element:\r
+ dst(x,y,c) = scale*src(x,y,c)+shift.\r
+ Arbitrary combination of input and output array depths are allowed\r
+ (number of channels must be the same), thus the function can be used\r
+ for type conversion */\r
+CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst,\r
+ double scale CV_DEFAULT(1),\r
+ double shift CV_DEFAULT(0) );\r
+#define cvCvtScale cvConvertScale\r
+#define cvScale cvConvertScale\r
+#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )\r
+\r
+\r
+/* Performs linear transformation on every source array element,\r
+ stores absolute value of the result:\r
+ dst(x,y,c) = abs(scale*src(x,y,c)+shift).\r
+ destination array must have 8u type.\r
+ In other cases one may use cvConvertScale + cvAbsDiffS */\r
+CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst,\r
+ double scale CV_DEFAULT(1),\r
+ double shift CV_DEFAULT(0) );\r
+#define cvCvtScaleAbs cvConvertScaleAbs\r
+\r
+\r
+/* checks termination criteria validity and\r
+ sets eps to default_eps (if it is not set),\r
+ max_iter to default_max_iters (if it is not set)\r
+*/\r
+CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria,\r
+ double default_eps,\r
+ int default_max_iters );\r
+\r
+/****************************************************************************************\\r
+* Arithmetic, logic and comparison operations *\r
+\****************************************************************************************/\r
+\r
+/* dst(mask) = src1(mask) + src2(mask) */\r
+CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(mask) = src(mask) + value */\r
+CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(mask) = src1(mask) - src2(mask) */\r
+CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(mask) = src(mask) - value = src(mask) + (-value) */\r
+CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL))\r
+{\r
+ cvAddS( src, cvScalar( -value.val[0], -value.val[1], -value.val[2], -value.val[3]),\r
+ dst, mask );\r
+}\r
+\r
+/* dst(mask) = value - src(mask) */\r
+CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst,\r
+ const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src1(idx) * src2(idx) * scale\r
+ (scaled element-wise multiplication of 2 arrays) */\r
+CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, double scale CV_DEFAULT(1) );\r
+\r
+/* element-wise division/inversion with scaling:\r
+ dst(idx) = src1(idx) * scale / src2(idx)\r
+ or dst(idx) = scale / src2(idx) if src1 == 0 */\r
+CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, double scale CV_DEFAULT(1));\r
+\r
+/* dst = src1 * scale + src2 */\r
+CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale,\r
+ const CvArr* src2, CvArr* dst );\r
+#define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C)\r
+\r
+/* dst = src1 * alpha + src2 * beta + gamma */\r
+CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha,\r
+ const CvArr* src2, double beta,\r
+ double gamma, CvArr* dst );\r
+\r
+/* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */\r
+CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );\r
+\r
+/* dst(idx) = src1(idx) & src2(idx) */\r
+CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src(idx) & value */\r
+CVAPI(void) cvAndS( const CvArr* src, CvScalar value,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src1(idx) | src2(idx) */\r
+CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src(idx) | value */\r
+CVAPI(void) cvOrS( const CvArr* src, CvScalar value,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src1(idx) ^ src2(idx) */\r
+CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = src(idx) ^ value */\r
+CVAPI(void) cvXorS( const CvArr* src, CvScalar value,\r
+ CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));\r
+\r
+/* dst(idx) = ~src(idx) */\r
+CVAPI(void) cvNot( const CvArr* src, CvArr* dst );\r
+\r
+/* dst(idx) = lower(idx) <= src(idx) < upper(idx) */\r
+CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower,\r
+ const CvArr* upper, CvArr* dst );\r
+\r
+/* dst(idx) = lower <= src(idx) < upper */\r
+CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower,\r
+ CvScalar upper, CvArr* dst );\r
+\r
+#define CV_CMP_EQ 0\r
+#define CV_CMP_GT 1\r
+#define CV_CMP_GE 2\r
+#define CV_CMP_LT 3\r
+#define CV_CMP_LE 4\r
+#define CV_CMP_NE 5\r
+\r
+/* The comparison operation support single-channel arrays only.\r
+ Destination image should be 8uC1 or 8sC1 */\r
+\r
+/* dst(idx) = src1(idx) _cmp_op_ src2(idx) */\r
+CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );\r
+\r
+/* dst(idx) = src1(idx) _cmp_op_ value */\r
+CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );\r
+\r
+/* dst(idx) = min(src1(idx),src2(idx)) */\r
+CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );\r
+\r
+/* dst(idx) = max(src1(idx),src2(idx)) */\r
+CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );\r
+\r
+/* dst(idx) = min(src(idx),value) */\r
+CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );\r
+\r
+/* dst(idx) = max(src(idx),value) */\r
+CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );\r
+\r
+/* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */\r
+CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );\r
+\r
+/* dst(x,y,c) = abs(src(x,y,c) - value(c)) */\r
+CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );\r
+#define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0))\r
+\r
+/****************************************************************************************\\r
+* Math operations *\r
+\****************************************************************************************/\r
+\r
+/* Does cartesian->polar coordinates conversion.\r
+ Either of output components (magnitude or angle) is optional */\r
+CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y,\r
+ CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL),\r
+ int angle_in_degrees CV_DEFAULT(0));\r
+\r
+/* Does polar->cartesian coordinates conversion.\r
+ Either of output components (magnitude or angle) is optional.\r
+ If magnitude is missing it is assumed to be all 1's */\r
+CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle,\r
+ CvArr* x, CvArr* y,\r
+ int angle_in_degrees CV_DEFAULT(0));\r
+\r
+/* Does powering: dst(idx) = src(idx)^power */\r
+CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );\r
+\r
+/* Does exponention: dst(idx) = exp(src(idx)).\r
+ Overflow is not handled yet. Underflow is handled.\r
+ Maximal relative error is ~7e-6 for single-precision input */\r
+CVAPI(void) cvExp( const CvArr* src, CvArr* dst );\r
+\r
+/* Calculates natural logarithms: dst(idx) = log(abs(src(idx))).\r
+ Logarithm of 0 gives large negative number(~-700)\r
+ Maximal relative error is ~3e-7 for single-precision output\r
+*/\r
+CVAPI(void) cvLog( const CvArr* src, CvArr* dst );\r
+\r
+/* Fast arctangent calculation */\r
+CVAPI(float) cvFastArctan( float y, float x );\r
+\r
+/* Fast cubic root calculation */\r
+CVAPI(float) cvCbrt( float value );\r
+\r
+/* Checks array values for NaNs, Infs or simply for too large numbers\r
+ (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,\r
+ no runtime errors is raised (function returns zero value in case of "bad" values).\r
+ Otherwise cvError is called */\r
+#define CV_CHECK_RANGE 1\r
+#define CV_CHECK_QUIET 2\r
+CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0),\r
+ double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));\r
+#define cvCheckArray cvCheckArr\r
+\r
+#define CV_RAND_UNI 0\r
+#define CV_RAND_NORMAL 1\r
+CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type,\r
+ CvScalar param1, CvScalar param2 );\r
+\r
+CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,\r
+ double iter_factor CV_DEFAULT(1.));\r
+\r
+#define CV_SORT_EVERY_ROW 0\r
+#define CV_SORT_EVERY_COLUMN 1\r
+#define CV_SORT_ASCENDING 0\r
+#define CV_SORT_DESCENDING 16\r
+\r
+CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),\r
+ CvArr* idxmat CV_DEFAULT(NULL),\r
+ int flags CV_DEFAULT(0));\r
+\r
+/* Finds real roots of a cubic equation */\r
+CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );\r
+\r
+/* Finds all real and complex roots of a polynomial equation */\r
+CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2,\r
+ int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));\r
+\r
+/****************************************************************************************\\r
+* Matrix operations *\r
+\****************************************************************************************/\r
+\r
+/* Calculates cross product of two 3d vectors */\r
+CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );\r
+\r
+/* Matrix transform: dst = A*B + C, C is optional */\r
+#define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 )\r
+#define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst))\r
+\r
+#define CV_GEMM_A_T 1\r
+#define CV_GEMM_B_T 2\r
+#define CV_GEMM_C_T 4\r
+/* Extended matrix transform:\r
+ dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */\r
+CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha,\r
+ const CvArr* src3, double beta, CvArr* dst,\r
+ int tABC CV_DEFAULT(0));\r
+#define cvMatMulAddEx cvGEMM\r
+\r
+/* Transforms each element of source array and stores\r
+ resultant vectors in destination array */\r
+CVAPI(void) cvTransform( const CvArr* src, CvArr* dst,\r
+ const CvMat* transmat,\r
+ const CvMat* shiftvec CV_DEFAULT(NULL));\r
+#define cvMatMulAddS cvTransform\r
+\r
+/* Does perspective transform on every element of input array */\r
+CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst,\r
+ const CvMat* mat );\r
+\r
+/* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */\r
+CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order,\r
+ const CvArr* delta CV_DEFAULT(NULL),\r
+ double scale CV_DEFAULT(1.) );\r
+\r
+/* Tranposes matrix. Square matrices can be transposed in-place */\r
+CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );\r
+#define cvT cvTranspose\r
+\r
+/* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */\r
+CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );\r
+\r
+/* Mirror array data around horizontal (flip=0),\r
+ vertical (flip=1) or both(flip=-1) axises:\r
+ cvFlip(src) flips images vertically and sequences horizontally (inplace) */\r
+CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),\r
+ int flip_mode CV_DEFAULT(0));\r
+#define cvMirror cvFlip\r
+\r
+\r
+#define CV_SVD_MODIFY_A 1\r
+#define CV_SVD_U_T 2\r
+#define CV_SVD_V_T 4\r
+\r
+/* Performs Singular Value Decomposition of a matrix */\r
+CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL),\r
+ CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));\r
+\r
+/* Performs Singular Value Back Substitution (solves A*X = B):\r
+ flags must be the same as in cvSVD */\r
+CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U,\r
+ const CvArr* V, const CvArr* B,\r
+ CvArr* X, int flags );\r
+\r
+#define CV_LU 0\r
+#define CV_SVD 1\r
+#define CV_SVD_SYM 2\r
+#define CV_CHOLESKY 3\r
+#define CV_QR 4\r
+#define CV_NORMAL 16\r
+\r
+/* Inverts matrix */\r
+CVAPI(double) cvInvert( const CvArr* src, CvArr* dst,\r
+ int method CV_DEFAULT(CV_LU));\r
+#define cvInv cvInvert\r
+\r
+/* Solves linear system (src1)*(dst) = (src2)\r
+ (returns 0 if src1 is a singular and CV_LU method is used) */\r
+CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst,\r
+ int method CV_DEFAULT(CV_LU));\r
+\r
+/* Calculates determinant of input matrix */\r
+CVAPI(double) cvDet( const CvArr* mat );\r
+\r
+/* Calculates trace of the matrix (sum of elements on the main diagonal) */\r
+CVAPI(CvScalar) cvTrace( const CvArr* mat );\r
+\r
+/* Finds eigen values and vectors of a symmetric matrix */\r
+CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,\r
+ double eps CV_DEFAULT(0),\r
+ int lowindex CV_DEFAULT(-1),\r
+ int highindex CV_DEFAULT(-1));\r
+\r
+///* Finds selected eigen values and vectors of a symmetric matrix */\r
+//CVAPI(void) cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,\r
+// int lowindex, int highindex );\r
+\r
+/* Makes an identity matrix (mat_ij = i == j) */\r
+CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );\r
+\r
+/* Fills matrix with given range of numbers */\r
+CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );\r
+\r
+/* Calculates covariation matrix for a set of vectors */\r
+/* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */\r
+#define CV_COVAR_SCRAMBLED 0\r
+\r
+/* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */\r
+#define CV_COVAR_NORMAL 1\r
+\r
+/* do not calc average (i.e. mean vector) - use the input vector instead\r
+ (useful for calculating covariance matrix by parts) */\r
+#define CV_COVAR_USE_AVG 2\r
+\r
+/* scale the covariance matrix coefficients by number of the vectors */\r
+#define CV_COVAR_SCALE 4\r
+\r
+/* all the input vectors are stored in a single matrix, as its rows */\r
+#define CV_COVAR_ROWS 8\r
+\r
+/* all the input vectors are stored in a single matrix, as its columns */\r
+#define CV_COVAR_COLS 16\r
+\r
+CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,\r
+ CvArr* cov_mat, CvArr* avg, int flags );\r
+\r
+#define CV_PCA_DATA_AS_ROW 0\r
+#define CV_PCA_DATA_AS_COL 1\r
+#define CV_PCA_USE_AVG 2\r
+CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,\r
+ CvArr* eigenvals, CvArr* eigenvects, int flags );\r
+\r
+CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,\r
+ const CvArr* eigenvects, CvArr* result );\r
+\r
+CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,\r
+ const CvArr* eigenvects, CvArr* result );\r
+\r
+/* Calculates Mahalanobis(weighted) distance */\r
+CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );\r
+#define cvMahalonobis cvMahalanobis\r
+\r
+/****************************************************************************************\\r
+* Array Statistics *\r
+\****************************************************************************************/\r
+\r
+/* Finds sum of array elements */\r
+CVAPI(CvScalar) cvSum( const CvArr* arr );\r
+\r
+/* Calculates number of non-zero pixels */\r
+CVAPI(int) cvCountNonZero( const CvArr* arr );\r
+\r
+/* Calculates mean value of array elements */\r
+CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+/* Calculates mean and standard deviation of pixel values */\r
+CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev,\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+/* Finds global minimum, maximum and their positions */\r
+CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,\r
+ CvPoint* min_loc CV_DEFAULT(NULL),\r
+ CvPoint* max_loc CV_DEFAULT(NULL),\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+/* types of array norm */\r
+#define CV_C 1\r
+#define CV_L1 2\r
+#define CV_L2 4\r
+#define CV_NORM_MASK 7\r
+#define CV_RELATIVE 8\r
+#define CV_DIFF 16\r
+#define CV_MINMAX 32\r
+\r
+#define CV_DIFF_C (CV_DIFF | CV_C)\r
+#define CV_DIFF_L1 (CV_DIFF | CV_L1)\r
+#define CV_DIFF_L2 (CV_DIFF | CV_L2)\r
+#define CV_RELATIVE_C (CV_RELATIVE | CV_C)\r
+#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)\r
+#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)\r
+\r
+/* Finds norm, difference norm or relative difference norm for an array (or two arrays) */\r
+CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL),\r
+ int norm_type CV_DEFAULT(CV_L2),\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst,\r
+ double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),\r
+ int norm_type CV_DEFAULT(CV_L2),\r
+ const CvArr* mask CV_DEFAULT(NULL) );\r
+\r
+\r
+#define CV_REDUCE_SUM 0\r
+#define CV_REDUCE_AVG 1\r
+#define CV_REDUCE_MAX 2\r
+#define CV_REDUCE_MIN 3\r
+\r
+CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),\r
+ int op CV_DEFAULT(CV_REDUCE_SUM) );\r
+\r
+/****************************************************************************************\\r
+* Discrete Linear Transforms and Related Functions *\r
+\****************************************************************************************/\r
+\r
+#define CV_DXT_FORWARD 0\r
+#define CV_DXT_INVERSE 1\r
+#define CV_DXT_SCALE 2 /* divide result by size of array */\r
+#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)\r
+#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE\r
+#define CV_DXT_ROWS 4 /* transform each row individually */\r
+#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */\r
+\r
+/* Discrete Fourier Transform:\r
+ complex->complex,\r
+ real->ccs (forward),\r
+ ccs->real (inverse) */\r
+CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags,\r
+ int nonzero_rows CV_DEFAULT(0) );\r
+#define cvFFT cvDFT\r
+\r
+/* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */\r
+CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2,\r
+ CvArr* dst, int flags );\r
+\r
+/* Finds optimal DFT vector size >= size0 */\r
+CVAPI(int) cvGetOptimalDFTSize( int size0 );\r
+\r
+/* Discrete Cosine Transform */\r
+CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );\r
+\r
+/****************************************************************************************\\r
+* Dynamic data structures *\r
+\****************************************************************************************/\r
+\r
+/* Calculates length of sequence slice (with support of negative indices). */\r
+CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );\r
+\r
+\r
+/* Creates new memory storage.\r
+ block_size == 0 means that default,\r
+ somewhat optimal size, is used (currently, it is 64K) */\r
+CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));\r
+\r
+\r
+/* Creates a memory storage that will borrow memory blocks from parent storage */\r
+CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );\r
+\r
+\r
+/* Releases memory storage. All the children of a parent must be released before\r
+ the parent. A child storage returns all the blocks to parent when it is released */\r
+CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );\r
+\r
+\r
+/* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)\r
+ to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...\r
+ do not free any memory.\r
+ A child storage returns all the blocks to the parent when it is cleared */\r
+CVAPI(void) cvClearMemStorage( CvMemStorage* storage );\r
+\r
+/* Remember a storage "free memory" position */\r
+CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );\r
+\r
+/* Restore a storage "free memory" position */\r
+CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );\r
+\r
+/* Allocates continuous buffer of the specified size in the storage */\r
+CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );\r
+\r
+/* Allocates string in memory storage */\r
+CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,\r
+ int len CV_DEFAULT(-1) );\r
+\r
+/* Creates new empty sequence that will reside in the specified storage */\r
+CVAPI(CvSeq*) cvCreateSeq( int seq_flags, int header_size,\r
+ int elem_size, CvMemStorage* storage );\r
+\r
+/* Changes default size (granularity) of sequence blocks.\r
+ The default size is ~1Kbyte */\r
+CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );\r
+\r
+\r
+/* Adds new element to the end of sequence. Returns pointer to the element */\r
+CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));\r
+\r
+\r
+/* Adds new element to the beginning of sequence. Returns pointer to it */\r
+CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));\r
+\r
+\r
+/* Removes the last element from sequence and optionally saves it */\r
+CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));\r
+\r
+\r
+/* Removes the first element from sequence and optioanally saves it */\r
+CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));\r
+\r
+\r
+#define CV_FRONT 1\r
+#define CV_BACK 0\r
+/* Adds several new elements to the end of sequence */\r
+CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements,\r
+ int count, int in_front CV_DEFAULT(0) );\r
+\r
+/* Removes several elements from the end of sequence and optionally saves them */\r
+CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements,\r
+ int count, int in_front CV_DEFAULT(0) );\r
+\r
+/* Inserts a new element in the middle of sequence.\r
+ cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */\r
+CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,\r
+ const void* element CV_DEFAULT(NULL));\r
+\r
+/* Removes specified sequence element */\r
+CVAPI(void) cvSeqRemove( CvSeq* seq, int index );\r
+\r
+\r
+/* Removes all the elements from the sequence. The freed memory\r
+ can be reused later only by the same sequence unless cvClearMemStorage\r
+ or cvRestoreMemStoragePos is called */\r
+CVAPI(void) cvClearSeq( CvSeq* seq );\r
+\r
+\r
+/* Retrieves pointer to specified sequence element.\r
+ Negative indices are supported and mean counting from the end\r
+ (e.g -1 means the last sequence element) */\r
+CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );\r
+\r
+/* Calculates index of the specified sequence element.\r
+ Returns -1 if element does not belong to the sequence */\r
+CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,\r
+ CvSeqBlock** block CV_DEFAULT(NULL) );\r
+\r
+/* Initializes sequence writer. The new elements will be added to the end of sequence */\r
+CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );\r
+\r
+\r
+/* Combination of cvCreateSeq and cvStartAppendToSeq */\r
+CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size,\r
+ int elem_size, CvMemStorage* storage,\r
+ CvSeqWriter* writer );\r
+\r
+/* Closes sequence writer, updates sequence header and returns pointer\r
+ to the resultant sequence\r
+ (which may be useful if the sequence was created using cvStartWriteSeq))\r
+*/\r
+CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );\r
+\r
+\r
+/* Updates sequence header. May be useful to get access to some of previously\r
+ written elements via cvGetSeqElem or sequence reader */\r
+CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );\r
+\r
+\r
+/* Initializes sequence reader.\r
+ The sequence can be read in forward or backward direction */\r
+CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader,\r
+ int reverse CV_DEFAULT(0) );\r
+\r
+\r
+/* Returns current sequence reader position (currently observed sequence element) */\r
+CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );\r
+\r
+\r
+/* Changes sequence reader position. It may seek to an absolute or\r
+ to relative to the current position */\r
+CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index,\r
+ int is_relative CV_DEFAULT(0));\r
+\r
+/* Copies sequence content to a continuous piece of memory */\r
+CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,\r
+ CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );\r
+\r
+/* Creates sequence header for array.\r
+ After that all the operations on sequences that do not alter the content\r
+ can be applied to the resultant sequence */\r
+CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,\r
+ int elem_size, void* elements, int total,\r
+ CvSeq* seq, CvSeqBlock* block );\r
+\r
+/* Extracts sequence slice (with or without copying sequence elements) */\r
+CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,\r
+ CvMemStorage* storage CV_DEFAULT(NULL),\r
+ int copy_data CV_DEFAULT(0));\r
+\r
+CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))\r
+{\r
+ return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );\r
+}\r
+\r
+/* Removes sequence slice */\r
+CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );\r
+\r
+/* Inserts a sequence or array into another sequence */\r
+CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );\r
+\r
+/* a < b ? -1 : a > b ? 1 : 0 */\r
+typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata );\r
+\r
+/* Sorts sequence in-place given element comparison function */\r
+CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );\r
+\r
+/* Finds element in a [sorted] sequence */\r
+CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,\r
+ int is_sorted, int* elem_idx,\r
+ void* userdata CV_DEFAULT(NULL) );\r
+\r
+/* Reverses order of sequence elements in-place */\r
+CVAPI(void) cvSeqInvert( CvSeq* seq );\r
+\r
+/* Splits sequence into one or more equivalence classes using the specified criteria */\r
+CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,\r
+ CvSeq** labels, CvCmpFunc is_equal, void* userdata );\r
+\r
+/************ Internal sequence functions ************/\r
+CVAPI(void) cvChangeSeqBlock( void* reader, int direction );\r
+CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );\r
+\r
+\r
+/* Creates a new set */\r
+CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size,\r
+ int elem_size, CvMemStorage* storage );\r
+\r
+/* Adds new element to the set and returns pointer to it */\r
+CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL),\r
+ CvSetElem** inserted_elem CV_DEFAULT(NULL) );\r
+\r
+/* Fast variant of cvSetAdd */\r
+CV_INLINE CvSetElem* cvSetNew( CvSet* set_header )\r
+{\r
+ CvSetElem* elem = set_header->free_elems;\r
+ if( elem )\r
+ {\r
+ set_header->free_elems = elem->next_free;\r
+ elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;\r
+ set_header->active_count++;\r
+ }\r
+ else\r
+ cvSetAdd( set_header, NULL, (CvSetElem**)&elem );\r
+ return elem;\r
+}\r
+\r
+/* Removes set element given its pointer */\r
+CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem )\r
+{\r
+ CvSetElem* _elem = (CvSetElem*)elem;\r
+ assert( _elem->flags >= 0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/ );\r
+ _elem->next_free = set_header->free_elems;\r
+ _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;\r
+ set_header->free_elems = _elem;\r
+ set_header->active_count--;\r
+}\r
+\r
+/* Removes element from the set by its index */\r
+CVAPI(void) cvSetRemove( CvSet* set_header, int index );\r
+\r
+/* Returns a set element by index. If the element doesn't belong to the set,\r
+ NULL is returned */\r
+CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int index )\r
+{\r
+ CvSetElem* elem = (CvSetElem*)cvGetSeqElem( (CvSeq*)set_header, index );\r
+ return elem && CV_IS_SET_ELEM( elem ) ? elem : 0;\r
+}\r
+\r
+/* Removes all the elements from the set */\r
+CVAPI(void) cvClearSet( CvSet* set_header );\r
+\r
+/* Creates new graph */\r
+CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size,\r
+ int vtx_size, int edge_size,\r
+ CvMemStorage* storage );\r
+\r
+/* Adds new vertex to the graph */\r
+CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL),\r
+ CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );\r
+\r
+\r
+/* Removes vertex from the graph together with all incident edges */\r
+CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );\r
+CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );\r
+\r
+\r
+/* Link two vertices specifed by indices or pointers if they\r
+ are not connected or return pointer to already existing edge\r
+ connecting the vertices.\r
+ Functions return 1 if a new edge was created, 0 otherwise */\r
+CVAPI(int) cvGraphAddEdge( CvGraph* graph,\r
+ int start_idx, int end_idx,\r
+ const CvGraphEdge* edge CV_DEFAULT(NULL),\r
+ CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );\r
+\r
+CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph,\r
+ CvGraphVtx* start_vtx, CvGraphVtx* end_vtx,\r
+ const CvGraphEdge* edge CV_DEFAULT(NULL),\r
+ CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );\r
+\r
+/* Remove edge connecting two vertices */\r
+CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );\r
+CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx,\r
+ CvGraphVtx* end_vtx );\r
+\r
+/* Find edge connecting two vertices */\r
+CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );\r
+CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph,\r
+ const CvGraphVtx* start_vtx,\r
+ const CvGraphVtx* end_vtx );\r
+#define cvGraphFindEdge cvFindGraphEdge\r
+#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr\r
+\r
+/* Remove all vertices and edges from the graph */\r
+CVAPI(void) cvClearGraph( CvGraph* graph );\r
+\r
+\r
+/* Count number of edges incident to the vertex */\r
+CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );\r
+CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );\r
+\r
+\r
+/* Retrieves graph vertex by given index */\r
+#define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx))\r
+\r
+/* Retrieves index of a graph vertex given its pointer */\r
+#define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)\r
+\r
+/* Retrieves index of a graph edge given its pointer */\r
+#define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK)\r
+\r
+#define cvGraphGetVtxCount( graph ) ((graph)->active_count)\r
+#define cvGraphGetEdgeCount( graph ) ((graph)->edges->active_count)\r
+\r
+#define CV_GRAPH_VERTEX 1\r
+#define CV_GRAPH_TREE_EDGE 2\r
+#define CV_GRAPH_BACK_EDGE 4\r
+#define CV_GRAPH_FORWARD_EDGE 8\r
+#define CV_GRAPH_CROSS_EDGE 16\r
+#define CV_GRAPH_ANY_EDGE 30\r
+#define CV_GRAPH_NEW_TREE 32\r
+#define CV_GRAPH_BACKTRACKING 64\r
+#define CV_GRAPH_OVER -1\r
+\r
+#define CV_GRAPH_ALL_ITEMS -1\r
+\r
+/* flags for graph vertices and edges */\r
+#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)\r
+#define CV_IS_GRAPH_VERTEX_VISITED(vtx) \\r
+ (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)\r
+#define CV_IS_GRAPH_EDGE_VISITED(edge) \\r
+ (((CvGraphEdge*)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)\r
+#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)\r
+#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)\r
+\r
+typedef struct CvGraphScanner\r
+{\r
+ CvGraphVtx* vtx; /* current graph vertex (or current edge origin) */\r
+ CvGraphVtx* dst; /* current graph edge destination vertex */\r
+ CvGraphEdge* edge; /* current edge */\r
+\r
+ CvGraph* graph; /* the graph */\r
+ CvSeq* stack; /* the graph vertex stack */\r
+ int index; /* the lower bound of certainly visited vertices */\r
+ int mask; /* event mask */\r
+}\r
+CvGraphScanner;\r
+\r
+/* Creates new graph scanner. */\r
+CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph,\r
+ CvGraphVtx* vtx CV_DEFAULT(NULL),\r
+ int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));\r
+\r
+/* Releases graph scanner. */\r
+CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );\r
+\r
+/* Get next graph element */\r
+CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );\r
+\r
+/* Creates a copy of graph */\r
+CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );\r
+\r
+/****************************************************************************************\\r
+* Drawing *\r
+\****************************************************************************************/\r
+\r
+/****************************************************************************************\\r
+* Drawing functions work with images/matrices of arbitrary type. *\r
+* For color images the channel order is BGR[A] *\r
+* Antialiasing is supported only for 8-bit image now. *\r
+* All the functions include parameter color that means rgb value (that may be *\r
+* constructed with CV_RGB macro) for color images and brightness *\r
+* for grayscale images. *\r
+* If a drawn figure is partially or completely outside of the image, it is clipped.*\r
+\****************************************************************************************/\r
+\r
+#define CV_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 )\r
+#define CV_FILLED -1\r
+\r
+#define CV_AA 16\r
+\r
+/* Draws 4-connected, 8-connected or antialiased line segment connecting two points */\r
+CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,\r
+ CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );\r
+\r
+/* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),\r
+ if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */\r
+CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,\r
+ CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8),\r
+ int shift CV_DEFAULT(0));\r
+\r
+/* Draws a rectangle specified by a CvRect structure */\r
+CVAPI(void) cvRectangleR( CvArr* img, CvRect r,\r
+ CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8),\r
+ int shift CV_DEFAULT(0));\r
+ \r
+ \r
+/* Draws a circle with specified center and radius.\r
+ Thickness works in the same way as with cvRectangle */\r
+CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius,\r
+ CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));\r
+\r
+/* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,\r
+ depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure\r
+ is rotated by <angle>. All the angles are in degrees */\r
+CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,\r
+ double angle, double start_angle, double end_angle,\r
+ CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));\r
+\r
+CV_INLINE void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,\r
+ int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )\r
+{\r
+ CvSize axes;\r
+ axes.width = cvRound(box.size.width*0.5);\r
+ axes.height = cvRound(box.size.height*0.5);\r
+\r
+ cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,\r
+ 0, 360, color, thickness, line_type, shift );\r
+}\r
+\r
+/* Fills convex or monotonous polygon. */\r
+CVAPI(void) cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));\r
+\r
+/* Fills an area bounded by one or more arbitrary polygons */\r
+CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,\r
+ int contours, CvScalar color,\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );\r
+\r
+/* Draws one or more polygonal curves */\r
+CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours,\r
+ int is_closed, CvScalar color, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );\r
+\r
+#define cvDrawRect cvRectangle\r
+#define cvDrawLine cvLine\r
+#define cvDrawCircle cvCircle\r
+#define cvDrawEllipse cvEllipse\r
+#define cvDrawPolyLine cvPolyLine\r
+\r
+/* Clips the line segment connecting *pt1 and *pt2\r
+ by the rectangular window\r
+ (0<=x<img_size.width, 0<=y<img_size.height). */\r
+CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );\r
+\r
+/* Initializes line iterator. Initially, line_iterator->ptr will point\r
+ to pt1 (or pt2, see left_to_right description) location in the image.\r
+ Returns the number of pixels on the line between the ending points. */\r
+CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,\r
+ CvLineIterator* line_iterator,\r
+ int connectivity CV_DEFAULT(8),\r
+ int left_to_right CV_DEFAULT(0));\r
+\r
+/* Moves iterator to the next line point */\r
+#define CV_NEXT_LINE_POINT( line_iterator ) \\r
+{ \\r
+ int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \\r
+ (line_iterator).err += (line_iterator).minus_delta + \\r
+ ((line_iterator).plus_delta & _line_iterator_mask); \\r
+ (line_iterator).ptr += (line_iterator).minus_step + \\r
+ ((line_iterator).plus_step & _line_iterator_mask); \\r
+}\r
+\r
+\r
+/* basic font types */\r
+#define CV_FONT_HERSHEY_SIMPLEX 0\r
+#define CV_FONT_HERSHEY_PLAIN 1\r
+#define CV_FONT_HERSHEY_DUPLEX 2\r
+#define CV_FONT_HERSHEY_COMPLEX 3\r
+#define CV_FONT_HERSHEY_TRIPLEX 4\r
+#define CV_FONT_HERSHEY_COMPLEX_SMALL 5\r
+#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6\r
+#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7\r
+\r
+/* font flags */\r
+#define CV_FONT_ITALIC 16\r
+\r
+#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX\r
+\r
+/* Font structure */\r
+typedef struct CvFont\r
+{\r
+ int font_face; /* =CV_FONT_* */\r
+ const int* ascii; /* font data and metrics */\r
+ const int* greek;\r
+ const int* cyrillic;\r
+ float hscale, vscale;\r
+ float shear; /* slope coefficient: 0 - normal, >0 - italic */\r
+ int thickness; /* letters thickness */\r
+ float dx; /* horizontal interval between letters */\r
+ int line_type;\r
+}\r
+CvFont;\r
+\r
+/* Initializes font structure used further in cvPutText */\r
+CVAPI(void) cvInitFont( CvFont* font, int font_face,\r
+ double hscale, double vscale,\r
+ double shear CV_DEFAULT(0),\r
+ int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8));\r
+\r
+CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )\r
+{\r
+ CvFont font;\r
+ cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );\r
+ return font;\r
+}\r
+\r
+/* Renders text stroke with specified font and color at specified location.\r
+ CvFont should be initialized with cvInitFont */\r
+CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org,\r
+ const CvFont* font, CvScalar color );\r
+\r
+/* Calculates bounding box of text stroke (useful for alignment) */\r
+CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font,\r
+ CvSize* text_size, int* baseline );\r
+\r
+/* Unpacks color value, if arrtype is CV_8UC?, <color> is treated as\r
+ packed color value, otherwise the first channels (depending on arrtype)\r
+ of destination scalar are set to the same value = <color> */\r
+CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype );\r
+\r
+/* Returns the polygon points which make up the given ellipse. The ellipse is define by\r
+ the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep\r
+ of the ellipse arc can be done by spcifying arc_start and arc_end to be something\r
+ other than 0 and 360, respectively. The input array 'pts' must be large enough to\r
+ hold the result. The total number of points stored into 'pts' is returned by this\r
+ function. */\r
+CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,\r
+ int angle, int arc_start, int arc_end, CvPoint * pts, int delta );\r
+\r
+/* Draws contour outlines or filled interiors on the image */\r
+CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour,\r
+ CvScalar external_color, CvScalar hole_color,\r
+ int max_level, int thickness CV_DEFAULT(1),\r
+ int line_type CV_DEFAULT(8),\r
+ CvPoint offset CV_DEFAULT(cvPoint(0,0)));\r
+\r
+/* Does look-up transformation. Elements of the source array\r
+ (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */\r
+CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );\r
+\r
+\r
+/******************* Iteration through the sequence tree *****************/\r
+typedef struct CvTreeNodeIterator\r
+{\r
+ const void* node;\r
+ int level;\r
+ int max_level;\r
+}\r
+CvTreeNodeIterator;\r
+\r
+CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator,\r
+ const void* first, int max_level );\r
+CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );\r
+CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );\r
+\r
+/* Inserts sequence into tree with specified "parent" sequence.\r
+ If parent is equal to frame (e.g. the most external contour),\r
+ then added contour will have null pointer to parent. */\r
+CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );\r
+\r
+/* Removes contour from tree (together with the contour children). */\r
+CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );\r
+\r
+/* Gathers pointers to all the sequences,\r
+ accessible from the <first>, to the single sequence */\r
+CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size,\r
+ CvMemStorage* storage );\r
+\r
+/* The function implements the K-means algorithm for clustering an array of sample\r
+ vectors in a specified number of classes */\r
+#define CV_KMEANS_USE_INITIAL_LABELS 1\r
+CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels,\r
+ CvTermCriteria termcrit, int attempts CV_DEFAULT(1),\r
+ CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0),\r
+ CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );\r
+\r
+/****************************************************************************************\\r
+* System functions *\r
+\****************************************************************************************/\r
+\r
+/* Add the function pointers table with associated information to the IPP primitives list */\r
+CVAPI(int) cvRegisterModule( const CvModuleInfo* module_info );\r
+\r
+/* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */\r
+CVAPI(int) cvUseOptimized( int on_off );\r
+\r
+/* Retrieves information about the registered modules and loaded optimized plugins */\r
+CVAPI(void) cvGetModuleInfo( const char* module_name,\r
+ const char** version,\r
+ const char** loaded_addon_plugins );\r
+\r
+/* Get current OpenCV error status */\r
+CVAPI(int) cvGetErrStatus( void );\r
+\r
+/* Sets error status silently */\r
+CVAPI(void) cvSetErrStatus( int status );\r
+\r
+#define CV_ErrModeLeaf 0 /* Print error and exit program */\r
+#define CV_ErrModeParent 1 /* Print error and continue */\r
+#define CV_ErrModeSilent 2 /* Don't print and continue */\r
+\r
+/* Retrives current error processing mode */\r
+CVAPI(int) cvGetErrMode( void );\r
+\r
+/* Sets error processing mode, returns previously used mode */\r
+CVAPI(int) cvSetErrMode( int mode );\r
+\r
+/* Sets error status and performs some additonal actions (displaying message box,\r
+ writing message to stderr, terminating application etc.)\r
+ depending on the current error mode */\r
+CVAPI(void) cvError( int status, const char* func_name,\r
+ const char* err_msg, const char* file_name, int line );\r
+\r
+/* Retrieves textual description of the error given its code */\r
+CVAPI(const char*) cvErrorStr( int status );\r
+\r
+/* Retrieves detailed information about the last error occured */\r
+CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description,\r
+ const char** filename, int* line );\r
+\r
+/* Maps IPP error codes to the counterparts from OpenCV */\r
+CVAPI(int) cvErrorFromIppStatus( int ipp_status );\r
+\r
+typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name,\r
+ const char* err_msg, const char* file_name, int line, void* userdata );\r
+\r
+/* Assigns a new error-handling function */\r
+CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler,\r
+ void* userdata CV_DEFAULT(NULL),\r
+ void** prev_userdata CV_DEFAULT(NULL) );\r
+\r
+/*\r
+ Output to:\r
+ cvNulDevReport - nothing\r
+ cvStdErrReport - console(fprintf(stderr,...))\r
+ cvGuiBoxReport - MessageBox(WIN32)\r
+*/\r
+CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg,\r
+ const char* file_name, int line, void* userdata );\r
+\r
+CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg,\r
+ const char* file_name, int line, void* userdata );\r
+\r
+CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg,\r
+ const char* file_name, int line, void* userdata );\r
+\r
+typedef void* (CV_CDECL *CvAllocFunc)(size_t size, void* userdata);\r
+typedef int (CV_CDECL *CvFreeFunc)(void* pptr, void* userdata);\r
+\r
+/* Set user-defined memory managment functions (substitutors for malloc and free) that\r
+ will be called by cvAlloc, cvFree and higher-level functions (e.g. cvCreateImage) */\r
+CVAPI(void) cvSetMemoryManager( CvAllocFunc alloc_func CV_DEFAULT(NULL),\r
+ CvFreeFunc free_func CV_DEFAULT(NULL),\r
+ void* userdata CV_DEFAULT(NULL));\r
+\r
+\r
+typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader)\r
+ (int,int,int,char*,char*,int,int,int,int,int,\r
+ IplROI*,IplImage*,void*,IplTileInfo*);\r
+typedef void (CV_STDCALL* Cv_iplAllocateImageData)(IplImage*,int,int);\r
+typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int);\r
+typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int);\r
+typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*);\r
+\r
+/* Makes OpenCV use IPL functions for IplImage allocation/deallocation */\r
+CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header,\r
+ Cv_iplAllocateImageData allocate_data,\r
+ Cv_iplDeallocate deallocate,\r
+ Cv_iplCreateROI create_roi,\r
+ Cv_iplCloneImage clone_image );\r
+\r
+#define CV_TURN_ON_IPL_COMPATIBILITY() \\r
+ cvSetIPLAllocators( iplCreateImageHeader, iplAllocateImage, \\r
+ iplDeallocate, iplCreateROI, iplCloneImage )\r
+\r
+/****************************************************************************************\\r
+* Data Persistence *\r
+\****************************************************************************************/\r
+\r
+/********************************** High-level functions ********************************/\r
+\r
+/* opens existing or creates new file storage */\r
+CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename,\r
+ CvMemStorage* memstorage,\r
+ int flags );\r
+\r
+/* closes file storage and deallocates buffers */\r
+CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );\r
+\r
+/* returns attribute value or 0 (NULL) if there is no such attribute */\r
+CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );\r
+\r
+/* starts writing compound structure (map or sequence) */\r
+CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,\r
+ int struct_flags, const char* type_name CV_DEFAULT(NULL),\r
+ CvAttrList attributes CV_DEFAULT(cvAttrList()));\r
+\r
+/* finishes writing compound structure */\r
+CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );\r
+\r
+/* writes an integer */\r
+CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );\r
+\r
+/* writes a floating-point number */\r
+CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );\r
+\r
+/* writes a string */\r
+CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,\r
+ const char* str, int quote CV_DEFAULT(0) );\r
+\r
+/* writes a comment */\r
+CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,\r
+ int eol_comment );\r
+\r
+/* writes instance of a standard type (matrix, image, sequence, graph etc.)\r
+ or user-defined type */\r
+CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,\r
+ CvAttrList attributes CV_DEFAULT(cvAttrList()));\r
+\r
+/* starts the next stream */\r
+CVAPI(void) cvStartNextStream( CvFileStorage* fs );\r
+\r
+/* helper function: writes multiple integer or floating-point numbers */\r
+CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,\r
+ int len, const char* dt );\r
+\r
+/* returns the hash entry corresponding to the specified literal key string or 0\r
+ if there is no such a key in the storage */\r
+CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,\r
+ int len CV_DEFAULT(-1),\r
+ int create_missing CV_DEFAULT(0));\r
+\r
+/* returns file node with the specified key within the specified map\r
+ (collection of named nodes) */\r
+CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,\r
+ int stream_index CV_DEFAULT(0) );\r
+\r
+/* returns file node with the specified key within the specified map\r
+ (collection of named nodes) */\r
+CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,\r
+ const CvStringHashNode* key,\r
+ int create_missing CV_DEFAULT(0) );\r
+\r
+/* this is a slower version of cvGetFileNode that takes the key as a literal string */\r
+CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,\r
+ const CvFileNode* map,\r
+ const char* name );\r
+\r
+CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )\r
+{\r
+ return !node ? default_value :\r
+ CV_NODE_IS_INT(node->tag) ? node->data.i :\r
+ CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;\r
+}\r
+\r
+\r
+CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,\r
+ const char* name, int default_value CV_DEFAULT(0) )\r
+{\r
+ return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );\r
+}\r
+\r
+\r
+CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )\r
+{\r
+ return !node ? default_value :\r
+ CV_NODE_IS_INT(node->tag) ? (double)node->data.i :\r
+ CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;\r
+}\r
+\r
+\r
+CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,\r
+ const char* name, double default_value CV_DEFAULT(0.) )\r
+{\r
+ return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );\r
+}\r
+\r
+\r
+CV_INLINE const char* cvReadString( const CvFileNode* node,\r
+ const char* default_value CV_DEFAULT(NULL) )\r
+{\r
+ return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;\r
+}\r
+\r
+\r
+CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,\r
+ const char* name, const char* default_value CV_DEFAULT(NULL) )\r
+{\r
+ return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );\r
+}\r
+\r
+\r
+/* decodes standard or user-defined object and returns it */\r
+CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,\r
+ CvAttrList* attributes CV_DEFAULT(NULL));\r
+\r
+/* decodes standard or user-defined object and returns it */\r
+CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,\r
+ const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )\r
+{\r
+ return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );\r
+}\r
+\r
+\r
+/* starts reading data from sequence or scalar numeric node */\r
+CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,\r
+ CvSeqReader* reader );\r
+\r
+/* reads multiple numbers and stores them to array */\r
+CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,\r
+ int count, void* dst, const char* dt );\r
+\r
+/* combination of two previous functions for easier reading of whole sequences */\r
+CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,\r
+ void* dst, const char* dt );\r
+\r
+/* writes a copy of file node to file storage */\r
+CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,\r
+ const CvFileNode* node, int embed );\r
+\r
+/* returns name of file node */\r
+CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );\r
+\r
+/*********************************** Adding own types ***********************************/\r
+\r
+CVAPI(void) cvRegisterType( const CvTypeInfo* info );\r
+CVAPI(void) cvUnregisterType( const char* type_name );\r
+CVAPI(CvTypeInfo*) cvFirstType(void);\r
+CVAPI(CvTypeInfo*) cvFindType( const char* type_name );\r
+CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );\r
+\r
+/* universal functions */\r
+CVAPI(void) cvRelease( void** struct_ptr );\r
+CVAPI(void*) cvClone( const void* struct_ptr );\r
+\r
+/* simple API for reading/writing data */\r
+CVAPI(void) cvSave( const char* filename, const void* struct_ptr,\r
+ const char* name CV_DEFAULT(NULL),\r
+ const char* comment CV_DEFAULT(NULL),\r
+ CvAttrList attributes CV_DEFAULT(cvAttrList()));\r
+CVAPI(void*) cvLoad( const char* filename,\r
+ CvMemStorage* memstorage CV_DEFAULT(NULL),\r
+ const char* name CV_DEFAULT(NULL),\r
+ const char** real_name CV_DEFAULT(NULL) );\r
+\r
+/*********************************** Measuring Execution Time ***************************/\r
+\r
+/* helper functions for RNG initialization and accurate time measurement:\r
+ uses internal clock counter on x86 */\r
+CVAPI(int64) cvGetTickCount( void );\r
+CVAPI(double) cvGetTickFrequency( void );\r
+\r
+/*********************************** CPU capabilities ***********************************/\r
+\r
+#define CV_CPU_NONE 0 \r
+#define CV_CPU_MMX 1\r
+#define CV_CPU_SSE 2\r
+#define CV_CPU_SSE2 3\r
+#define CV_CPU_SSE3 4\r
+#define CV_CPU_SSSE3 5\r
+#define CV_CPU_SSE4_1 6\r
+#define CV_CPU_SSE4_2 7\r
+#define CV_CPU_AVX 10\r
+#define CV_HARDWARE_MAX_FEATURE 255\r
+\r
+CVAPI(int) cvCheckHardwareSupport(int feature);\r
+\r
+/*********************************** Multi-Threading ************************************/\r
+\r
+/* retrieve/set the number of threads used in OpenMP implementations */\r
+CVAPI(int) cvGetNumThreads( void );\r
+CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );\r
+/* get index of the thread being executed */\r
+CVAPI(int) cvGetThreadNum( void );\r
+ \r
+\r
+#ifdef __cplusplus\r
+}\r
+\r
+// classes for automatic module/RTTI data registration/unregistration\r
+struct CV_EXPORTS CvModule\r
+{\r
+ CvModule( CvModuleInfo* _info );\r
+ ~CvModule();\r
+ CvModuleInfo* info;\r
+\r
+ static CvModuleInfo* first;\r
+ static CvModuleInfo* last;\r
+};\r
+\r
+struct CV_EXPORTS CvType\r
+{\r
+ CvType( const char* type_name,\r
+ CvIsInstanceFunc is_instance, CvReleaseFunc release=0,\r
+ CvReadFunc read=0, CvWriteFunc write=0, CvCloneFunc clone=0 );\r
+ ~CvType();\r
+ CvTypeInfo* info;\r
+\r
+ static CvTypeInfo* first;\r
+ static CvTypeInfo* last;\r
+};\r
+\r
+#endif\r
+\r
+#ifndef SKIP_INCLUDES // for now only expose old interface to swig\r
+#include "cxcore.hpp"\r
+#endif // SKIP_INCLUDES\r
+\r
+#endif\r
projects / opencv.git / blobdiff