736 lines
29 KiB
C++
736 lines
29 KiB
C++
/*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 __OPENCV_COMPAT_HPP__
|
|
#define __OPENCV_COMPAT_HPP__
|
|
|
|
#include "opencv2/core/core_c.h"
|
|
#include "opencv2/imgproc/types_c.h"
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
#define CV_NOOP(...)
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef int CvMatType;
|
|
typedef int CvDisMaskType;
|
|
typedef CvMat CvMatArray;
|
|
|
|
typedef int CvThreshType;
|
|
typedef int CvAdaptiveThreshMethod;
|
|
typedef int CvCompareMethod;
|
|
typedef int CvFontFace;
|
|
typedef int CvPolyApproxMethod;
|
|
typedef int CvContoursMatchMethod;
|
|
typedef int CvContourTreesMatchMethod;
|
|
typedef int CvCoeffType;
|
|
typedef int CvRodriguesType;
|
|
typedef int CvElementShape;
|
|
typedef int CvMorphOp;
|
|
typedef int CvTemplMatchMethod;
|
|
|
|
typedef CvPoint2D64f CvPoint2D64d;
|
|
typedef CvPoint3D64f CvPoint3D64d;
|
|
|
|
enum
|
|
{
|
|
CV_MAT32F = CV_32FC1,
|
|
CV_MAT3x1_32F = CV_32FC1,
|
|
CV_MAT4x1_32F = CV_32FC1,
|
|
CV_MAT3x3_32F = CV_32FC1,
|
|
CV_MAT4x4_32F = CV_32FC1,
|
|
|
|
CV_MAT64D = CV_64FC1,
|
|
CV_MAT3x1_64D = CV_64FC1,
|
|
CV_MAT4x1_64D = CV_64FC1,
|
|
CV_MAT3x3_64D = CV_64FC1,
|
|
CV_MAT4x4_64D = CV_64FC1
|
|
};
|
|
|
|
enum
|
|
{
|
|
IPL_GAUSSIAN_5x5 = 7
|
|
};
|
|
|
|
typedef CvBox2D CvBox2D32f;
|
|
|
|
/* allocation/deallocation macros */
|
|
#define cvCreateImageData cvCreateData
|
|
#define cvReleaseImageData cvReleaseData
|
|
#define cvSetImageData cvSetData
|
|
#define cvGetImageRawData cvGetRawData
|
|
|
|
#define cvmAlloc cvCreateData
|
|
#define cvmFree cvReleaseData
|
|
#define cvmAllocArray cvCreateData
|
|
#define cvmFreeArray cvReleaseData
|
|
|
|
#define cvIntegralImage cvIntegral
|
|
#define cvMatchContours cvMatchShapes
|
|
|
|
CV_EXPORTS CvMat cvMatArray( int rows, int cols, int type,
|
|
int count, void* data CV_DEFAULT(0));
|
|
|
|
#define cvUpdateMHIByTime cvUpdateMotionHistory
|
|
|
|
#define cvAccMask cvAcc
|
|
#define cvSquareAccMask cvSquareAcc
|
|
#define cvMultiplyAccMask cvMultiplyAcc
|
|
#define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
|
|
|
|
#define cvSetHistThresh cvSetHistBinRanges
|
|
#define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
|
|
|
|
CV_EXPORTS double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0));
|
|
CV_EXPORTS double cvSumPixels( const CvArr* image );
|
|
CV_EXPORTS void cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
|
|
const CvArr* mask CV_DEFAULT(0));
|
|
|
|
CV_EXPORTS void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst );
|
|
CV_EXPORTS void cvFillImage( CvArr* mat, double color );
|
|
|
|
#define cvCvtPixToPlane cvSplit
|
|
#define cvCvtPlaneToPix cvMerge
|
|
|
|
typedef struct CvRandState
|
|
{
|
|
CvRNG state; /* RNG state (the current seed and carry)*/
|
|
int disttype; /* distribution type */
|
|
CvScalar param[2]; /* parameters of RNG */
|
|
} CvRandState;
|
|
|
|
/* Changes RNG range while preserving RNG state */
|
|
CV_EXPORTS void cvRandSetRange( CvRandState* state, double param1,
|
|
double param2, int index CV_DEFAULT(-1));
|
|
|
|
CV_EXPORTS void cvRandInit( CvRandState* state, double param1,
|
|
double param2, int seed,
|
|
int disttype CV_DEFAULT(CV_RAND_UNI));
|
|
|
|
/* Fills array with random numbers */
|
|
CV_EXPORTS void cvRand( CvRandState* state, CvArr* arr );
|
|
|
|
#define cvRandNext( _state ) cvRandInt( &(_state)->state )
|
|
|
|
CV_EXPORTS void cvbRand( CvRandState* state, float* dst, int len );
|
|
|
|
CV_EXPORTS void cvbCartToPolar( const float* y, const float* x,
|
|
float* magnitude, float* angle, int len );
|
|
CV_EXPORTS void cvbFastArctan( const float* y, const float* x, float* angle, int len );
|
|
CV_EXPORTS void cvbSqrt( const float* x, float* y, int len );
|
|
CV_EXPORTS void cvbInvSqrt( const float* x, float* y, int len );
|
|
CV_EXPORTS void cvbReciprocal( const float* x, float* y, int len );
|
|
CV_EXPORTS void cvbFastExp( const float* x, double* y, int len );
|
|
CV_EXPORTS void cvbFastLog( const double* x, float* y, int len );
|
|
|
|
CV_EXPORTS CvRect cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0));
|
|
|
|
CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
|
|
#define cvPseudoInv cvPseudoInverse
|
|
|
|
#define cvContourMoments( contour, moments ) cvMoments( contour, moments, 0 )
|
|
|
|
#define cvGetPtrAt cvPtr2D
|
|
#define cvGetAt cvGet2D
|
|
#define cvSetAt(arr,val,y,x) cvSet2D((arr),(y),(x),(val))
|
|
|
|
#define cvMeanMask cvMean
|
|
#define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
|
|
|
|
#define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
|
|
|
|
#define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
|
|
cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
|
|
|
|
#define cvRemoveMemoryManager CV_NOOP
|
|
#define cvSetMemoryManager CV_NOOP
|
|
|
|
#define cvmSetZero( mat ) cvSetZero( mat )
|
|
#define cvmSetIdentity( mat ) cvSetIdentity( mat )
|
|
#define cvmAdd( src1, src2, dst ) cvAdd( src1, src2, dst, 0 )
|
|
#define cvmSub( src1, src2, dst ) cvSub( src1, src2, dst, 0 )
|
|
#define cvmCopy( src, dst ) cvCopy( src, dst, 0 )
|
|
#define cvmMul( src1, src2, dst ) cvMatMulAdd( src1, src2, 0, dst )
|
|
#define cvmTranspose( src, dst ) cvT( src, dst )
|
|
#define cvmInvert( src, dst ) cvInv( src, dst )
|
|
#define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
|
|
#define cvmDotProduct( vec1, vec2 ) cvDotProduct( vec1, vec2 )
|
|
#define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
|
|
#define cvmTrace( mat ) (cvTrace( mat )).val[0]
|
|
#define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
|
|
#define cvmEigenVV( mat, evec, eval, eps) cvEigenVV( mat, evec, eval, eps )
|
|
#define cvmDet( mat ) cvDet( mat )
|
|
#define cvmScale( src, dst, scale ) cvScale( src, dst, scale )
|
|
|
|
#define cvCopyImage( src, dst ) cvCopy( src, dst, 0 )
|
|
#define cvReleaseMatHeader cvReleaseMat
|
|
|
|
/* Calculates exact convex hull of 2d point set */
|
|
CV_EXPORTS void cvConvexHull( CvPoint* points, int num_points,
|
|
CvRect* bound_rect,
|
|
int orientation, int* hull, int* hullsize );
|
|
|
|
|
|
CV_EXPORTS void cvMinAreaRect( CvPoint* points, int n,
|
|
int left, int bottom,
|
|
int right, int top,
|
|
CvPoint2D32f* anchor,
|
|
CvPoint2D32f* vect1,
|
|
CvPoint2D32f* vect2 );
|
|
|
|
typedef int CvDisType;
|
|
typedef int CvChainApproxMethod;
|
|
typedef int CvContourRetrievalMode;
|
|
|
|
CV_EXPORTS void cvFitLine3D( CvPoint3D32f* points, int count, int dist,
|
|
void *param, float reps, float aeps, float* line );
|
|
|
|
/* Fits a line into set of 2d points in a robust way (M-estimator technique) */
|
|
CV_EXPORTS void cvFitLine2D( CvPoint2D32f* points, int count, int dist,
|
|
void *param, float reps, float aeps, float* line );
|
|
|
|
CV_EXPORTS void cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box );
|
|
|
|
/* Projects 2d points to one of standard coordinate planes
|
|
(i.e. removes one of coordinates) */
|
|
CV_EXPORTS void cvProject3D( CvPoint3D32f* points3D, int count,
|
|
CvPoint2D32f* points2D,
|
|
int xIndx CV_DEFAULT(0),
|
|
int yIndx CV_DEFAULT(1));
|
|
|
|
/* Retrieves value of the particular bin
|
|
of x-dimensional (x=1,2,3,...) histogram */
|
|
#define cvQueryHistValue_1D( hist, idx0 ) \
|
|
((float)cvGetReal1D( (hist)->bins, (idx0)))
|
|
#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
|
|
((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
|
|
#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
|
|
((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
|
|
#define cvQueryHistValue_nD( hist, idx ) \
|
|
((float)cvGetRealND( (hist)->bins, (idx)))
|
|
|
|
/* Returns pointer to the particular bin of x-dimesional histogram.
|
|
For sparse histogram the bin is created if it didn't exist before */
|
|
#define cvGetHistValue_1D( hist, idx0 ) \
|
|
((float*)cvPtr1D( (hist)->bins, (idx0), 0))
|
|
#define cvGetHistValue_2D( hist, idx0, idx1 ) \
|
|
((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
|
|
#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
|
|
((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
|
|
#define cvGetHistValue_nD( hist, idx ) \
|
|
((float*)cvPtrND( (hist)->bins, (idx), 0))
|
|
|
|
|
|
#define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
|
|
|
|
|
|
CV_EXPORTS int cvHoughLines( CvArr* image, double rho,
|
|
double theta, int threshold,
|
|
float* lines, int linesNumber );
|
|
|
|
CV_EXPORTS int cvHoughLinesP( CvArr* image, double rho,
|
|
double theta, int threshold,
|
|
int lineLength, int lineGap,
|
|
int* lines, int linesNumber );
|
|
|
|
|
|
CV_EXPORTS int cvHoughLinesSDiv( CvArr* image, double rho, int srn,
|
|
double theta, int stn, int threshold,
|
|
float* lines, int linesNumber );
|
|
|
|
CV_EXPORTS float cvCalcEMD( const float* signature1, int size1,
|
|
const float* signature2, int size2,
|
|
int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
|
|
CvDistanceFunction dist_func CV_DEFAULT(0),
|
|
float* lower_bound CV_DEFAULT(0),
|
|
void* user_param CV_DEFAULT(0));
|
|
|
|
CV_EXPORTS void cvKMeans( int num_clusters, float** samples,
|
|
int num_samples, int vec_size,
|
|
CvTermCriteria termcrit, int* cluster_idx );
|
|
|
|
CV_EXPORTS void cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
|
|
CvGraphVtx* vtx CV_DEFAULT(NULL),
|
|
int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
|
|
|
|
CV_EXPORTS void cvEndScanGraph( CvGraphScanner* scanner );
|
|
|
|
|
|
/* old drawing functions */
|
|
CV_EXPORTS void cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
|
|
double color, int scale CV_DEFAULT(0));
|
|
|
|
CV_EXPORTS void cvCircleAA( CvArr* img, CvPoint center, int radius,
|
|
double color, int scale CV_DEFAULT(0) );
|
|
|
|
CV_EXPORTS void cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
|
|
double angle, double start_angle,
|
|
double end_angle, double color,
|
|
int scale CV_DEFAULT(0) );
|
|
|
|
CV_EXPORTS void cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
|
|
int is_closed, double color, int scale CV_DEFAULT(0) );
|
|
|
|
/****************************************************************************************\
|
|
* Pixel Access Macros *
|
|
\****************************************************************************************/
|
|
|
|
typedef struct _CvPixelPosition8u
|
|
{
|
|
uchar* currline; /* pointer to the start of the current pixel line */
|
|
uchar* topline; /* pointer to the start of the top pixel line */
|
|
uchar* bottomline; /* pointer to the start of the first line */
|
|
/* which is below the image */
|
|
int x; /* current x coordinate ( in pixels ) */
|
|
int width; /* width of the image ( in pixels ) */
|
|
int height; /* height of the image ( in pixels ) */
|
|
int step; /* distance between lines ( in elements of single */
|
|
/* plane ) */
|
|
int step_arr[3]; /* array: ( 0, -step, step ). It is used for */
|
|
/* vertical moving */
|
|
} CvPixelPosition8u;
|
|
|
|
/* this structure differs from the above only in data type */
|
|
typedef struct _CvPixelPosition8s
|
|
{
|
|
schar* currline;
|
|
schar* topline;
|
|
schar* bottomline;
|
|
int x;
|
|
int width;
|
|
int height;
|
|
int step;
|
|
int step_arr[3];
|
|
} CvPixelPosition8s;
|
|
|
|
/* this structure differs from the CvPixelPosition8u only in data type */
|
|
typedef struct _CvPixelPosition32f
|
|
{
|
|
float* currline;
|
|
float* topline;
|
|
float* bottomline;
|
|
int x;
|
|
int width;
|
|
int height;
|
|
int step;
|
|
int step_arr[3];
|
|
} CvPixelPosition32f;
|
|
|
|
|
|
/* Initialize one of the CvPixelPosition structures. */
|
|
/* pos - initialized structure */
|
|
/* origin - pointer to the left-top corner of the ROI */
|
|
/* step - width of the whole image in bytes */
|
|
/* roi - width & height of the ROI */
|
|
/* x, y - initial position */
|
|
#define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation) \
|
|
( \
|
|
(pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
|
|
(pos).width = (roi).width, \
|
|
(pos).height = (roi).height, \
|
|
(pos).bottomline = (origin) + (pos).step*(pos).height, \
|
|
(pos).topline = (origin) - (pos).step, \
|
|
(pos).step_arr[0] = 0, \
|
|
(pos).step_arr[1] = -(pos).step, \
|
|
(pos).step_arr[2] = (pos).step, \
|
|
(pos).x = (_x), \
|
|
(pos).currline = (origin) + (pos).step*(_y) )
|
|
|
|
|
|
/* Move to specified point ( absolute shift ) */
|
|
/* pos - position structure */
|
|
/* x, y - coordinates of the new position */
|
|
/* cs - number of the image channels */
|
|
#define CV_MOVE_TO( pos, _x, _y, cs ) \
|
|
((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
|
|
(pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
|
|
|
|
/* Get current coordinates */
|
|
/* pos - position structure */
|
|
/* x, y - coordinates of the new position */
|
|
/* cs - number of the image channels */
|
|
#define CV_GET_CURRENT( pos, cs ) ((pos).currline + (pos).x * (cs))
|
|
|
|
/* Move by one pixel relatively to current position */
|
|
/* pos - position structure */
|
|
/* cs - number of the image channels */
|
|
|
|
/* left */
|
|
#define CV_MOVE_LEFT( pos, cs ) \
|
|
( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
|
|
|
|
/* right */
|
|
#define CV_MOVE_RIGHT( pos, cs ) \
|
|
( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
|
|
|
|
/* up */
|
|
#define CV_MOVE_UP( pos, cs ) \
|
|
(((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
|
|
|
|
/* down */
|
|
#define CV_MOVE_DOWN( pos, cs ) \
|
|
(((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
|
|
|
|
/* left up */
|
|
#define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
|
|
|
|
/* right up */
|
|
#define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
|
|
|
|
/* left down */
|
|
#define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
|
|
|
|
/* right down */
|
|
#define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
|
|
|
|
|
|
|
|
/* Move by one pixel relatively to current position with wrapping when the position */
|
|
/* achieves image boundary */
|
|
/* pos - position structure */
|
|
/* cs - number of the image channels */
|
|
|
|
/* left */
|
|
#define CV_MOVE_LEFT_WRAP( pos, cs ) \
|
|
((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
|
|
|
|
/* right */
|
|
#define CV_MOVE_RIGHT_WRAP( pos, cs ) \
|
|
((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
|
|
|
|
/* up */
|
|
#define CV_MOVE_UP_WRAP( pos, cs ) \
|
|
((((pos).currline -= (pos).step) != (pos).topline ? \
|
|
(pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
|
|
|
|
/* down */
|
|
#define CV_MOVE_DOWN_WRAP( pos, cs ) \
|
|
((((pos).currline += (pos).step) != (pos).bottomline ? \
|
|
(pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
|
|
|
|
/* left up */
|
|
#define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
|
|
/* right up */
|
|
#define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
|
|
/* left down */
|
|
#define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
|
|
/* right down */
|
|
#define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
|
|
|
|
/* Numeric constants which used for moving in arbitrary direction */
|
|
enum
|
|
{
|
|
CV_SHIFT_NONE = 2,
|
|
CV_SHIFT_LEFT = 1,
|
|
CV_SHIFT_RIGHT = 3,
|
|
CV_SHIFT_UP = 6,
|
|
CV_SHIFT_DOWN = 10,
|
|
CV_SHIFT_LU = 5,
|
|
CV_SHIFT_RU = 7,
|
|
CV_SHIFT_LD = 9,
|
|
CV_SHIFT_RD = 11
|
|
};
|
|
|
|
/* Move by one pixel in specified direction */
|
|
/* pos - position structure */
|
|
/* shift - direction ( it's value must be one of the CV_SHIFT_Ö constants ) */
|
|
/* cs - number of the image channels */
|
|
#define CV_MOVE_PARAM( pos, shift, cs ) \
|
|
( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2, \
|
|
((pos).currline != (pos).topline && (pos).currline != (pos).bottomline && \
|
|
(pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
|
|
|
|
/* Move by one pixel in specified direction with wrapping when the */
|
|
/* position achieves image boundary */
|
|
/* pos - position structure */
|
|
/* shift - direction ( it's value must be one of the CV_SHIFT_Ö constants ) */
|
|
/* cs - number of the image channels */
|
|
#define CV_MOVE_PARAM_WRAP( pos, shift, cs ) \
|
|
( (pos).currline += (pos).step_arr[(shift)>>2], \
|
|
(pos).currline = ((pos).currline == (pos).topline ? \
|
|
(pos).bottomline - (pos).step : \
|
|
(pos).currline == (pos).bottomline ? \
|
|
(pos).topline + (pos).step : (pos).currline), \
|
|
\
|
|
(pos).x += ((shift)&3)-2, \
|
|
(pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
|
|
\
|
|
(pos).currline + (pos).x*(cs) )
|
|
|
|
|
|
typedef float* CvVect32f;
|
|
typedef float* CvMatr32f;
|
|
typedef double* CvVect64d;
|
|
typedef double* CvMatr64d;
|
|
|
|
CV_EXPORTS void cvUnDistortOnce( const CvArr* src, CvArr* dst,
|
|
const float* intrinsic_matrix,
|
|
const float* distortion_coeffs,
|
|
int interpolate );
|
|
|
|
/* the two functions below have quite hackerish implementations, use with care
|
|
(or, which is better, switch to cvUndistortInitMap and cvRemap instead */
|
|
CV_EXPORTS void cvUnDistortInit( const CvArr* src,
|
|
CvArr* undistortion_map,
|
|
const float* A, const float* k,
|
|
int interpolate );
|
|
|
|
CV_EXPORTS void cvUnDistort( const CvArr* src, CvArr* dst,
|
|
const CvArr* undistortion_map,
|
|
int interpolate );
|
|
|
|
/* Find fundamental matrix */
|
|
CV_EXPORTS void cvFindFundamentalMatrix( int* points1, int* points2,
|
|
int numpoints, int method, float* matrix );
|
|
|
|
|
|
CV_EXPORTS int cvFindChessBoardCornerGuesses( const void* arr, void* thresharr,
|
|
CvMemStorage* storage,
|
|
CvSize pattern_size, CvPoint2D32f * corners,
|
|
int *corner_count );
|
|
|
|
/* Calibrates camera using multiple views of calibration pattern */
|
|
CV_EXPORTS void cvCalibrateCamera( int image_count, int* _point_counts,
|
|
CvSize image_size, CvPoint2D32f* _image_points, CvPoint3D32f* _object_points,
|
|
float* _distortion_coeffs, float* _camera_matrix, float* _translation_vectors,
|
|
float* _rotation_matrices, int flags );
|
|
|
|
|
|
CV_EXPORTS void cvCalibrateCamera_64d( int image_count, int* _point_counts,
|
|
CvSize image_size, CvPoint2D64f* _image_points, CvPoint3D64f* _object_points,
|
|
double* _distortion_coeffs, double* _camera_matrix, double* _translation_vectors,
|
|
double* _rotation_matrices, int flags );
|
|
|
|
|
|
/* Find 3d position of object given intrinsic camera parameters,
|
|
3d model of the object and projection of the object into view plane */
|
|
CV_EXPORTS void cvFindExtrinsicCameraParams( int point_count,
|
|
CvSize image_size, CvPoint2D32f* _image_points,
|
|
CvPoint3D32f* _object_points, float* focal_length,
|
|
CvPoint2D32f principal_point, float* _distortion_coeffs,
|
|
float* _rotation_vector, float* _translation_vector );
|
|
|
|
/* Variant of the previous function that takes double-precision parameters */
|
|
CV_EXPORTS void cvFindExtrinsicCameraParams_64d( int point_count,
|
|
CvSize image_size, CvPoint2D64f* _image_points,
|
|
CvPoint3D64f* _object_points, double* focal_length,
|
|
CvPoint2D64f principal_point, double* _distortion_coeffs,
|
|
double* _rotation_vector, double* _translation_vector );
|
|
|
|
/* Rodrigues transform */
|
|
enum
|
|
{
|
|
CV_RODRIGUES_M2V = 0,
|
|
CV_RODRIGUES_V2M = 1
|
|
};
|
|
|
|
/* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
|
|
CV_EXPORTS void cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
|
|
CvMat* jacobian, int conv_type );
|
|
|
|
/* Does reprojection of 3d object points to the view plane */
|
|
CV_EXPORTS void cvProjectPoints( int point_count, CvPoint3D64f* _object_points,
|
|
double* _rotation_vector, double* _translation_vector,
|
|
double* focal_length, CvPoint2D64f principal_point,
|
|
double* _distortion, CvPoint2D64f* _image_points,
|
|
double* _deriv_points_rotation_matrix,
|
|
double* _deriv_points_translation_vect,
|
|
double* _deriv_points_focal,
|
|
double* _deriv_points_principal_point,
|
|
double* _deriv_points_distortion_coeffs );
|
|
|
|
|
|
/* Simpler version of the previous function */
|
|
CV_EXPORTS void cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
|
|
double* _rotation_matrix, double* _translation_vector,
|
|
double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points );
|
|
|
|
|
|
#define cvMake2DPoints cvConvertPointsHomogeneous
|
|
#define cvMake3DPoints cvConvertPointsHomogeneous
|
|
|
|
#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
|
|
|
|
#define cvConvertPointsHomogenious cvConvertPointsHomogeneous
|
|
|
|
|
|
//////////////////////////////////// feature extractors: obsolete API //////////////////////////////////
|
|
|
|
typedef struct CvSURFPoint
|
|
{
|
|
CvPoint2D32f pt;
|
|
|
|
int laplacian;
|
|
int size;
|
|
float dir;
|
|
float hessian;
|
|
|
|
} CvSURFPoint;
|
|
|
|
CV_INLINE CvSURFPoint cvSURFPoint( CvPoint2D32f pt, int laplacian,
|
|
int size, float dir CV_DEFAULT(0),
|
|
float hessian CV_DEFAULT(0))
|
|
{
|
|
CvSURFPoint kp;
|
|
|
|
kp.pt = pt;
|
|
kp.laplacian = laplacian;
|
|
kp.size = size;
|
|
kp.dir = dir;
|
|
kp.hessian = hessian;
|
|
|
|
return kp;
|
|
}
|
|
|
|
typedef struct CvSURFParams
|
|
{
|
|
int extended;
|
|
int upright;
|
|
double hessianThreshold;
|
|
|
|
int nOctaves;
|
|
int nOctaveLayers;
|
|
|
|
} CvSURFParams;
|
|
|
|
CVAPI(CvSURFParams) cvSURFParams( double hessianThreshold, int extended CV_DEFAULT(0) );
|
|
|
|
// If useProvidedKeyPts!=0, keypoints are not detected, but descriptors are computed
|
|
// at the locations provided in keypoints (a CvSeq of CvSURFPoint).
|
|
CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask,
|
|
CvSeq** keypoints, CvSeq** descriptors,
|
|
CvMemStorage* storage, CvSURFParams params,
|
|
int useProvidedKeyPts CV_DEFAULT(0) );
|
|
|
|
/*!
|
|
Maximal Stable Regions Parameters
|
|
*/
|
|
typedef struct CvMSERParams
|
|
{
|
|
//! delta, in the code, it compares (size_{i}-size_{i-delta})/size_{i-delta}
|
|
int delta;
|
|
//! prune the area which bigger than maxArea
|
|
int maxArea;
|
|
//! prune the area which smaller than minArea
|
|
int minArea;
|
|
//! prune the area have simliar size to its children
|
|
float maxVariation;
|
|
//! trace back to cut off mser with diversity < min_diversity
|
|
float minDiversity;
|
|
|
|
/////// the next few params for MSER of color image
|
|
|
|
//! for color image, the evolution steps
|
|
int maxEvolution;
|
|
//! the area threshold to cause re-initialize
|
|
double areaThreshold;
|
|
//! ignore too small margin
|
|
double minMargin;
|
|
//! the aperture size for edge blur
|
|
int edgeBlurSize;
|
|
} CvMSERParams;
|
|
|
|
CVAPI(CvMSERParams) cvMSERParams( int delta CV_DEFAULT(5), int min_area CV_DEFAULT(60),
|
|
int max_area CV_DEFAULT(14400), float max_variation CV_DEFAULT(.25f),
|
|
float min_diversity CV_DEFAULT(.2f), int max_evolution CV_DEFAULT(200),
|
|
double area_threshold CV_DEFAULT(1.01),
|
|
double min_margin CV_DEFAULT(.003),
|
|
int edge_blur_size CV_DEFAULT(5) );
|
|
|
|
// Extracts the contours of Maximally Stable Extremal Regions
|
|
CVAPI(void) cvExtractMSER( CvArr* _img, CvArr* _mask, CvSeq** contours, CvMemStorage* storage, CvMSERParams params );
|
|
|
|
|
|
typedef struct CvStarKeypoint
|
|
{
|
|
CvPoint pt;
|
|
int size;
|
|
float response;
|
|
} CvStarKeypoint;
|
|
|
|
CV_INLINE CvStarKeypoint cvStarKeypoint(CvPoint pt, int size, float response)
|
|
{
|
|
CvStarKeypoint kpt;
|
|
kpt.pt = pt;
|
|
kpt.size = size;
|
|
kpt.response = response;
|
|
return kpt;
|
|
}
|
|
|
|
typedef struct CvStarDetectorParams
|
|
{
|
|
int maxSize;
|
|
int responseThreshold;
|
|
int lineThresholdProjected;
|
|
int lineThresholdBinarized;
|
|
int suppressNonmaxSize;
|
|
} CvStarDetectorParams;
|
|
|
|
CV_INLINE CvStarDetectorParams cvStarDetectorParams(
|
|
int maxSize CV_DEFAULT(45),
|
|
int responseThreshold CV_DEFAULT(30),
|
|
int lineThresholdProjected CV_DEFAULT(10),
|
|
int lineThresholdBinarized CV_DEFAULT(8),
|
|
int suppressNonmaxSize CV_DEFAULT(5))
|
|
{
|
|
CvStarDetectorParams params;
|
|
params.maxSize = maxSize;
|
|
params.responseThreshold = responseThreshold;
|
|
params.lineThresholdProjected = lineThresholdProjected;
|
|
params.lineThresholdBinarized = lineThresholdBinarized;
|
|
params.suppressNonmaxSize = suppressNonmaxSize;
|
|
|
|
return params;
|
|
}
|
|
|
|
CVAPI(CvSeq*) cvGetStarKeypoints( const CvArr* img, CvMemStorage* storage,
|
|
CvStarDetectorParams params CV_DEFAULT(cvStarDetectorParams()));
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|