#include "opencv2/core/core_c.h"
#include "opencv2/imgproc/types_c.h"
#include <math.h>
#include <string.h>

Classes
struct	CvRandState

struct	CvPixelPosition8u

struct	CvPixelPosition8s

struct	CvPixelPosition32f

struct	CvSURFPoint

struct	CvSURFParams

struct	CvMSERParams

struct	CvStarKeypoint

struct	CvStarDetectorParams

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

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

#define	cvCvtPixToPlane cvSplit

#define	cvCvtPlaneToPix cvMerge

#define	cvRandNext(_state) cvRandInt( &(_state)->state )

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

#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

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

#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

#define	CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation)

#define	CV_MOVE_TO(pos, _x, _y, cs)

#define	CV_GET_CURRENT(pos, cs) ((pos).currline + (pos).x * (cs))

#define	CV_MOVE_LEFT(pos, cs) ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )

#define	CV_MOVE_RIGHT(pos, cs) ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )

#define	CV_MOVE_UP(pos, cs) (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )

#define	CV_MOVE_DOWN(pos, cs) (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )

#define	CV_MOVE_LU(pos, cs) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))

#define	CV_MOVE_RU(pos, cs) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))

#define	CV_MOVE_LD(pos, cs) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))

#define	CV_MOVE_RD(pos, cs) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))

#define	CV_MOVE_LEFT_WRAP(pos, cs) ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))

#define	CV_MOVE_RIGHT_WRAP(pos, cs) ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )

#define	CV_MOVE_UP_WRAP(pos, cs)

#define	CV_MOVE_DOWN_WRAP(pos, cs)

#define	CV_MOVE_LU_WRAP(pos, cs) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))

#define	CV_MOVE_RU_WRAP(pos, cs) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))

#define	CV_MOVE_LD_WRAP(pos, cs) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))

#define	CV_MOVE_RD_WRAP(pos, cs) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))

#define	CV_MOVE_PARAM(pos, shift, cs)

#define	CV_MOVE_PARAM_WRAP(pos, shift, cs)

#define	cvMake2DPoints cvConvertPointsHomogeneous

#define	cvMake3DPoints cvConvertPointsHomogeneous

#define	cvWarpPerspectiveQMatrix cvGetPerspectiveTransform

#define	cvConvertPointsHomogenious cvConvertPointsHomogeneous

Typedefs
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

typedef CvBox2D	CvBox2D32f

typedef int	CvDisType

typedef int	CvChainApproxMethod

typedef int	CvContourRetrievalMode

typedef float *	CvVect32f

typedef float *	CvMatr32f

typedef double *	CvVect64d

typedef double *	CvMatr64d

Enumerations
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 }

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 }

enum	{ CV_RODRIGUES_M2V = 0, CV_RODRIGUES_V2M = 1 }

Functions
CvMat	cvMatArray (int rows, int cols, int type, int count, void *data CV_DEFAULT(0))

double	cvMean (const CvArr image, const CvArr mask CV_DEFAULT(0))

double	cvSumPixels (const CvArr *image)

void	cvMean_StdDev (const CvArr image, double mean, double sdv, const CvArr mask CV_DEFAULT(0))

void	cvmPerspectiveProject (const CvMat mat, const CvArr src, CvArr *dst)

void	cvFillImage (CvArr *mat, double color)

void	cvRandSetRange (CvRandState *state, double param1, double param2, int index CV_DEFAULT(-1))

void	cvRandInit (CvRandState *state, double param1, double param2, int seed, int disttype CV_DEFAULT(CV_RAND_UNI))

void	cvRand (CvRandState state, CvArr arr)

void	cvbRand (CvRandState state, float dst, int len)

void	cvbCartToPolar (const float y, const float x, float magnitude, float angle, int len)

void	cvbFastArctan (const float y, const float x, float *angle, int len)

void	cvbSqrt (const float x, float y, int len)

void	cvbInvSqrt (const float x, float y, int len)

void	cvbReciprocal (const float x, float y, int len)

void	cvbFastExp (const float x, double y, int len)

void	cvbFastLog (const double x, float y, int len)

CvRect	cvContourBoundingRect (void *point_set, int update CV_DEFAULT(0))

double	cvPseudoInverse (const CvArr src, CvArr dst)

void	cvConvexHull (CvPoint points, int num_points, CvRect bound_rect, int orientation, int hull, int hullsize)

void	cvMinAreaRect (CvPoint points, int n, int left, int bottom, int right, int top, CvPoint2D32f anchor, CvPoint2D32f vect1, CvPoint2D32f vect2)

void	cvFitLine3D (CvPoint3D32f points, int count, int dist, void param, float reps, float aeps, float *line)

void	cvFitLine2D (CvPoint2D32f points, int count, int dist, void param, float reps, float aeps, float *line)

void	cvFitEllipse (const CvPoint2D32f points, int count, CvBox2D box)

void	cvProject3D (CvPoint3D32f points3D, int count, CvPoint2D32f points2D, int xIndx CV_DEFAULT(0), int yIndx CV_DEFAULT(1))

int	cvHoughLines (CvArr image, double rho, double theta, int threshold, float lines, int linesNumber)

int	cvHoughLinesP (CvArr image, double rho, double theta, int threshold, int lineLength, int lineGap, int lines, int linesNumber)

int	cvHoughLinesSDiv (CvArr image, double rho, int srn, double theta, int stn, int threshold, float lines, int linesNumber)

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

void	cvKMeans (int num_clusters, float *samples, int num_samples, int vec_size, CvTermCriteria termcrit, int cluster_idx)

void	cvStartScanGraph (CvGraph graph, CvGraphScanner scanner, CvGraphVtx *vtx CV_DEFAULT(NULL), int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS))

void	cvEndScanGraph (CvGraphScanner *scanner)

void	cvLineAA (CvArr *img, CvPoint pt1, CvPoint pt2, double color, int scale CV_DEFAULT(0))

void	cvCircleAA (CvArr *img, CvPoint center, int radius, double color, int scale CV_DEFAULT(0))

void	cvEllipseAA (CvArr *img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, double color, int scale CV_DEFAULT(0))

void	cvPolyLineAA (CvArr img, CvPoint pts, int npts, int contours, int is_closed, double color, int scale CV_DEFAULT(0))

void	cvUnDistortOnce (const CvArr src, CvArr dst, const float intrinsic_matrix, const float distortion_coeffs, int interpolate)

void	cvUnDistortInit (const CvArr src, CvArr undistortion_map, const float A, const float k, int interpolate)

void	cvUnDistort (const CvArr src, CvArr dst, const CvArr *undistortion_map, int interpolate)

void	cvFindFundamentalMatrix (int points1, int points2, int numpoints, int method, float *matrix)

int	cvFindChessBoardCornerGuesses (const void arr, void thresharr, CvMemStorage storage, CvSize pattern_size, CvPoint2D32f corners, int *corner_count)

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)

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)

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)

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)

void	cvRodrigues (CvMat rotation_matrix, CvMat rotation_vector, CvMat *jacobian, int conv_type)

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)

void	cvProjectPointsSimple (int point_count, CvPoint3D64f _object_points, double _rotation_matrix, double _translation_vector, double _camera_matrix, double _distortion, CvPoint2D64f _image_points)

CV_INLINE CvSURFPoint	cvSURFPoint (CvPoint2D32f pt, int laplacian, int size, float dir CV_DEFAULT(0), float hessian CV_DEFAULT(0))

CvSURFParams	cvSURFParams (double hessianThreshold, int extended CV_DEFAULT(0))

void	cvExtractSURF (const CvArr img, const CvArr mask, CvSeq keypoints, CvSeq descriptors, CvMemStorage *storage, CvSURFParams params, int useProvidedKeyPts CV_DEFAULT(0))

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

void	cvExtractMSER (CvArr _img, CvArr _mask, CvSeq *contours, CvMemStorage storage, CvMSERParams params)

CV_INLINE CvStarKeypoint	cvStarKeypoint (CvPoint pt, int size, float response)

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

CvSeq *	cvGetStarKeypoints (const CvArr img, CvMemStorage storage, CvStarDetectorParams params CV_DEFAULT(cvStarDetectorParams()))

Macro Definition Documentation

#define CV_GET_CURRENT	(	pos,
		cs
	)	((pos).currline + (pos).x * (cs))

#define CV_INIT_PIXEL_POS	(	pos,
		origin,
		_step,
		roi,
		_x,
		_y,
		orientation
	)

Value:

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

#define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM

#define CV_MOVE_DOWN	(	pos,
		cs
	)	(((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )

#define CV_MOVE_DOWN_WRAP	(	pos,
		cs
	)

Value:

((((pos).currline += (pos).step) != (pos).bottomline ? \

(pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )

int

#define CV_MOVE_LD	(	pos,
		cs
	)	( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))

#define CV_MOVE_LD_WRAP	(	pos,
		cs
	)	( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))

#define CV_MOVE_LEFT	(	pos,
		cs
	)	( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )

#define CV_MOVE_LEFT_WRAP	(	pos,
		cs
	)	((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))

#define CV_MOVE_LU	(	pos,
		cs
	)	( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))

#define CV_MOVE_LU_WRAP	(	pos,
		cs
	)	( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))

#define CV_MOVE_PARAM	(	pos,
		shift,
		cs
	)

Value:

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

#define CV_MOVE_PARAM_WRAP	(	pos,
		shift,
		cs
	)

Value:

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

#define CV_MOVE_RD	(	pos,
		cs
	)	( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))

#define CV_MOVE_RD_WRAP	(	pos,
		cs
	)	( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))

#define CV_MOVE_RIGHT	(	pos,
		cs
	)	( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )

#define CV_MOVE_RIGHT_WRAP	(	pos,
		cs
	)	((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )

#define CV_MOVE_RU	(	pos,
		cs
	)	( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))

#define CV_MOVE_RU_WRAP	(	pos,
		cs
	)	( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))

#define CV_MOVE_TO	(	pos,
		_x,
		_y,
		cs
	)

Value:

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

int

#define CV_MOVE_UP	(	pos,
		cs
	)	(((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )

#define CV_MOVE_UP_WRAP	(	pos,
		cs
	)

Value:

((((pos).currline -= (pos).step) != (pos).topline ? \

(pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )

int

#define cvAccMask cvAcc

#define cvCalcHistMask	(	img,
		mask,
		hist,
		doNotClear
	)	cvCalcHist(img, hist, doNotClear, mask)

#define cvContourMoments	(	contour,
		moments
	)	cvMoments( contour, moments, 0 )

#define cvConvertPointsHomogenious cvConvertPointsHomogeneous

#define cvCopyImage	(	src,
		dst
	)	cvCopy( src, dst, 0 )

#define cvCreateImageData cvCreateData

#define cvCvtPixToPlane cvSplit

#define cvCvtPlaneToPix cvMerge

#define cvGetAt cvGet2D

#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 cvGetImageRawData cvGetRawData

#define cvGetPtrAt cvPtr2D

#define cvIntegralImage cvIntegral

#define cvmAdd	(	src1,
		src2,
		dst
	)	cvAdd( src1, src2, dst, 0 )

#define cvMake2DPoints cvConvertPointsHomogeneous

#define cvMake3DPoints cvConvertPointsHomogeneous

#define cvmAlloc cvCreateData

#define cvmAllocArray cvCreateData

#define cvMatchContours cvMatchShapes

#define cvmCopy	(	src,
		dst
	)	cvCopy( src, dst, 0 )

#define cvmCrossProduct	(	vec1,
		vec2,
		dst
	)	cvCrossProduct( vec1, vec2, dst )

#define cvmDet ( mat ) cvDet( mat )

#define cvmDotProduct	(	vec1,
		vec2
	)	cvDotProduct( vec1, vec2 )

#define cvMean_StdDevMask	(	img,
		mask,
		mean,
		sdv
	)	cvMean_StdDev(img,mean,sdv,mask)

#define cvMeanMask cvMean

#define cvmEigenVV	(	mat,
		evec,
		eval,
		eps
	)	cvEigenVV( mat, evec, eval, eps )

#define cvmFree cvReleaseData

#define cvmFreeArray cvReleaseData

#define cvMinMaxLocMask	(	img,
		mask,
		min_val,
		max_val,
		min_loc,
		max_loc
	)	cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)

#define cvmInvert	(	src,
		dst
	)	cvInv( src, dst )

#define cvmMahalanobis	(	vec1,
		vec2,
		mat
	)	cvMahalanobis( vec1, vec2, mat )

#define cvmMul	(	src1,
		src2,
		dst
	)	cvMatMulAdd( src1, src2, 0, dst )

#define cvmMulTransposed	(	src,
		dst,
		order
	)	cvMulTransposed( src, dst, order )

#define cvmScale	(	src,
		dst,
		scale
	)	cvScale( src, dst, scale )

#define cvmSetIdentity ( mat ) cvSetIdentity( mat )

#define cvmSetZero ( mat ) cvSetZero( mat )

#define cvmSub	(	src1,
		src2,
		dst
	)	cvSub( src1, src2, dst, 0 )

#define cvmTrace ( mat ) (cvTrace( mat )).val[0]

#define cvmTranspose	(	src,
		dst
	)	cvT( src, dst )

#define cvMultiplyAccMask cvMultiplyAcc

#define cvNormMask	(	imgA,
		imgB,
		mask,
		normType
	)	cvNorm(imgA,imgB,normType,mask)

#define cvPseudoInv cvPseudoInverse

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

#define cvRandNext ( _state ) cvRandInt( &(_state)->state )

#define cvReleaseImageData cvReleaseData

#define cvReleaseMatHeader cvReleaseMat

#define cvRemoveMemoryManager cvSetMemoryManager

#define cvRunningAvgMask	(	imgY,
		imgU,
		mask,
		alpha
	)	cvRunningAvg(imgY, imgU, alpha, mask)

#define cvSetAt	(	arr,
		val,
		y,
		x
	)	cvSet2D((arr),(y),(x),(val))

#define cvSetHistThresh cvSetHistBinRanges

#define cvSetImageData cvSetData

#define cvSquareAccMask cvSquareAcc

#define cvUpdateMHIByTime cvUpdateMotionHistory

#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform

Typedef Documentation

typedef int CvAdaptiveThreshMethod

typedef CvBox2D CvBox2D32f

typedef int CvChainApproxMethod

typedef int CvCoeffType

typedef int CvCompareMethod

typedef int CvContourRetrievalMode

typedef int CvContoursMatchMethod

typedef int CvContourTreesMatchMethod

typedef int CvDisMaskType

typedef int CvDisType

typedef int CvElementShape

typedef int CvFontFace

typedef CvMat CvMatArray

typedef float* CvMatr32f

typedef double* CvMatr64d

typedef int CvMatType

typedef int CvMorphOp

typedef CvPoint2D64f CvPoint2D64d

typedef CvPoint3D64f CvPoint3D64d

typedef int CvPolyApproxMethod

typedef int CvRodriguesType

typedef int CvTemplMatchMethod

typedef int CvThreshType

typedef float* CvVect32f

typedef double* CvVect64d

Enumeration Type Documentation

anonymous enum

Enumerator
CV_MAT32F
CV_MAT3x1_32F
CV_MAT4x1_32F
CV_MAT3x3_32F
CV_MAT4x4_32F
CV_MAT64D
CV_MAT3x1_64D
CV_MAT4x1_64D
CV_MAT3x3_64D
CV_MAT4x4_64D

anonymous enum

Enumerator
IPL_GAUSSIAN_5x5

anonymous enum

Enumerator
CV_SHIFT_NONE
CV_SHIFT_LEFT
CV_SHIFT_RIGHT
CV_SHIFT_UP
CV_SHIFT_DOWN
CV_SHIFT_LU
CV_SHIFT_RU
CV_SHIFT_LD
CV_SHIFT_RD

anonymous enum

Enumerator
CV_RODRIGUES_M2V
CV_RODRIGUES_V2M

Function Documentation

void cvbCartToPolar	(	const float *	y,
		const float *	x,
		float *	magnitude,
		float *	angle,
		int	len
	)

void cvbFastArctan	(	const float *	y,
		const float *	x,
		float *	angle,
		int	len
	)

void cvbFastExp	(	const float *	x,
		double *	y,
		int	len
	)

void cvbFastLog	(	const double *	x,
		float *	y,
		int	len
	)

void cvbInvSqrt	(	const float *	x,
		float *	y,
		int	len
	)

void cvbRand	(	CvRandState *	state,
		float *	dst,
		int	len
	)

void cvbReciprocal	(	const float *	x,
		float *	y,
		int	len
	)

void cvbSqrt	(	const float *	x,
		float *	y,
		int	len
	)

float cvCalcEMD	(	const float *	signature1,
		int	size1,
		const float *	signature2,
		int	size2,
		int	dims,
		int dist_type	CV_DEFAULTCV_DIST_L2,
		CvDistanceFunction dist_func	CV_DEFAULT0,
		float *lower_bound	CV_DEFAULT0,
		void *user_param	CV_DEFAULT0
	)

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
	)

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
	)

void cvCircleAA	(	CvArr *	img,
		CvPoint	center,
		int	radius,
		double	color,
		int scale	CV_DEFAULT0
	)

CvRect cvContourBoundingRect	(	void *	point_set,
		int update	CV_DEFAULT0
	)

void cvConvexHull	(	CvPoint *	points,
		int	num_points,
		CvRect *	bound_rect,
		int	orientation,
		int *	hull,
		int *	hullsize
	)

void cvEllipseAA	(	CvArr *	img,
		CvPoint	center,
		CvSize	axes,
		double	angle,
		double	start_angle,
		double	end_angle,
		double	color,
		int scale	CV_DEFAULT0
	)

void cvEndScanGraph ( CvGraphScanner * scanner )

void cvExtractMSER	(	CvArr *	_img,
		CvArr *	_mask,
		CvSeq **	contours,
		CvMemStorage *	storage,
		CvMSERParams	params
	)

void cvExtractSURF	(	const CvArr *	img,
		const CvArr *	mask,
		CvSeq **	keypoints,
		CvSeq **	descriptors,
		CvMemStorage *	storage,
		CvSURFParams	params,
		int useProvidedKeyPts	CV_DEFAULT0
	)

void cvFillImage	(	CvArr *	mat,
		double	color
	)

int cvFindChessBoardCornerGuesses	(	const void *	arr,
		void *	thresharr,
		CvMemStorage *	storage,
		CvSize	pattern_size,
		CvPoint2D32f *	corners,
		int *	corner_count
	)

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
	)

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
	)

void cvFindFundamentalMatrix	(	int *	points1,
		int *	points2,
		int	numpoints,
		int	method,
		float *	matrix
	)

void cvFitEllipse	(	const CvPoint2D32f *	points,
		int	count,
		CvBox2D *	box
	)

void cvFitLine2D	(	CvPoint2D32f *	points,
		int	count,
		int	dist,
		void *	param,
		float	reps,
		float	aeps,
		float *	line
	)

void cvFitLine3D	(	CvPoint3D32f *	points,
		int	count,
		int	dist,
		void *	param,
		float	reps,
		float	aeps,
		float *	line
	)

CvSeq* cvGetStarKeypoints	(	const CvArr *	img,
		CvMemStorage *	storage,
		CvStarDetectorParams params	CV_DEFAULTcvStarDetectorParams()
	)

int cvHoughLines	(	CvArr *	image,
		double	rho,
		double	theta,
		int	threshold,
		float *	lines,
		int	linesNumber
	)

int cvHoughLinesP	(	CvArr *	image,
		double	rho,
		double	theta,
		int	threshold,
		int	lineLength,
		int	lineGap,
		int *	lines,
		int	linesNumber
	)

int cvHoughLinesSDiv	(	CvArr *	image,
		double	rho,
		int	srn,
		double	theta,
		int	stn,
		int	threshold,
		float *	lines,
		int	linesNumber
	)

void cvKMeans	(	int	num_clusters,
		float **	samples,
		int	num_samples,
		int	vec_size,
		CvTermCriteria	termcrit,
		int *	cluster_idx
	)

void cvLineAA	(	CvArr *	img,
		CvPoint	pt1,
		CvPoint	pt2,
		double	color,
		int scale	CV_DEFAULT0
	)

CvMat cvMatArray	(	int	rows,
		int	cols,
		int	type,
		int	count,
		void *data	CV_DEFAULT0
	)

double cvMean	(	const CvArr *	image,
		const CvArr *mask	CV_DEFAULT0
	)

void cvMean_StdDev	(	const CvArr *	image,
		double *	mean,
		double *	sdv,
		const CvArr *mask	CV_DEFAULT0
	)

void cvMinAreaRect	(	CvPoint *	points,
		int	n,
		int	left,
		int	bottom,
		int	right,
		int	top,
		CvPoint2D32f *	anchor,
		CvPoint2D32f *	vect1,
		CvPoint2D32f *	vect2
	)

void cvmPerspectiveProject	(	const CvMat *	mat,
		const CvArr *	src,
		CvArr *	dst
	)

CvMSERParams cvMSERParams	(	int delta	CV_DEFAULT5,
		int min_area	CV_DEFAULT60,
		int max_area	CV_DEFAULT14400,
		float max_variation	CV_DEFAULT.25f,
		float min_diversity	CV_DEFAULT.2f,
		int max_evolution	CV_DEFAULT200,
		double area_threshold	CV_DEFAULT1.01,
		double min_margin	CV_DEFAULT.003,
		int edge_blur_size	CV_DEFAULT5
	)

void cvPolyLineAA	(	CvArr *	img,
		CvPoint **	pts,
		int *	npts,
		int	contours,
		int	is_closed,
		double	color,
		int scale	CV_DEFAULT0
	)

void cvProject3D	(	CvPoint3D32f *	points3D,
		int	count,
		CvPoint2D32f *	points2D,
		int xIndx	CV_DEFAULT0,
		int yIndx	CV_DEFAULT1
	)

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
	)

void cvProjectPointsSimple	(	int	point_count,
		CvPoint3D64f *	_object_points,
		double *	_rotation_matrix,
		double *	_translation_vector,
		double *	_camera_matrix,
		double *	_distortion,
		CvPoint2D64f *	_image_points
	)

double cvPseudoInverse	(	const CvArr *	src,
		CvArr *	dst
	)

void cvRand	(	CvRandState *	state,
		CvArr *	arr
	)

void cvRandInit	(	CvRandState *	state,
		double	param1,
		double	param2,
		int	seed,
		int disttype	CV_DEFAULTCV_RAND_UNI
	)

void cvRandSetRange	(	CvRandState *	state,
		double	param1,
		double	param2,
		int index	CV_DEFAULT-1
	)

void cvRodrigues	(	CvMat *	rotation_matrix,
		CvMat *	rotation_vector,
		CvMat *	jacobian,
		int	conv_type
	)

CV_INLINE CvStarDetectorParams cvStarDetectorParams	(	int maxSize	CV_DEFAULT45,
		int responseThreshold	CV_DEFAULT30,
		int lineThresholdProjected	CV_DEFAULT10,
		int lineThresholdBinarized	CV_DEFAULT8,
		int suppressNonmaxSize	CV_DEFAULT5
	)

CV_INLINE CvStarKeypoint cvStarKeypoint	(	CvPoint	pt,
		int	size,
		float	response
	)

void cvStartScanGraph	(	CvGraph *	graph,
		CvGraphScanner *	scanner,
		CvGraphVtx *vtx	CV_DEFAULTNULL,
		int mask	CV_DEFAULTCV_GRAPH_ALL_ITEMS
	)

double cvSumPixels ( const CvArr * image )

CvSURFParams cvSURFParams	(	double	hessianThreshold,
		int extended	CV_DEFAULT0
	)

CV_INLINE CvSURFPoint cvSURFPoint	(	CvPoint2D32f	pt,
		int	laplacian,
		int	size,
		float dir	CV_DEFAULT0,
		float hessian	CV_DEFAULT0
	)

void cvUnDistort	(	const CvArr *	src,
		CvArr *	dst,
		const CvArr *	undistortion_map,
		int	interpolate
	)

void cvUnDistortInit	(	const CvArr *	src,
		CvArr *	undistortion_map,
		const float *	A,
		const float *	k,
		int	interpolate
	)

void cvUnDistortOnce	(	const CvArr *	src,
		CvArr *	dst,
		const float *	intrinsic_matrix,
		const float *	distortion_coeffs,
		int	interpolate
	)

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation