opencv: /usr/ports/pobj/OpenCV-2.2.0/OpenCV-2.2.0/modules/legacy/include/opencv2/legacy/compat.hpp File Reference

Classes | Defines | Typedefs | Enumerations | Functions

# /usr/ports/pobj/OpenCV-2.2.0/OpenCV-2.2.0/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
| ) |  |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines