/home/grier/opencv/opencv/modules/legacy/include/opencv2/legacy/compat.hpp File Reference

Go to the source code of this file.

Classes
struct	_CvPixelPosition32f
struct	_CvPixelPosition8s
struct	_CvPixelPosition8u
struct	CvRandState
Defines
#define	CV_GET_CURRENT(pos, cs)   ((pos).currline + (pos).x * (cs))
#define	CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation)
#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)
#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)
#define	CV_MOVE_PARAM_WRAP(pos, shift, 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)
#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)
#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
Typedefs
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 struct _CvPixelPosition32f	CvPixelPosition32f
typedef struct _CvPixelPosition8s	CvPixelPosition8s
typedef struct _CvPixelPosition8u	CvPixelPosition8u
typedef CvPoint2D64f	CvPoint2D64d
typedef CvPoint3D64f	CvPoint3D64d
typedef int	CvPolyApproxMethod
typedef struct CvRandState	CvRandState
typedef int	CvRodriguesType
typedef int	CvTemplMatchMethod
typedef int	CvThreshType
typedef float *	CvVect32f
typedef double *	CvVect64d
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
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_DEFAULT(CV_DIST_L2), CvDistanceFunction dist_func CV_DEFAULT(0), float *lower_bound CV_DEFAULT(0), void *user_param CV_DEFAULT(0))
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_DEFAULT(0))
CvRect	cvContourBoundingRect (void *point_set, int update CV_DEFAULT(0))
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_DEFAULT(0))
void	cvEndScanGraph (CvGraphScanner *scanner)
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)
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_DEFAULT(0))
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))
void	cvMean_StdDev (const CvArr *image, double *mean, double *sdv, const CvArr *mask CV_DEFAULT(0))
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)
void	cvPolyLineAA (CvArr *img, CvPoint **pts, int *npts, int contours, int is_closed, double color, int scale CV_DEFAULT(0))
void	cvProject3D (CvPoint3D32f *points3D, int count, CvPoint2D32f *points2D, int xIndx CV_DEFAULT(0), int yIndx CV_DEFAULT(1))
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_DEFAULT(CV_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)
void	cvStartScanGraph (CvGraph *graph, CvGraphScanner *scanner, CvGraphVtx *vtx CV_DEFAULT(NULL), int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS))
double	cvSumPixels (const CvArr *image)
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)

---

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

#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 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 struct _CvPixelPosition32f CvPixelPosition32f

typedef struct _CvPixelPosition8s CvPixelPosition8s

typedef struct _CvPixelPosition8u CvPixelPosition8u

typedef CvPoint2D64f CvPoint2D64d

typedef CvPoint3D64f CvPoint3D64d

typedef int CvPolyApproxMethod

typedef struct CvRandState CvRandState

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

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
	)

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
	)

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

double cvSumPixels

(

const CvArr *

image

)

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
	)