+++ /dev/null
-/*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"
-#include "cvver.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, const 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, const 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, const 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, const 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, const 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, const 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 );
-
-CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng,
- double iter_factor CV_DEFAULT(1.));
-
-/* Finds real roots of a cubic equation */
-CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
-
-/* Finds all real and complex roots of a polynomial equation */
-CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots,
- int maxiter = 10, int fig = 10);
-
-/****************************************************************************************\
-* 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),
- double scale CV_DEFAULT(1.) );
-
-/* 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)) );
-
-/* Fills matrix with given range of numbers */
-CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );
-
-/* 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
-
-/* all the input vectors are stored in a single matrix, as its rows */
-#define CV_COVAR_ROWS 8
-
-/* all the input vectors are stored in a single matrix, as its columns */
-#define CV_COVAR_COLS 16
-
-CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count,
- CvArr* cov_mat, CvArr* avg, int flags );
-
-#define CV_PCA_DATA_AS_ROW 0
-#define CV_PCA_DATA_AS_COL 1
-#define CV_PCA_USE_AVG 2
-CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean,
- CvArr* eigenvals, CvArr* eigenvects, int flags );
-
-CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean,
- const CvArr* eigenvects, CvArr* result );
-
-CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean,
- const CvArr* eigenvects, CvArr* result );
-
-/* 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_MINMAX 32
-
-#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) );
-
-CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst,
- double a CV_DEFAULT(1.), double b CV_DEFAULT(0.),
- int norm_type CV_DEFAULT(CV_L2),
- const CvArr* mask CV_DEFAULT(NULL) );
-
-
-#define CV_REDUCE_SUM 0
-#define CV_REDUCE_AVG 1
-#define CV_REDUCE_MAX 2
-#define CV_REDUCE_MIN 3
-
-CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1),
- int op CV_DEFAULT(CV_REDUCE_SUM) );
-
-/****************************************************************************************\
-* 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(schar*) cvSeqPush( CvSeq* seq, void* element CV_DEFAULT(NULL));
-
-
-/* Adds new element to the beginning of sequence. Returns pointer to it */
-CVAPI(schar*) 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(schar*) 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 );
-
-
-/* Retrieves pointer to specified sequence element.
- Negative indices are supported and mean counting from the end
- (e.g -1 means the last sequence element) */
-CVAPI(schar*) 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(schar*) 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,
- 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) );
-
-#define cvDrawRect cvRectangle
-#define cvDrawLine cvLine
-#define cvDrawCircle cvCircle
-#define cvDrawEllipse cvEllipse
-#define cvDrawPolyLine cvPolyLine
-
-/* 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));
-
-CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
-{
- CvFont font;
- cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
- return font;
-}
-
-/* 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( void );
-CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
-/* get index of the thread being executed */
-CVAPI(int) cvGetThreadNum( void );
-
-#ifdef __cplusplus
-}
-
-#include "cxcore.hpp"
-#endif
-
-#endif /*_CXCORE_H_*/
projects / opencv / blobdiff