#include <string.h>

Classes
struct	CvRandState

struct	_CvPixelPosition8u

struct	_CvPixelPosition8s

struct	_CvPixelPosition32f

Macros
#define	CV_UNREFERENCED(arg) arg

#define	CvMatType int

#define	CvDisMaskType int

#define	CvMatArray CvMat

#define	CvThreshType int

#define	CvAdaptiveThreshMethod int

#define	CvCompareMethod int

#define	CvFontFace int

#define	CvPolyApproxMethod int

#define	CvContoursMatchMethod int

#define	CvContourTreesMatchMethod int

#define	CvCoeffType int

#define	CvRodriguesType int

#define	CvElementShape int

#define	CvMorphOp int

#define	CvTemplMatchMethod int

#define	CvPoint2D64d CvPoint2D64f

#define	CvPoint3D64d CvPoint3D64f

#define	CV_MAT32F CV_32FC1

#define	CV_MAT3x1_32F CV_32FC1

#define	CV_MAT4x1_32F CV_32FC1

#define	CV_MAT3x3_32F CV_32FC1

#define	CV_MAT4x4_32F CV_32FC1

#define	CV_MAT64D CV_64FC1

#define	CV_MAT3x1_64D CV_64FC1

#define	CV_MAT4x1_64D CV_64FC1

#define	CV_MAT3x3_64D CV_64FC1

#define	CV_MAT4x4_64D CV_64FC1

#define	IPL_GAUSSIAN_5x5 7

#define	CvBox2D32f CvBox2D

#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	cvContourConvexHull(contour, orientation, storage) cvConvexHull2( contour, storage, orientation )

#define	cvConvexHullApprox(points, num_points, bound_rect, bandwidth,orientation, hull, hullsize) cvConvexHull( points, num_points, bound_rect, orientation, hull, hullsize )

#define	cvContourConvexHullApprox(contour, bandwidth, orientation, storage) cvConvexHull2( contour, storage, orientation )

#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_RODRIGUES_M2V 0

#define	CV_RODRIGUES_V2M 1

#define	cvKalmanUpdateByTime cvKalmanPredict

#define	cvKalmanUpdateByMeasurement cvKalmanCorrect

#define	cvMake2DPoints cvConvertPointsHomogeneous

#define	cvMake3DPoints cvConvertPointsHomogeneous

#define	cvWarpPerspectiveQMatrix cvGetPerspectiveTransform

#define	cvConvertPointsHomogenious cvConvertPointsHomogeneous

#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_SHIFT_NONE 2

#define	CV_SHIFT_LEFT 1

#define	CV_SHIFT_RIGHT 3

#define	CV_SHIFT_UP 6

#define	CV_SHIFT_DOWN 10

#define	CV_SHIFT_LU 5

#define	CV_SHIFT_RU 7

#define	CV_SHIFT_LD 9

#define	CV_SHIFT_RD 11

#define	CV_MOVE_PARAM(pos, shift, cs)

#define	CV_MOVE_PARAM_WRAP(pos, shift, cs)

Typedefs
typedef struct CvRandState	CvRandState

typedef int	CvDisType

typedef int	CvChainApproxMethod

typedef int	CvContourRetrievalMode

typedef struct _CvPixelPosition8u	CvPixelPosition8u

typedef struct _CvPixelPosition8s	CvPixelPosition8s

typedef struct _CvPixelPosition32f	CvPixelPosition32f

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

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

CV_INLINE double	cvSumPixels (const CvArr *image)

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

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

CV_INLINE void	cvFillImage (CvArr *mat, double color)

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

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

CV_INLINE void	cvRand (CvRandState state, CvArr arr)

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

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

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

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

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

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

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

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

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

CV_INLINE double	cvPseudoInverse (const CvArr src, CvArr dst)

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

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

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

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

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

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

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

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

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

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

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

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

CV_INLINE void	cvFindExtrinsicCameraParams (int point_count, CvSize CV_UNREFERENCED(image_size), CvPoint2D32f _image_points, CvPoint3D32f _object_points, float focal_length, CvPoint2D32f principal_point, float _distortion_coeffs, float _rotation_vector, float _translation_vector)

CV_INLINE void	cvFindExtrinsicCameraParams_64d (int point_count, CvSize CV_UNREFERENCED(image_size), CvPoint2D64f _image_points, CvPoint3D64f _object_points, double focal_length, CvPoint2D64f principal_point, double _distortion_coeffs, double _rotation_vector, double _translation_vector)

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

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

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

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

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

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

CV_INLINE 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_INLINE void	cvKMeans (int num_clusters, float *samples, int num_samples, int vec_size, CvTermCriteria termcrit, int cluster_idx)

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

CV_INLINE void	cvEndScanGraph (CvGraphScanner *scanner)

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

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

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

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

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_MAT32F CV_32FC1

#define CV_MAT3x1_32F CV_32FC1

#define CV_MAT3x1_64D CV_64FC1

#define CV_MAT3x3_32F CV_32FC1

#define CV_MAT3x3_64D CV_64FC1

#define CV_MAT4x1_32F CV_32FC1

#define CV_MAT4x1_64D CV_64FC1

#define CV_MAT4x4_32F CV_32FC1

#define CV_MAT4x4_64D CV_64FC1

#define CV_MAT64D CV_64FC1

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

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

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

#define CV_RODRIGUES_M2V 0

#define CV_RODRIGUES_V2M 1

#define CV_SHIFT_DOWN 10

#define CV_SHIFT_LD 9

#define CV_SHIFT_LEFT 1

#define CV_SHIFT_LU 5

#define CV_SHIFT_NONE 2

#define CV_SHIFT_RD 11

#define CV_SHIFT_RIGHT 3

#define CV_SHIFT_RU 7

#define CV_SHIFT_UP 6

#define CV_UNREFERENCED ( arg ) arg

#define cvAccMask cvAcc

#define CvAdaptiveThreshMethod int

#define CvBox2D32f CvBox2D

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

#define CvCoeffType int

#define CvCompareMethod int

#define cvContourConvexHull	(	contour,
		orientation,
		storage
	)	cvConvexHull2( contour, storage, orientation )

#define cvContourConvexHullApprox	(	contour,
		bandwidth,
		orientation,
		storage
	)	cvConvexHull2( contour, storage, orientation )

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

#define CvContoursMatchMethod int

#define CvContourTreesMatchMethod int

#define cvConvertPointsHomogenious cvConvertPointsHomogeneous

#define cvConvexHullApprox	(	points,
		num_points,
		bound_rect,
		bandwidth,
		orientation,
		hull,
		hullsize
	)	cvConvexHull( points, num_points, bound_rect, orientation, hull, hullsize )

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

#define cvCreateImageData cvCreateData

#define cvCvtPixToPlane cvSplit

#define cvCvtPlaneToPix cvMerge

#define CvDisMaskType int

#define CvElementShape int

#define CvFontFace int

#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 cvKalmanUpdateByMeasurement cvKalmanCorrect

#define cvKalmanUpdateByTime cvKalmanPredict

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

#define cvMake2DPoints cvConvertPointsHomogeneous

#define cvMake3DPoints cvConvertPointsHomogeneous

#define cvmAlloc cvCreateData

#define cvmAllocArray cvCreateData

#define CvMatArray CvMat

#define cvMatchContours cvMatchShapes

#define CvMatType int

#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 CvMorphOp int

#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 CvPoint2D64d CvPoint2D64f

#define CvPoint3D64d CvPoint3D64f

#define CvPolyApproxMethod int

#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 CvRodriguesType int

#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 CvTemplMatchMethod int

#define CvThreshType int

#define cvUpdateMHIByTime cvUpdateMotionHistory

#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform

#define IPL_GAUSSIAN_5x5 7

Typedef Documentation

typedef int CvChainApproxMethod

typedef int CvContourRetrievalMode

typedef int CvDisType

typedef struct _CvPixelPosition32f CvPixelPosition32f

typedef struct _CvPixelPosition8s CvPixelPosition8s

typedef struct _CvPixelPosition8u CvPixelPosition8u

typedef struct CvRandState CvRandState

Function Documentation

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

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

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

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

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

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

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

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

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

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

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

CV_INLINE CvRect cvContourBoundingRect	(	void *	point_set,
		int update	CV_DEFAULT0
	)

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

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

CV_INLINE void cvEndScanGraph ( CvGraphScanner * scanner )

CV_INLINE void cvFillImage	(	CvArr *	mat,
		double	color
	)

CV_INLINE int cvFindChessBoardCornerGuesses	(	const void *	arr,
		void *	CV_UNREFERENCEDthresharr,
		CvMemStorage *	CV_UNREFERENCEDstorage,
		CvSize	pattern_size,
		CvPoint2D32f *	corners,
		int *	corner_count
	)

CV_INLINE void cvFindExtrinsicCameraParams	(	int	point_count,
		CvSize	CV_UNREFERENCEDimage_size,
		CvPoint2D32f *	_image_points,
		CvPoint3D32f *	_object_points,
		float *	focal_length,
		CvPoint2D32f	principal_point,
		float *	_distortion_coeffs,
		float *	_rotation_vector,
		float *	_translation_vector
	)

CV_INLINE void cvFindExtrinsicCameraParams_64d	(	int	point_count,
		CvSize	CV_UNREFERENCEDimage_size,
		CvPoint2D64f *	_image_points,
		CvPoint3D64f *	_object_points,
		double *	focal_length,
		CvPoint2D64f	principal_point,
		double *	_distortion_coeffs,
		double *	_rotation_vector,
		double *	_translation_vector
	)

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

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

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

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

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

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

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

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

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

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

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

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

CV_INLINE void cvMinAreaRect	(	CvPoint *	points,
		int	n,
		int	CV_UNREFERENCEDleft,
		int	CV_UNREFERENCEDbottom,
		int	CV_UNREFERENCEDright,
		int	CV_UNREFERENCEDtop,
		CvPoint2D32f *	anchor,
		CvPoint2D32f *	vect1,
		CvPoint2D32f *	vect2
	)

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

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

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

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

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

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

CV_INLINE void cvRand	(	CvRandState *	state,
		CvArr *	arr
	)

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

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

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

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

CV_INLINE double cvSumPixels ( const CvArr * image )

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

CV_INLINE void cvUnDistortInit	(	const CvArr *	CV_UNREFERENCEDsrc,
		CvArr *	undistortion_map,
		const float *	A,
		const float *	k,
		int	CV_UNREFERENCEDinterpolate
	)

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

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation