#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/ml/ml.hpp"
#include <iosfwd>
#include <limits>

Classes
union	CvInput

struct	CvImgObsInfo

struct	CvEHMMState

struct	CvEHMM

struct	CvGraphWeightedVtx

struct	CvGraphWeightedEdge

struct	CvCliqueFinder

struct	CvStereoLineCoeff

struct	CvCamera

struct	CvStereoCamera

struct	CvContourOrientation

struct	CvContourTree

struct	CvFaceData

struct	Cv3dTracker2dTrackedObject

struct	Cv3dTrackerTrackedObject

struct	Cv3dTrackerCameraInfo

struct	Cv3dTrackerCameraIntrinsics

struct	CvVoronoiSite2D

struct	CvVoronoiEdge2D

struct	CvVoronoiNode2D

struct	CvVoronoiDiagram2D

struct	CvLCMEdge

struct	CvLCMNode

struct	CvMatrix3

struct	CvConDensation

class	CvCalibFilter

class	CvImage

class	CvMatrix

class	CvCamShiftTracker

struct	CvEMParams

class	CvEM

class	cv::PatchGenerator

class	cv::LDetector

class	cv::FernClassifier

struct	cv::FernClassifier::Feature

struct	cv::BaseKeypoint

class	cv::RandomizedTree

struct	cv::RTreeNode

class	cv::RTreeClassifier

class	cv::CvAffinePose

class	cv::OneWayDescriptor

class	cv::OneWayDescriptorBase

class	cv::OneWayDescriptorObject

class	cv::OneWayDescriptorMatcher

class	cv::OneWayDescriptorMatcher::Params

class	cv::FernDescriptorMatcher

class	cv::FernDescriptorMatcher::Params

class	cv::CalonderDescriptorExtractor< T >

class	cv::BruteForceMatcher< Distance >

class	cv::PlanarObjectDetector

struct	lsh_hash

struct	CvLSHOperations

struct	CvStereoGCState

struct	CvBGStatModel

struct	CvFGDStatModelParams

struct	CvBGPixelCStatTable

struct	CvBGPixelCCStatTable

struct	CvBGPixelStat

struct	CvFGDStatModel

struct	CvGaussBGStatModelParams

struct	CvGaussBGValues

struct	CvGaussBGPoint

struct	CvGaussBGModel

struct	CvBGCodeBookElem

struct	CvBGCodeBookModel

Namespaces
	cv

Macros
#define	CV_EIGOBJ_NO_CALLBACK 0

#define	CV_EIGOBJ_INPUT_CALLBACK 1

#define	CV_EIGOBJ_OUTPUT_CALLBACK 2

#define	CV_EIGOBJ_BOTH_CALLBACK 3

#define	CV_COUNT_OBS(roi, win, delta, numObs)

#define	CV_CURRENT_INT(reader) (((int )(reader).ptr))

#define	CV_PREV_INT(reader) (((int )(reader).prev_elem))

#define	CV_GRAPH_WEIGHTED_VERTEX_FIELDS()

#define	CV_GRAPH_WEIGHTED_EDGE_FIELDS() CV_GRAPH_EDGE_FIELDS()

#define	CV_DOMINANT_IPAN 1

#define	CLIQUE_TIME_OFF 2

#define	CLIQUE_FOUND 1

#define	CLIQUE_END 0

#define	CV_UNDEF_SC_PARAM 12345

#define	CV_IDP_BIRCHFIELD_PARAM1 25

#define	CV_IDP_BIRCHFIELD_PARAM2 5

#define	CV_IDP_BIRCHFIELD_PARAM3 12

#define	CV_IDP_BIRCHFIELD_PARAM4 15

#define	CV_IDP_BIRCHFIELD_PARAM5 25

#define	CV_DISPARITY_BIRCHFIELD 0

#define	CV_CAMERA_TO_WARP 1

#define	CV_WARP_TO_CAMERA 2

#define	CV_VALUE 1

#define	CV_ARRAY 2

#define	CV_GLCM_OPTIMIZATION_NONE -2

#define	CV_GLCM_OPTIMIZATION_LUT -1

#define	CV_GLCM_OPTIMIZATION_HISTOGRAM 0

#define	CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST 10

#define	CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST 11

#define	CV_GLCMDESC_OPTIMIZATION_HISTOGRAM 4

#define	CV_GLCMDESC_ENTROPY 0

#define	CV_GLCMDESC_ENERGY 1

#define	CV_GLCMDESC_HOMOGENITY 2

#define	CV_GLCMDESC_CONTRAST 3

#define	CV_GLCMDESC_CLUSTERTENDENCY 4

#define	CV_GLCMDESC_CLUSTERSHADE 5

#define	CV_GLCMDESC_CORRELATION 6

#define	CV_GLCMDESC_CORRELATIONINFO1 7

#define	CV_GLCMDESC_CORRELATIONINFO2 8

#define	CV_GLCMDESC_MAXIMUMPROBABILITY 9

#define	CV_GLCM_ALL 0

#define	CV_GLCM_GLCM 1

#define	CV_GLCM_DESC 2

#define	CV_NUM_FACE_ELEMENTS 3

#define	CV_NEXT_VORONOISITE2D(SITE) ((SITE)->edge[0]->site[((SITE)->edge[0]->site[0] == (SITE))])

#define	CV_PREV_VORONOISITE2D(SITE) ((SITE)->edge[1]->site[((SITE)->edge[1]->site[0] == (SITE))])

#define	CV_FIRST_VORONOIEDGE2D(SITE) ((SITE)->edge[0])

#define	CV_LAST_VORONOIEDGE2D(SITE) ((SITE)->edge[1])

#define	CV_NEXT_VORONOIEDGE2D(EDGE, SITE) ((EDGE)->next[(EDGE)->site[0] != (SITE)])

#define	CV_PREV_VORONOIEDGE2D(EDGE, SITE) ((EDGE)->next[2 + ((EDGE)->site[0] != (SITE))])

#define	CV_VORONOIEDGE2D_BEGINNODE(EDGE, SITE) ((EDGE)->node[((EDGE)->site[0] != (SITE))])

#define	CV_VORONOIEDGE2D_ENDNODE(EDGE, SITE) ((EDGE)->node[((EDGE)->site[0] == (SITE))])

#define	CV_TWIN_VORONOISITE2D(SITE, EDGE) ( (EDGE)->site[((EDGE)->site[0] == (SITE))])

#define	CV_VORONOISITE2D_FIELDS()

#define	CV_VORONOIEDGE2D_FIELDS()

#define	CV_VORONOINODE2D_FIELDS()

#define	CV_VORONOIDIAGRAM2D_FIELDS()

#define	CV_STEREO_GC_OCCLUDED SHRT_MAX

#define	CV_BG_MODEL_FGD 0

#define	CV_BG_MODEL_MOG 1 /* "Mixture of Gaussians". */

#define	CV_BG_MODEL_FGD_SIMPLE 2

#define	CV_BG_STAT_MODEL_FIELDS()

#define	CV_BGFG_FGD_LC 128

#define	CV_BGFG_FGD_N1C 15

#define	CV_BGFG_FGD_N2C 25

#define	CV_BGFG_FGD_LCC 64

#define	CV_BGFG_FGD_N1CC 25

#define	CV_BGFG_FGD_N2CC 40

#define	CV_BGFG_FGD_ALPHA_1 0.1f

#define	CV_BGFG_FGD_ALPHA_2 0.005f

#define	CV_BGFG_FGD_ALPHA_3 0.1f

#define	CV_BGFG_FGD_DELTA 2

#define	CV_BGFG_FGD_T 0.9f

#define	CV_BGFG_FGD_MINAREA 15.f

#define	CV_BGFG_FGD_BG_UPDATE_TRESH 0.5f

#define	CV_BGFG_MOG_MAX_NGAUSSIANS 500

#define	CV_BGFG_MOG_BACKGROUND_THRESHOLD 0.7 /* threshold sum of weights for background test */

#define	CV_BGFG_MOG_STD_THRESHOLD 2.5 /* lambda=2.5 is 99% */

#define	CV_BGFG_MOG_WINDOW_SIZE 200 /* Learning rate; alpha = 1/CV_GBG_WINDOW_SIZE */

#define	CV_BGFG_MOG_NGAUSSIANS 5 /* = K = number of Gaussians in mixture */

#define	CV_BGFG_MOG_WEIGHT_INIT 0.05

#define	CV_BGFG_MOG_SIGMA_INIT 30

#define	CV_BGFG_MOG_MINAREA 15.f

#define	CV_BGFG_MOG_NCOLORS 3

Typedefs
typedef int(CV_CDECL *	CvCallback) (int index, void buffer, void user_data)

typedef CvImgObsInfo	Cv1DObsInfo

typedef struct CvGLCM	CvGLCM

typedef struct CvFaceTracker	CvFaceTracker

typedef unsigned char	CvBool

typedef CvEMParams	cv::EMParams

typedef CvEM	cv::ExpectationMaximization

typedef LDetector	cv::YAPE

typedef OneWayDescriptorMatcher	cv::OneWayDescriptorMatch

typedef FernDescriptorMatcher	cv::FernDescriptorMatch

typedef int(CV_CDECL *	CvUpdateBGStatModel) (IplImage curr_frame, struct CvBGStatModel bg_model, double learningRate)

Enumerations
enum	CvGraphWeightType { CV_NOT_WEIGHTED, CV_WEIGHTED_VTX, CV_WEIGHTED_EDGE, CV_WEIGHTED_ALL }

enum	{ CV_CONTOUR_TREES_MATCH_I1 = 1 }

enum	CV_FACE_ELEMENTS { CV_FACE_MOUTH = 0, CV_FACE_LEFT_EYE = 1, CV_FACE_RIGHT_EYE = 2 }

enum	CvLeeParameters { CV_LEE_INT = 0, CV_LEE_FLOAT = 1, CV_LEE_DOUBLE = 2, CV_LEE_AUTO = -1, CV_LEE_ERODE = 0, CV_LEE_ZOOM = 1, CV_LEE_NON = 2 }

enum	CvCalibEtalonType { CV_CALIB_ETALON_USER = -1, CV_CALIB_ETALON_CHESSBOARD = 0, CV_CALIB_ETALON_CHECKERBOARD = CV_CALIB_ETALON_CHESSBOARD }

Functions
CvSeq *	cvSegmentImage (const CvArr srcarr, CvArr dstarr, double canny_threshold, double ffill_threshold, CvMemStorage *storage)

void	cvCalcCovarMatrixEx (int nObjects, void input, int ioFlags, int ioBufSize, uchar buffer, void userData, IplImage avg, float *covarMatrix)

void	cvCalcEigenObjects (int nObjects, void input, void output, int ioFlags, int ioBufSize, void userData, CvTermCriteria calcLimit, IplImage avg, float eigVals)

double	cvCalcDecompCoeff (IplImage obj, IplImage eigObj, IplImage *avg)

void	cvEigenDecomposite (IplImage obj, int nEigObjs, void eigInput, int ioFlags, void userData, IplImage avg, float *coeffs)

void	cvEigenProjection (void eigInput, int nEigObjs, int ioFlags, void userData, float coeffs, IplImage avg, IplImage *proj)

CvEHMM *	cvCreate2DHMM (int stateNumber, int numMix, int obsSize)

void	cvRelease2DHMM (CvEHMM **hmm)

CvImgObsInfo *	cvCreateObsInfo (CvSize numObs, int obsSize)

void	cvReleaseObsInfo (CvImgObsInfo **obs_info)

void	cvImgToObs_DCT (const CvArr arr, float obs, CvSize dctSize, CvSize obsSize, CvSize delta)

void	cvUniformImgSegm (CvImgObsInfo obs_info, CvEHMM ehmm)

void	cvInitMixSegm (CvImgObsInfo *obs_info_array, int num_img, CvEHMM hmm)

void	cvEstimateHMMStateParams (CvImgObsInfo *obs_info_array, int num_img, CvEHMM hmm)

void	cvEstimateTransProb (CvImgObsInfo *obs_info_array, int num_img, CvEHMM hmm)

void	cvEstimateObsProb (CvImgObsInfo obs_info, CvEHMM hmm)

float	cvEViterbi (CvImgObsInfo obs_info, CvEHMM hmm)

void	cvMixSegmL2 (CvImgObsInfo *obs_info_array, int num_img, CvEHMM hmm)

void	cvCreateHandMask (CvSeq hand_points, IplImage img_mask, CvRect *roi)

void	cvFindHandRegion (CvPoint3D32f points, int count, CvSeq indexs, float line, CvSize2D32f size, int flag, CvPoint3D32f center, CvMemStorage storage, CvSeq *numbers)

void	cvFindHandRegionA (CvPoint3D32f points, int count, CvSeq indexs, float line, CvSize2D32f size, int jc, CvPoint3D32f center, CvMemStorage storage, CvSeq *numbers)

void	cvCalcImageHomography (float line, CvPoint3D32f center, float intrinsic, float homography)

void	cvCalcPGH (const CvSeq contour, CvHistogram hist)

CvSeq *	cvFindDominantPoints (CvSeq contour, CvMemStorage storage, int method CV_DEFAULT(1), double parameter1 CV_DEFAULT(0), double parameter2 CV_DEFAULT(0), double parameter3 CV_DEFAULT(0), double parameter4 CV_DEFAULT(0))

void	cvFindStereoCorrespondence (const CvArr leftImage, const CvArr rightImage, int mode, CvArr *dispImage, int maxDisparity, double param1 CV_DEFAULT(12345), double param2 CV_DEFAULT(12345), double param3 CV_DEFAULT(12345), double param4 CV_DEFAULT(12345), double param5 CV_DEFAULT(12345))

int	icvConvertWarpCoordinates (double coeffs[3][3], CvPoint2D32f cameraPoint, CvPoint2D32f warpPoint, int direction)

int	icvGetSymPoint3D (CvPoint3D64f pointCorner, CvPoint3D64f point1, CvPoint3D64f point2, CvPoint3D64f *pointSym2)

void	icvGetPieceLength3D (CvPoint3D64f point1, CvPoint3D64f point2, double *dist)

int	icvCompute3DPoint (double alpha, double betta, CvStereoLineCoeff coeffs, CvPoint3D64f point)

int	icvCreateConvertMatrVect (double rotMatr1, double transVect1, double rotMatr2, double transVect2, double convRotMatr, double convTransVect)

int	icvConvertPointSystem (CvPoint3D64f M2, CvPoint3D64f M1, double rotMatr, double *transVect)

int	icvComputeCoeffForStereo (CvStereoCamera *stereoCamera)

int	icvGetCrossPieceVector (CvPoint2D32f p1_start, CvPoint2D32f p1_end, CvPoint2D32f v2_start, CvPoint2D32f v2_end, CvPoint2D32f *cross)

int	icvGetCrossLineDirect (CvPoint2D32f p1, CvPoint2D32f p2, float a, float b, float c, CvPoint2D32f *cross)

float	icvDefinePointPosition (CvPoint2D32f point1, CvPoint2D32f point2, CvPoint2D32f point)

int	icvStereoCalibration (int numImages, int nums, CvSize imageSize, CvPoint2D32f imagePoints1, CvPoint2D32f imagePoints2, CvPoint3D32f objectPoints, CvStereoCamera *stereoparams)

int	icvComputeRestStereoParams (CvStereoCamera *stereoparams)

void	cvComputePerspectiveMap (const double coeffs[3][3], CvArr rectMapX, CvArr rectMapY)

int	icvComCoeffForLine (CvPoint2D64f point1, CvPoint2D64f point2, CvPoint2D64f point3, CvPoint2D64f point4, double camMatr1, double rotMatr1, double transVect1, double camMatr2, double rotMatr2, double transVect2, CvStereoLineCoeff coeffs, int needSwapCameras)

int	icvGetDirectionForPoint (CvPoint2D64f point, double camMatr, CvPoint3D64f direct)

int	icvGetCrossLines (CvPoint3D64f point11, CvPoint3D64f point12, CvPoint3D64f point21, CvPoint3D64f point22, CvPoint3D64f *midPoint)

int	icvComputeStereoLineCoeffs (CvPoint3D64f pointA, CvPoint3D64f pointB, CvPoint3D64f pointCam1, double gamma, CvStereoLineCoeff *coeffs)

int	icvGetAngleLine (CvPoint2D64f startPoint, CvSize imageSize, CvPoint2D64f point1, CvPoint2D64f point2)

void	icvGetCoefForPiece (CvPoint2D64f p_start, CvPoint2D64f p_end, double a, double b, double c, int result)

void	icvComputeeInfiniteProject1 (double rotMatr, double camMatr1, double camMatr2, CvPoint2D32f point1, CvPoint2D32f point2)

void	icvComputeeInfiniteProject2 (double rotMatr, double camMatr1, double camMatr2, CvPoint2D32f point1, CvPoint2D32f point2)

void	icvGetCrossDirectDirect (double direct1, double direct2, CvPoint2D64f cross, int result)

void	icvGetCrossPieceDirect (CvPoint2D64f p_start, CvPoint2D64f p_end, double a, double b, double c, CvPoint2D64f cross, int result)

void	icvGetCrossPiecePiece (CvPoint2D64f p1_start, CvPoint2D64f p1_end, CvPoint2D64f p2_start, CvPoint2D64f p2_end, CvPoint2D64f cross, int result)

void	icvGetPieceLength (CvPoint2D64f point1, CvPoint2D64f point2, double *dist)

void	icvGetCrossRectDirect (CvSize imageSize, double a, double b, double c, CvPoint2D64f start, CvPoint2D64f end, int *result)

void	icvProjectPointToImage (CvPoint3D64f point, double camMatr, double rotMatr, double transVect, CvPoint2D64f projPoint)

void	icvGetQuadsTransform (CvSize imageSize, double camMatr1, double rotMatr1, double transVect1, double camMatr2, double rotMatr2, double transVect2, CvSize warpSize, double quad1[4][2], double quad2[4][2], double fundMatr, CvPoint3D64f epipole1, CvPoint3D64f epipole2)

void	icvGetQuadsTransformStruct (CvStereoCamera *stereoCamera)

void	icvComputeStereoParamsForCameras (CvStereoCamera *stereoCamera)

void	icvGetCutPiece (double areaLineCoef1, double areaLineCoef2, CvPoint2D64f epipole, CvSize imageSize, CvPoint2D64f point11, CvPoint2D64f point12, CvPoint2D64f point21, CvPoint2D64f point22, int *result)

void	icvGetMiddleAnglePoint (CvPoint2D64f basePoint, CvPoint2D64f point1, CvPoint2D64f point2, CvPoint2D64f *midPoint)

void	icvGetNormalDirect (double direct, CvPoint2D64f point, double normDirect)

double	icvGetVect (CvPoint2D64f basePoint, CvPoint2D64f point1, CvPoint2D64f point2)

void	icvProjectPointToDirect (CvPoint2D64f point, double lineCoeff, CvPoint2D64f projectPoint)

void	icvGetDistanceFromPointToDirect (CvPoint2D64f point, double lineCoef, double dist)

IplImage *	icvCreateIsometricImage (IplImage src, IplImage dst, int desired_depth, int desired_num_channels)

void	cvDeInterlace (const CvArr frame, CvArr fieldEven, CvArr *fieldOdd)

CvContourTree *	cvCreateContourTree (const CvSeq contour, CvMemStorage storage, double threshold)

CvSeq *	cvContourFromContourTree (const CvContourTree tree, CvMemStorage storage, CvTermCriteria criteria)

double	cvMatchContourTrees (const CvContourTree tree1, const CvContourTree tree2, int method, double threshold)

CvSeq *	cvCalcContoursCorrespondence (const CvSeq contour1, const CvSeq contour2, CvMemStorage *storage)

CvSeq *	cvMorphContours (const CvSeq contour1, const CvSeq contour2, CvSeq corr, double alpha, CvMemStorage storage)

void	cvSnakeImage (const IplImage image, CvPoint points, int length, float alpha, float beta, float *gamma, int coeff_usage, CvSize win, CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1))

CvGLCM *	cvCreateGLCM (const IplImage srcImage, int stepMagnitude, const int stepDirections CV_DEFAULT(0), int numStepDirections CV_DEFAULT(0), int optimizationType CV_DEFAULT(-2))

void	cvReleaseGLCM (CvGLCM **GLCM, int flag CV_DEFAULT(0))

void	cvCreateGLCMDescriptors (CvGLCM *destGLCM, int descriptorOptimizationType CV_DEFAULT(10))

double	cvGetGLCMDescriptor (CvGLCM *GLCM, int step, int descriptor)

void	cvGetGLCMDescriptorStatistics (CvGLCM GLCM, int descriptor, double average, double *standardDeviation)

IplImage *	cvCreateGLCMImage (CvGLCM *GLCM, int step)

CvFaceTracker *	cvInitFaceTracker (CvFaceTracker pFaceTracking, const IplImage imgGray, CvRect *pRects, int nRects)

int	cvTrackFace (CvFaceTracker pFaceTracker, IplImage imgGray, CvRect pRects, int nRects, CvPoint ptRotate, double *dbAngleRotate)

void	cvReleaseFaceTracker (CvFaceTracker **ppFaceTracker)

CvSeq *	cvFindFace (IplImage Image, CvMemStorage storage)

CvSeq *	cvPostBoostingFindFace (IplImage Image, CvMemStorage storage)

CV_INLINE Cv3dTracker2dTrackedObject	cv3dTracker2dTrackedObject (int id, CvPoint2D32f p)

CV_INLINE Cv3dTrackerTrackedObject	cv3dTrackerTrackedObject (int id, CvPoint3D32f p)

CvBool	cv3dTrackerCalibrateCameras (int num_cameras, const Cv3dTrackerCameraIntrinsics camera_intrinsics[], CvSize etalon_size, float square_size, IplImage *samples[], Cv3dTrackerCameraInfo camera_info[])

int	cv3dTrackerLocateObjects (int num_cameras, int num_objects, const Cv3dTrackerCameraInfo camera_info[], const Cv3dTracker2dTrackedObject tracking_info[], Cv3dTrackerTrackedObject tracked_objects[])

int	cvVoronoiDiagramFromContour (CvSeq ContourSeq, CvVoronoiDiagram2D VoronoiDiagram, CvMemStorage VoronoiStorage, CvLeeParameters contour_type CV_DEFAULT(CV_LEE_INT), int contour_orientation CV_DEFAULT(-1), int attempt_number CV_DEFAULT(10))

int	cvVoronoiDiagramFromImage (IplImage pImage, CvSeq ContourSeq, CvVoronoiDiagram2D VoronoiDiagram, CvMemStorage VoronoiStorage, CvLeeParameters regularization_method CV_DEFAULT(CV_LEE_NON), float approx_precision CV_DEFAULT(CV_LEE_AUTO))

void	cvReleaseVoronoiStorage (CvVoronoiDiagram2D VoronoiDiagram, CvMemStorage *pVoronoiStorage)

CvGraph *	cvLinearContorModelFromVoronoiDiagram (CvVoronoiDiagram2D *VoronoiDiagram, float maxWidth)

int	cvReleaseLinearContorModelStorage (CvGraph **Graph)

void	cvInitPerspectiveTransform (CvSize size, const CvPoint2D32f vertex[4], double matrix[3][3], CvArr *rectMap)

void	cvMakeScanlines (const CvMatrix3 matrix, CvSize img_size, int scanlines1, int scanlines2, int lengths1, int lengths2, int line_count)

void	cvPreWarpImage (int line_count, IplImage img, uchar dst, int dst_nums, int scanlines)

void	cvFindRuns (int line_count, uchar prewarp1, uchar prewarp2, int line_lengths1, int line_lengths2, int runs1, int runs2, int num_runs1, int num_runs2)

void	cvDynamicCorrespondMulti (int line_count, int first, int first_runs, int second, int second_runs, int first_corr, int second_corr)

void	cvMakeAlphaScanlines (int scanlines1, int scanlines2, int scanlinesA, int lengths, int line_count, float alpha)

void	cvMorphEpilinesMulti (int line_count, uchar first_pix, int first_num, uchar second_pix, int second_num, uchar dst_pix, int dst_num, float alpha, int first, int first_runs, int second, int second_runs, int first_corr, int second_corr)

void	cvPostWarpImage (int line_count, uchar src, int src_nums, IplImage img, int scanlines)

void	cvDeleteMoire (IplImage *img)

CvConDensation *	cvCreateConDensation (int dynam_params, int measure_params, int sample_count)

void	cvReleaseConDensation (CvConDensation **condens)

void	cvConDensUpdateByTime (CvConDensation *condens)

void	cvConDensInitSampleSet (CvConDensation condens, CvMat lower_bound, CvMat *upper_bound)

CV_INLINE int	iplWidth (const IplImage *img)

CV_INLINE int	iplHeight (const IplImage *img)

uchar *	cv::getData (IplImage *image)

void	cvPyrSegmentation (IplImage src, IplImage dst, CvMemStorage storage, CvSeq *comp, int level, double threshold1, double threshold2)

void	cvInitSubdivDelaunay2D (CvSubdiv2D *subdiv, CvRect rect)

CvSubdiv2D *	cvCreateSubdiv2D (int subdiv_type, int header_size, int vtx_size, int quadedge_size, CvMemStorage *storage)

CV_INLINE CvSubdiv2D *	cvCreateSubdivDelaunay2D (CvRect rect, CvMemStorage *storage)

CvSubdiv2DPoint *	cvSubdivDelaunay2DInsert (CvSubdiv2D *subdiv, CvPoint2D32f pt)

CvSubdiv2DPointLocation	cvSubdiv2DLocate (CvSubdiv2D subdiv, CvPoint2D32f pt, CvSubdiv2DEdge edge, CvSubdiv2DPoint **vertex CV_DEFAULT(NULL))

void	cvCalcSubdivVoronoi2D (CvSubdiv2D *subdiv)

void	cvClearSubdivVoronoi2D (CvSubdiv2D *subdiv)

CvSubdiv2DPoint *	cvFindNearestPoint2D (CvSubdiv2D *subdiv, CvPoint2D32f pt)

CV_INLINE CvSubdiv2DEdge	cvSubdiv2DNextEdge (CvSubdiv2DEdge edge)

CV_INLINE CvSubdiv2DEdge	cvSubdiv2DRotateEdge (CvSubdiv2DEdge edge, int rotate)

CV_INLINE CvSubdiv2DEdge	cvSubdiv2DSymEdge (CvSubdiv2DEdge edge)

CV_INLINE CvSubdiv2DEdge	cvSubdiv2DGetEdge (CvSubdiv2DEdge edge, CvNextEdgeType type)

CV_INLINE CvSubdiv2DPoint *	cvSubdiv2DEdgeOrg (CvSubdiv2DEdge edge)

CV_INLINE CvSubdiv2DPoint *	cvSubdiv2DEdgeDst (CvSubdiv2DEdge edge)

void	icvDrawMosaic (CvSubdiv2D subdiv, IplImage src, IplImage *dst)

int	icvSubdiv2DCheck (CvSubdiv2D *subdiv)

CV_INLINE double	icvSqDist2D32f (CvPoint2D32f pt1, CvPoint2D32f pt2)

CV_INLINE double	cvTriangleArea (CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c)

struct CvFeatureTree *	cvCreateKDTree (CvMat *desc)

struct CvFeatureTree *	cvCreateSpillTree (const CvMat *raw_data, const int naive CV_DEFAULT(50), const double rho CV_DEFAULT(.7), const double tau CV_DEFAULT(.1))

void	cvReleaseFeatureTree (struct CvFeatureTree *tr)

void	cvFindFeatures (struct CvFeatureTree tr, const CvMat query_points, CvMat indices, CvMat dist, int k, int emax CV_DEFAULT(20))

int	cvFindFeaturesBoxed (struct CvFeatureTree tr, CvMat bounds_min, CvMat bounds_max, CvMat out_indices)

struct CvLSH *	cvCreateLSH (struct CvLSHOperations *ops, int d, int L CV_DEFAULT(10), int k CV_DEFAULT(10), int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4), int64 seed CV_DEFAULT(-1))

struct CvLSH *	cvCreateMemoryLSH (int d, int n, int L CV_DEFAULT(10), int k CV_DEFAULT(10), int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4), int64 seed CV_DEFAULT(-1))

void	cvReleaseLSH (struct CvLSH **lsh)

unsigned int	LSHSize (struct CvLSH *lsh)

void	cvLSHAdd (struct CvLSH lsh, const CvMat data, CvMat *indices CV_DEFAULT(0))

void	cvLSHRemove (struct CvLSH lsh, const CvMat indices)

void	cvLSHQuery (struct CvLSH lsh, const CvMat query_points, CvMat indices, CvMat dist, int k, int emax)

CvStereoGCState *	cvCreateStereoGCState (int numberOfDisparities, int maxIters)

void	cvReleaseStereoGCState (CvStereoGCState **state)

void	cvFindStereoCorrespondenceGC (const CvArr left, const CvArr right, CvArr disparityLeft, CvArr disparityRight, CvStereoGCState *state, int useDisparityGuess CV_DEFAULT(0))

void	cvCalcOpticalFlowLK (const CvArr prev, const CvArr curr, CvSize win_size, CvArr velx, CvArr vely)

void	cvCalcOpticalFlowBM (const CvArr prev, const CvArr curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, CvArr velx, CvArr vely)

void	cvCalcOpticalFlowHS (const CvArr prev, const CvArr curr, int use_previous, CvArr velx, CvArr vely, double lambda, CvTermCriteria criteria)

typedef	void (CV_CDECL CvReleaseBGStatModel)(struct CvBGStatModel *bg_model)

void	cvReleaseBGStatModel (CvBGStatModel **bg_model)

int	cvUpdateBGStatModel (IplImage current_frame, CvBGStatModel bg_model, double learningRate CV_DEFAULT(-1))

void	cvRefineForegroundMaskBySegm (CvSeq segments, CvBGStatModel bg_model)

int	cvChangeDetection (IplImage prev_frame, IplImage curr_frame, IplImage *change_mask)

CvBGStatModel *	cvCreateFGDStatModel (IplImage first_frame, CvFGDStatModelParams parameters CV_DEFAULT(NULL))

CvBGStatModel *	cvCreateGaussianBGModel (IplImage first_frame, CvGaussBGStatModelParams parameters CV_DEFAULT(NULL))

CvBGCodeBookModel *	cvCreateBGCodeBookModel (void)

void	cvReleaseBGCodeBookModel (CvBGCodeBookModel **model)

void	cvBGCodeBookUpdate (CvBGCodeBookModel model, const CvArr image, CvRect roi CV_DEFAULT(cvRect(0, 0, 0, 0)), const CvArr *mask CV_DEFAULT(0))

int	cvBGCodeBookDiff (const CvBGCodeBookModel model, const CvArr image, CvArr *fgmask, CvRect roi CV_DEFAULT(cvRect(0, 0, 0, 0)))

void	cvBGCodeBookClearStale (CvBGCodeBookModel model, int staleThresh, CvRect roi CV_DEFAULT(cvRect(0, 0, 0, 0)), const CvArr mask CV_DEFAULT(0))

CvSeq *	cvSegmentFGMask (CvArr fgmask, int poly1Hull0 CV_DEFAULT(1), float perimScale CV_DEFAULT(4.f), CvMemStorage storage CV_DEFAULT(0), CvPoint offset CV_DEFAULT(cvPoint(0, 0)))

Macro Definition Documentation

#define CLIQUE_END 0

#define CLIQUE_FOUND 1

#define CLIQUE_TIME_OFF 2

#define CV_ARRAY 2

#define CV_BG_MODEL_FGD 0

#define CV_BG_MODEL_FGD_SIMPLE 2

#define CV_BG_MODEL_MOG 1 /* "Mixture of Gaussians". */

#define CV_BG_STAT_MODEL_FIELDS ( )

Value:

int             type; /*type of BG model*/                                      \
CvReleaseBGStatModel release;                                                   \
CvUpdateBGStatModel update;                                                     \
IplImage*       background;   /*8UC3 reference background image*/               \
IplImage*       foreground;   /*8UC1 foreground image*/                         \
IplImage**      layers;       /*8UC3 reference background image, can be null */ \
int             layer_count;  /* can be zero */                                 \
CvMemStorage*   storage;      /*storage for foreground_regions*/                \
CvSeq*          foreground_regions /*foreground object contours*/

#define CV_BGFG_FGD_ALPHA_1 0.1f

#define CV_BGFG_FGD_ALPHA_2 0.005f

#define CV_BGFG_FGD_ALPHA_3 0.1f

#define CV_BGFG_FGD_BG_UPDATE_TRESH 0.5f

#define CV_BGFG_FGD_DELTA 2

#define CV_BGFG_FGD_LC 128

#define CV_BGFG_FGD_LCC 64

#define CV_BGFG_FGD_MINAREA 15.f

#define CV_BGFG_FGD_N1C 15

#define CV_BGFG_FGD_N1CC 25

#define CV_BGFG_FGD_N2C 25

#define CV_BGFG_FGD_N2CC 40

#define CV_BGFG_FGD_T 0.9f

#define CV_BGFG_MOG_BACKGROUND_THRESHOLD 0.7 /* threshold sum of weights for background test */

#define CV_BGFG_MOG_MAX_NGAUSSIANS 500

#define CV_BGFG_MOG_MINAREA 15.f

#define CV_BGFG_MOG_NCOLORS 3

#define CV_BGFG_MOG_NGAUSSIANS 5 /* = K = number of Gaussians in mixture */

#define CV_BGFG_MOG_SIGMA_INIT 30

#define CV_BGFG_MOG_STD_THRESHOLD 2.5 /* lambda=2.5 is 99% */

#define CV_BGFG_MOG_WEIGHT_INIT 0.05

#define CV_BGFG_MOG_WINDOW_SIZE 200 /* Learning rate; alpha = 1/CV_GBG_WINDOW_SIZE */

#define CV_CAMERA_TO_WARP 1

#define CV_COUNT_OBS	(	roi,
		win,
		delta,
		numObs
	)

Value:

{                                                                                    \
   (numObs)->width  =((roi)->width  -(win)->width  +(delta)->width)/(delta)->width;  \
   (numObs)->height =((roi)->height -(win)->height +(delta)->height)/(delta)->height;\
}

#define CV_CURRENT_INT ( reader ) (*((int *)(reader).ptr))

#define CV_DISPARITY_BIRCHFIELD 0

#define CV_DOMINANT_IPAN 1

#define CV_EIGOBJ_BOTH_CALLBACK 3

#define CV_EIGOBJ_INPUT_CALLBACK 1

#define CV_EIGOBJ_NO_CALLBACK 0

#define CV_EIGOBJ_OUTPUT_CALLBACK 2

#define CV_FIRST_VORONOIEDGE2D ( SITE ) ((SITE)->edge[0])

#define CV_GLCM_ALL 0

#define CV_GLCM_DESC 2

#define CV_GLCM_GLCM 1

#define CV_GLCM_OPTIMIZATION_HISTOGRAM 0

#define CV_GLCM_OPTIMIZATION_LUT -1

#define CV_GLCM_OPTIMIZATION_NONE -2

#define CV_GLCMDESC_CLUSTERSHADE 5

#define CV_GLCMDESC_CLUSTERTENDENCY 4

#define CV_GLCMDESC_CONTRAST 3

#define CV_GLCMDESC_CORRELATION 6

#define CV_GLCMDESC_CORRELATIONINFO1 7

#define CV_GLCMDESC_CORRELATIONINFO2 8

#define CV_GLCMDESC_ENERGY 1

#define CV_GLCMDESC_ENTROPY 0

#define CV_GLCMDESC_HOMOGENITY 2

#define CV_GLCMDESC_MAXIMUMPROBABILITY 9

#define CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST 10

#define CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST 11

#define CV_GLCMDESC_OPTIMIZATION_HISTOGRAM 4

#define CV_GRAPH_WEIGHTED_EDGE_FIELDS ( ) CV_GRAPH_EDGE_FIELDS()

#define CV_GRAPH_WEIGHTED_VERTEX_FIELDS ( )

Value:

CV_GRAPH_VERTEX_FIELDS()\

float weight;

CV_GRAPH_VERTEX_FIELDS

#define CV_GRAPH_VERTEX_FIELDS()

Definition: core/include/opencv2/core/types_c.h:1431

#define CV_IDP_BIRCHFIELD_PARAM1 25

#define CV_IDP_BIRCHFIELD_PARAM2 5

#define CV_IDP_BIRCHFIELD_PARAM3 12

#define CV_IDP_BIRCHFIELD_PARAM4 15

#define CV_IDP_BIRCHFIELD_PARAM5 25

#define CV_LAST_VORONOIEDGE2D ( SITE ) ((SITE)->edge[1])

#define CV_NEXT_VORONOIEDGE2D	(	EDGE,
		SITE
	)	((EDGE)->next[(EDGE)->site[0] != (SITE)])

#define CV_NEXT_VORONOISITE2D ( SITE ) ((SITE)->edge[0]->site[((SITE)->edge[0]->site[0] == (SITE))])

#define CV_NUM_FACE_ELEMENTS 3

#define CV_PREV_INT ( reader ) (*((int *)(reader).prev_elem))

#define CV_PREV_VORONOIEDGE2D	(	EDGE,
		SITE
	)	((EDGE)->next[2 + ((EDGE)->site[0] != (SITE))])

#define CV_PREV_VORONOISITE2D ( SITE ) ((SITE)->edge[1]->site[((SITE)->edge[1]->site[0] == (SITE))])

#define CV_STEREO_GC_OCCLUDED SHRT_MAX

#define CV_TWIN_VORONOISITE2D	(	SITE,
		EDGE
	)	( (EDGE)->site[((EDGE)->site[0] == (SITE))])

#define CV_UNDEF_SC_PARAM 12345

#define CV_VALUE 1

#define CV_VORONOIDIAGRAM2D_FIELDS ( )

Value:

CV_GRAPH_FIELDS() \

CvSet *sites;

CV_GRAPH_FIELDS

#define CV_GRAPH_FIELDS()

Definition: core/include/opencv2/core/types_c.h:1459

#define CV_VORONOIEDGE2D_BEGINNODE	(	EDGE,
		SITE
	)	((EDGE)->node[((EDGE)->site[0] != (SITE))])

#define CV_VORONOIEDGE2D_ENDNODE	(	EDGE,
		SITE
	)	((EDGE)->node[((EDGE)->site[0] == (SITE))])

#define CV_VORONOIEDGE2D_FIELDS ( )

Value:

struct CvVoronoiNode2D *node[2]; \
    struct CvVoronoiSite2D *site[2]; \
    struct CvVoronoiEdge2D *next[4];

#define CV_VORONOINODE2D_FIELDS ( )

Value:

CV_SET_ELEM_FIELDS(CvVoronoiNode2D) \
    CvPoint2D32f pt;                    \
    float radius;

#define CV_VORONOISITE2D_FIELDS ( )

Value:

struct CvVoronoiNode2D *node[2]; \

struct CvVoronoiEdge2D *edge[2];

CvVoronoiEdge2D

Definition: legacy.hpp:995

CvVoronoiNode2D

Definition: legacy.hpp:1005

#define CV_WARP_TO_CAMERA 2

Typedef Documentation

typedef CvImgObsInfo Cv1DObsInfo

typedef unsigned char CvBool

typedef int(CV_CDECL * CvCallback) (int index, void *buffer, void *user_data)

typedef struct CvFaceTracker CvFaceTracker

typedef struct CvGLCM CvGLCM

typedef int(CV_CDECL * CvUpdateBGStatModel) (IplImage *curr_frame, struct CvBGStatModel *bg_model, double learningRate)

Enumeration Type Documentation

anonymous enum

Enumerator
CV_CONTOUR_TREES_MATCH_I1

enum CV_FACE_ELEMENTS

Enumerator
CV_FACE_MOUTH
CV_FACE_LEFT_EYE
CV_FACE_RIGHT_EYE

enum CvCalibEtalonType

Enumerator
CV_CALIB_ETALON_USER
CV_CALIB_ETALON_CHESSBOARD
CV_CALIB_ETALON_CHECKERBOARD

enum CvGraphWeightType

Enumerator
CV_NOT_WEIGHTED
CV_WEIGHTED_VTX
CV_WEIGHTED_EDGE
CV_WEIGHTED_ALL

enum CvLeeParameters

Enumerator
CV_LEE_INT
CV_LEE_FLOAT
CV_LEE_DOUBLE
CV_LEE_AUTO
CV_LEE_ERODE
CV_LEE_ZOOM
CV_LEE_NON

Function Documentation

CV_INLINE Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject	(	int	id,
		CvPoint2D32f	p
	)

CvBool cv3dTrackerCalibrateCameras	(	int	num_cameras,
		const Cv3dTrackerCameraIntrinsics	camera_intrinsics[],
		CvSize	etalon_size,
		float	square_size,
		IplImage *	samples[],
		Cv3dTrackerCameraInfo	camera_info[]
	)

int cv3dTrackerLocateObjects	(	int	num_cameras,
		int	num_objects,
		const Cv3dTrackerCameraInfo	camera_info[],
		const Cv3dTracker2dTrackedObject	tracking_info[],
		Cv3dTrackerTrackedObject	tracked_objects[]
	)

CV_INLINE Cv3dTrackerTrackedObject cv3dTrackerTrackedObject	(	int	id,
		CvPoint3D32f	p
	)

void cvBGCodeBookClearStale	(	CvBGCodeBookModel *	model,
		int	staleThresh,
		CvRect roi	CV_DEFAULTcvRect(0, 0, 0, 0),
		const CvArr *mask	CV_DEFAULT0
	)

int cvBGCodeBookDiff	(	const CvBGCodeBookModel *	model,
		const CvArr *	image,
		CvArr *	fgmask,
		CvRect roi	CV_DEFAULTcvRect(0, 0, 0, 0)
	)

void cvBGCodeBookUpdate	(	CvBGCodeBookModel *	model,
		const CvArr *	image,
		CvRect roi	CV_DEFAULTcvRect(0, 0, 0, 0),
		const CvArr *mask	CV_DEFAULT0
	)

CvSeq* cvCalcContoursCorrespondence	(	const CvSeq *	contour1,
		const CvSeq *	contour2,
		CvMemStorage *	storage
	)

void cvCalcCovarMatrixEx	(	int	nObjects,
		void *	input,
		int	ioFlags,
		int	ioBufSize,
		uchar *	buffer,
		void *	userData,
		IplImage *	avg,
		float *	covarMatrix
	)

double cvCalcDecompCoeff	(	IplImage *	obj,
		IplImage *	eigObj,
		IplImage *	avg
	)

void cvCalcEigenObjects	(	int	nObjects,
		void *	input,
		void *	output,
		int	ioFlags,
		int	ioBufSize,
		void *	userData,
		CvTermCriteria *	calcLimit,
		IplImage *	avg,
		float *	eigVals
	)

void cvCalcImageHomography	(	float *	line,
		CvPoint3D32f *	center,
		float *	intrinsic,
		float *	homography
	)

void cvCalcOpticalFlowBM	(	const CvArr *	prev,
		const CvArr *	curr,
		CvSize	block_size,
		CvSize	shift_size,
		CvSize	max_range,
		int	use_previous,
		CvArr *	velx,
		CvArr *	vely
	)

void cvCalcOpticalFlowHS	(	const CvArr *	prev,
		const CvArr *	curr,
		int	use_previous,
		CvArr *	velx,
		CvArr *	vely,
		double	lambda,
		CvTermCriteria	criteria
	)

void cvCalcOpticalFlowLK	(	const CvArr *	prev,
		const CvArr *	curr,
		CvSize	win_size,
		CvArr *	velx,
		CvArr *	vely
	)

void cvCalcPGH	(	const CvSeq *	contour,
		CvHistogram *	hist
	)

void cvCalcSubdivVoronoi2D ( CvSubdiv2D * subdiv )

int cvChangeDetection	(	IplImage *	prev_frame,
		IplImage *	curr_frame,
		IplImage *	change_mask
	)

void cvClearSubdivVoronoi2D ( CvSubdiv2D * subdiv )

void cvComputePerspectiveMap	(	const double	coeffs[3][3],
		CvArr *	rectMapX,
		CvArr *	rectMapY
	)

void cvConDensInitSampleSet	(	CvConDensation *	condens,
		CvMat *	lower_bound,
		CvMat *	upper_bound
	)

void cvConDensUpdateByTime ( CvConDensation * condens )

CvSeq* cvContourFromContourTree	(	const CvContourTree *	tree,
		CvMemStorage *	storage,
		CvTermCriteria	criteria
	)

CvEHMM* cvCreate2DHMM	(	int *	stateNumber,
		int *	numMix,
		int	obsSize
	)

CvBGCodeBookModel* cvCreateBGCodeBookModel ( void )

CvConDensation* cvCreateConDensation	(	int	dynam_params,
		int	measure_params,
		int	sample_count
	)

CvContourTree* cvCreateContourTree	(	const CvSeq *	contour,
		CvMemStorage *	storage,
		double	threshold
	)

CvBGStatModel* cvCreateFGDStatModel	(	IplImage *	first_frame,
		CvFGDStatModelParams *parameters	CV_DEFAULTNULL
	)

CvBGStatModel* cvCreateGaussianBGModel	(	IplImage *	first_frame,
		CvGaussBGStatModelParams *parameters	CV_DEFAULTNULL
	)

CvGLCM* cvCreateGLCM	(	const IplImage *	srcImage,
		int	stepMagnitude,
		const int *stepDirections	CV_DEFAULT0,
		int numStepDirections	CV_DEFAULT0,
		int optimizationType	CV_DEFAULT-2
	)

void cvCreateGLCMDescriptors	(	CvGLCM *	destGLCM,
		int descriptorOptimizationType	CV_DEFAULT10
	)

IplImage* cvCreateGLCMImage	(	CvGLCM *	GLCM,
		int	step
	)

void cvCreateHandMask	(	CvSeq *	hand_points,
		IplImage *	img_mask,
		CvRect *	roi
	)

struct CvFeatureTree* cvCreateKDTree ( CvMat * desc )

struct CvLSH* cvCreateLSH	(	struct CvLSHOperations *	ops,
		int	d,
		int L	CV_DEFAULT10,
		int k	CV_DEFAULT10,
		int type	CV_DEFAULTCV_64FC1,
		double r	CV_DEFAULT4,
		int64 seed	CV_DEFAULT-1
	)

struct CvLSH* cvCreateMemoryLSH	(	int	d,
		int	n,
		int L	CV_DEFAULT10,
		int k	CV_DEFAULT10,
		int type	CV_DEFAULTCV_64FC1,
		double r	CV_DEFAULT4,
		int64 seed	CV_DEFAULT-1
	)

CvImgObsInfo* cvCreateObsInfo	(	CvSize	numObs,
		int	obsSize
	)

struct CvFeatureTree* cvCreateSpillTree	(	const CvMat *	raw_data,
		const int naive	CV_DEFAULT50,
		const double rho	CV_DEFAULT.7,
		const double tau	CV_DEFAULT.1
	)

CvStereoGCState* cvCreateStereoGCState	(	int	numberOfDisparities,
		int	maxIters
	)

CvSubdiv2D* cvCreateSubdiv2D	(	int	subdiv_type,
		int	header_size,
		int	vtx_size,
		int	quadedge_size,
		CvMemStorage *	storage
	)

CV_INLINE CvSubdiv2D* cvCreateSubdivDelaunay2D	(	CvRect	rect,
		CvMemStorage *	storage
	)

void cvDeInterlace	(	const CvArr *	frame,
		CvArr *	fieldEven,
		CvArr *	fieldOdd
	)

void cvDeleteMoire ( IplImage * img )

void cvDynamicCorrespondMulti	(	int	line_count,
		int *	first,
		int *	first_runs,
		int *	second,
		int *	second_runs,
		int *	first_corr,
		int *	second_corr
	)

void cvEigenDecomposite	(	IplImage *	obj,
		int	nEigObjs,
		void *	eigInput,
		int	ioFlags,
		void *	userData,
		IplImage *	avg,
		float *	coeffs
	)

void cvEigenProjection	(	void *	eigInput,
		int	nEigObjs,
		int	ioFlags,
		void *	userData,
		float *	coeffs,
		IplImage *	avg,
		IplImage *	proj
	)

void cvEstimateHMMStateParams	(	CvImgObsInfo **	obs_info_array,
		int	num_img,
		CvEHMM *	hmm
	)

void cvEstimateObsProb	(	CvImgObsInfo *	obs_info,
		CvEHMM *	hmm
	)

void cvEstimateTransProb	(	CvImgObsInfo **	obs_info_array,
		int	num_img,
		CvEHMM *	hmm
	)

float cvEViterbi	(	CvImgObsInfo *	obs_info,
		CvEHMM *	hmm
	)

CvSeq* cvFindDominantPoints	(	CvSeq *	contour,
		CvMemStorage *	storage,
		int method	CV_DEFAULT1,
		double parameter1	CV_DEFAULT0,
		double parameter2	CV_DEFAULT0,
		double parameter3	CV_DEFAULT0,
		double parameter4	CV_DEFAULT0
	)

CvSeq* cvFindFace	(	IplImage *	Image,
		CvMemStorage *	storage
	)

void cvFindFeatures	(	struct CvFeatureTree *	tr,
		const CvMat *	query_points,
		CvMat *	indices,
		CvMat *	dist,
		int	k,
		int emax	CV_DEFAULT20
	)

int cvFindFeaturesBoxed	(	struct CvFeatureTree *	tr,
		CvMat *	bounds_min,
		CvMat *	bounds_max,
		CvMat *	out_indices
	)

void cvFindHandRegion	(	CvPoint3D32f *	points,
		int	count,
		CvSeq *	indexs,
		float *	line,
		CvSize2D32f	size,
		int	flag,
		CvPoint3D32f *	center,
		CvMemStorage *	storage,
		CvSeq **	numbers
	)

void cvFindHandRegionA	(	CvPoint3D32f *	points,
		int	count,
		CvSeq *	indexs,
		float *	line,
		CvSize2D32f	size,
		int	jc,
		CvPoint3D32f *	center,
		CvMemStorage *	storage,
		CvSeq **	numbers
	)

CvSubdiv2DPoint* cvFindNearestPoint2D	(	CvSubdiv2D *	subdiv,
		CvPoint2D32f	pt
	)

void cvFindRuns	(	int	line_count,
		uchar *	prewarp1,
		uchar *	prewarp2,
		int *	line_lengths1,
		int *	line_lengths2,
		int *	runs1,
		int *	runs2,
		int *	num_runs1,
		int *	num_runs2
	)

void cvFindStereoCorrespondence	(	const CvArr *	leftImage,
		const CvArr *	rightImage,
		int	mode,
		CvArr *	dispImage,
		int	maxDisparity,
		double param1	CV_DEFAULT12345,
		double param2	CV_DEFAULT12345,
		double param3	CV_DEFAULT12345,
		double param4	CV_DEFAULT12345,
		double param5	CV_DEFAULT12345
	)

void cvFindStereoCorrespondenceGC	(	const CvArr *	left,
		const CvArr *	right,
		CvArr *	disparityLeft,
		CvArr *	disparityRight,
		CvStereoGCState *	state,
		int useDisparityGuess	CV_DEFAULT0
	)

double cvGetGLCMDescriptor	(	CvGLCM *	GLCM,
		int	step,
		int	descriptor
	)

void cvGetGLCMDescriptorStatistics	(	CvGLCM *	GLCM,
		int	descriptor,
		double *	average,
		double *	standardDeviation
	)

void cvImgToObs_DCT	(	const CvArr *	arr,
		float *	obs,
		CvSize	dctSize,
		CvSize	obsSize,
		CvSize	delta
	)

CvFaceTracker* cvInitFaceTracker	(	CvFaceTracker *	pFaceTracking,
		const IplImage *	imgGray,
		CvRect *	pRects,
		int	nRects
	)

void cvInitMixSegm	(	CvImgObsInfo **	obs_info_array,
		int	num_img,
		CvEHMM *	hmm
	)

void cvInitPerspectiveTransform	(	CvSize	size,
		const CvPoint2D32f	vertex[4],
		double	matrix[3][3],
		CvArr *	rectMap
	)

void cvInitSubdivDelaunay2D	(	CvSubdiv2D *	subdiv,
		CvRect	rect
	)

CvGraph* cvLinearContorModelFromVoronoiDiagram	(	CvVoronoiDiagram2D *	VoronoiDiagram,
		float	maxWidth
	)

void cvLSHAdd	(	struct CvLSH *	lsh,
		const CvMat *	data,
		CvMat *indices	CV_DEFAULT0
	)

void cvLSHQuery	(	struct CvLSH *	lsh,
		const CvMat *	query_points,
		CvMat *	indices,
		CvMat *	dist,
		int	k,
		int	emax
	)

void cvLSHRemove	(	struct CvLSH *	lsh,
		const CvMat *	indices
	)

void cvMakeAlphaScanlines	(	int *	scanlines1,
		int *	scanlines2,
		int *	scanlinesA,
		int *	lengths,
		int	line_count,
		float	alpha
	)

void cvMakeScanlines	(	const CvMatrix3 *	matrix,
		CvSize	img_size,
		int *	scanlines1,
		int *	scanlines2,
		int *	lengths1,
		int *	lengths2,
		int *	line_count
	)

double cvMatchContourTrees	(	const CvContourTree *	tree1,
		const CvContourTree *	tree2,
		int	method,
		double	threshold
	)

void cvMixSegmL2	(	CvImgObsInfo **	obs_info_array,
		int	num_img,
		CvEHMM *	hmm
	)

CvSeq* cvMorphContours	(	const CvSeq *	contour1,
		const CvSeq *	contour2,
		CvSeq *	corr,
		double	alpha,
		CvMemStorage *	storage
	)

void cvMorphEpilinesMulti	(	int	line_count,
		uchar *	first_pix,
		int *	first_num,
		uchar *	second_pix,
		int *	second_num,
		uchar *	dst_pix,
		int *	dst_num,
		float	alpha,
		int *	first,
		int *	first_runs,
		int *	second,
		int *	second_runs,
		int *	first_corr,
		int *	second_corr
	)

CvSeq* cvPostBoostingFindFace	(	IplImage *	Image,
		CvMemStorage *	storage
	)

void cvPostWarpImage	(	int	line_count,
		uchar *	src,
		int *	src_nums,
		IplImage *	img,
		int *	scanlines
	)

void cvPreWarpImage	(	int	line_count,
		IplImage *	img,
		uchar *	dst,
		int *	dst_nums,
		int *	scanlines
	)

void cvPyrSegmentation	(	IplImage *	src,
		IplImage *	dst,
		CvMemStorage *	storage,
		CvSeq **	comp,
		int	level,
		double	threshold1,
		double	threshold2
	)

void cvRefineForegroundMaskBySegm	(	CvSeq *	segments,
		CvBGStatModel *	bg_model
	)

void cvRelease2DHMM ( CvEHMM ** hmm )

void cvReleaseBGCodeBookModel ( CvBGCodeBookModel ** model )

void cvReleaseBGStatModel ( CvBGStatModel ** bg_model )

void cvReleaseConDensation ( CvConDensation ** condens )

void cvReleaseFaceTracker ( CvFaceTracker ** ppFaceTracker )

void cvReleaseFeatureTree ( struct CvFeatureTree * tr )

void cvReleaseGLCM	(	CvGLCM **	GLCM,
		int flag	CV_DEFAULT0
	)

int cvReleaseLinearContorModelStorage ( CvGraph ** Graph )

void cvReleaseLSH ( struct CvLSH ** lsh )

void cvReleaseObsInfo ( CvImgObsInfo ** obs_info )

void cvReleaseStereoGCState ( CvStereoGCState ** state )

void cvReleaseVoronoiStorage	(	CvVoronoiDiagram2D *	VoronoiDiagram,
		CvMemStorage **	pVoronoiStorage
	)

CvSeq* cvSegmentFGMask	(	CvArr *	fgmask,
		int poly1Hull0	CV_DEFAULT1,
		float perimScale	CV_DEFAULT4.f,
		CvMemStorage *storage	CV_DEFAULT0,
		CvPoint offset	CV_DEFAULTcvPoint(0, 0)
	)

CvSeq* cvSegmentImage	(	const CvArr *	srcarr,
		CvArr *	dstarr,
		double	canny_threshold,
		double	ffill_threshold,
		CvMemStorage *	storage
	)

void cvSnakeImage	(	const IplImage *	image,
		CvPoint *	points,
		int	length,
		float *	alpha,
		float *	beta,
		float *	gamma,
		int	coeff_usage,
		CvSize	win,
		CvTermCriteria	criteria,
		int calc_gradient	CV_DEFAULT1
	)

CV_INLINE CvSubdiv2DPoint* cvSubdiv2DEdgeDst ( CvSubdiv2DEdge edge )

CV_INLINE CvSubdiv2DPoint* cvSubdiv2DEdgeOrg ( CvSubdiv2DEdge edge )

CV_INLINE CvSubdiv2DEdge cvSubdiv2DGetEdge	(	CvSubdiv2DEdge	edge,
		CvNextEdgeType	type
	)

CvSubdiv2DPointLocation cvSubdiv2DLocate	(	CvSubdiv2D *	subdiv,
		CvPoint2D32f	pt,
		CvSubdiv2DEdge *	edge,
		CvSubdiv2DPoint **vertex	CV_DEFAULTNULL
	)

CV_INLINE CvSubdiv2DEdge cvSubdiv2DNextEdge ( CvSubdiv2DEdge edge )

CV_INLINE CvSubdiv2DEdge cvSubdiv2DRotateEdge	(	CvSubdiv2DEdge	edge,
		int	rotate
	)

CV_INLINE CvSubdiv2DEdge cvSubdiv2DSymEdge ( CvSubdiv2DEdge edge )

CvSubdiv2DPoint* cvSubdivDelaunay2DInsert	(	CvSubdiv2D *	subdiv,
		CvPoint2D32f	pt
	)

int cvTrackFace	(	CvFaceTracker *	pFaceTracker,
		IplImage *	imgGray,
		CvRect *	pRects,
		int	nRects,
		CvPoint *	ptRotate,
		double *	dbAngleRotate
	)

CV_INLINE double cvTriangleArea	(	CvPoint2D32f	a,
		CvPoint2D32f	b,
		CvPoint2D32f	c
	)

void cvUniformImgSegm	(	CvImgObsInfo *	obs_info,
		CvEHMM *	ehmm
	)

int cvUpdateBGStatModel	(	IplImage *	current_frame,
		CvBGStatModel *	bg_model,
		double learningRate	CV_DEFAULT-1
	)

int cvVoronoiDiagramFromContour	(	CvSeq *	ContourSeq,
		CvVoronoiDiagram2D **	VoronoiDiagram,
		CvMemStorage *	VoronoiStorage,
		CvLeeParameters contour_type	CV_DEFAULTCV_LEE_INT,
		int contour_orientation	CV_DEFAULT-1,
		int attempt_number	CV_DEFAULT10
	)

int cvVoronoiDiagramFromImage	(	IplImage *	pImage,
		CvSeq **	ContourSeq,
		CvVoronoiDiagram2D **	VoronoiDiagram,
		CvMemStorage *	VoronoiStorage,
		CvLeeParameters regularization_method	CV_DEFAULTCV_LEE_NON,
		float approx_precision	CV_DEFAULTCV_LEE_AUTO
	)

int icvComCoeffForLine	(	CvPoint2D64f	point1,
		CvPoint2D64f	point2,
		CvPoint2D64f	point3,
		CvPoint2D64f	point4,
		double *	camMatr1,
		double *	rotMatr1,
		double *	transVect1,
		double *	camMatr2,
		double *	rotMatr2,
		double *	transVect2,
		CvStereoLineCoeff *	coeffs,
		int *	needSwapCameras
	)

int icvCompute3DPoint	(	double	alpha,
		double	betta,
		CvStereoLineCoeff *	coeffs,
		CvPoint3D64f *	point
	)

int icvComputeCoeffForStereo ( CvStereoCamera * stereoCamera )

void icvComputeeInfiniteProject1	(	double *	rotMatr,
		double *	camMatr1,
		double *	camMatr2,
		CvPoint2D32f	point1,
		CvPoint2D32f *	point2
	)

void icvComputeeInfiniteProject2	(	double *	rotMatr,
		double *	camMatr1,
		double *	camMatr2,
		CvPoint2D32f *	point1,
		CvPoint2D32f	point2
	)

int icvComputeRestStereoParams ( CvStereoCamera * stereoparams )

int icvComputeStereoLineCoeffs	(	CvPoint3D64f	pointA,
		CvPoint3D64f	pointB,
		CvPoint3D64f	pointCam1,
		double	gamma,
		CvStereoLineCoeff *	coeffs
	)

void icvComputeStereoParamsForCameras ( CvStereoCamera * stereoCamera )

int icvConvertPointSystem	(	CvPoint3D64f	M2,
		CvPoint3D64f *	M1,
		double *	rotMatr,
		double *	transVect
	)

int icvConvertWarpCoordinates	(	double	coeffs[3][3],
		CvPoint2D32f *	cameraPoint,
		CvPoint2D32f *	warpPoint,
		int	direction
	)

int icvCreateConvertMatrVect	(	double *	rotMatr1,
		double *	transVect1,
		double *	rotMatr2,
		double *	transVect2,
		double *	convRotMatr,
		double *	convTransVect
	)

IplImage* icvCreateIsometricImage	(	IplImage *	src,
		IplImage *	dst,
		int	desired_depth,
		int	desired_num_channels
	)

float icvDefinePointPosition	(	CvPoint2D32f	point1,
		CvPoint2D32f	point2,
		CvPoint2D32f	point
	)

void icvDrawMosaic	(	CvSubdiv2D *	subdiv,
		IplImage *	src,
		IplImage *	dst
	)

int icvGetAngleLine	(	CvPoint2D64f	startPoint,
		CvSize	imageSize,
		CvPoint2D64f *	point1,
		CvPoint2D64f *	point2
	)

void icvGetCoefForPiece	(	CvPoint2D64f	p_start,
		CvPoint2D64f	p_end,
		double *	a,
		double *	b,
		double *	c,
		int *	result
	)

void icvGetCrossDirectDirect	(	double *	direct1,
		double *	direct2,
		CvPoint2D64f *	cross,
		int *	result
	)

int icvGetCrossLineDirect	(	CvPoint2D32f	p1,
		CvPoint2D32f	p2,
		float	a,
		float	b,
		float	c,
		CvPoint2D32f *	cross
	)

int icvGetCrossLines	(	CvPoint3D64f	point11,
		CvPoint3D64f	point12,
		CvPoint3D64f	point21,
		CvPoint3D64f	point22,
		CvPoint3D64f *	midPoint
	)

void icvGetCrossPieceDirect	(	CvPoint2D64f	p_start,
		CvPoint2D64f	p_end,
		double	a,
		double	b,
		double	c,
		CvPoint2D64f *	cross,
		int *	result
	)

void icvGetCrossPiecePiece	(	CvPoint2D64f	p1_start,
		CvPoint2D64f	p1_end,
		CvPoint2D64f	p2_start,
		CvPoint2D64f	p2_end,
		CvPoint2D64f *	cross,
		int *	result
	)

int icvGetCrossPieceVector	(	CvPoint2D32f	p1_start,
		CvPoint2D32f	p1_end,
		CvPoint2D32f	v2_start,
		CvPoint2D32f	v2_end,
		CvPoint2D32f *	cross
	)

void icvGetCrossRectDirect	(	CvSize	imageSize,
		double	a,
		double	b,
		double	c,
		CvPoint2D64f *	start,
		CvPoint2D64f *	end,
		int *	result
	)

void icvGetCutPiece	(	double *	areaLineCoef1,
		double *	areaLineCoef2,
		CvPoint2D64f	epipole,
		CvSize	imageSize,
		CvPoint2D64f *	point11,
		CvPoint2D64f *	point12,
		CvPoint2D64f *	point21,
		CvPoint2D64f *	point22,
		int *	result
	)

int icvGetDirectionForPoint	(	CvPoint2D64f	point,
		double *	camMatr,
		CvPoint3D64f *	direct
	)

void icvGetDistanceFromPointToDirect	(	CvPoint2D64f	point,
		double *	lineCoef,
		double *	dist
	)

void icvGetMiddleAnglePoint	(	CvPoint2D64f	basePoint,
		CvPoint2D64f	point1,
		CvPoint2D64f	point2,
		CvPoint2D64f *	midPoint
	)

void icvGetNormalDirect	(	double *	direct,
		CvPoint2D64f	point,
		double *	normDirect
	)

void icvGetPieceLength	(	CvPoint2D64f	point1,
		CvPoint2D64f	point2,
		double *	dist
	)

void icvGetPieceLength3D	(	CvPoint3D64f	point1,
		CvPoint3D64f	point2,
		double *	dist
	)

void icvGetQuadsTransform	(	CvSize	imageSize,
		double *	camMatr1,
		double *	rotMatr1,
		double *	transVect1,
		double *	camMatr2,
		double *	rotMatr2,
		double *	transVect2,
		CvSize *	warpSize,
		double	quad1[4][2],
		double	quad2[4][2],
		double *	fundMatr,
		CvPoint3D64f *	epipole1,
		CvPoint3D64f *	epipole2
	)

void icvGetQuadsTransformStruct ( CvStereoCamera * stereoCamera )

int icvGetSymPoint3D	(	CvPoint3D64f	pointCorner,
		CvPoint3D64f	point1,
		CvPoint3D64f	point2,
		CvPoint3D64f *	pointSym2
	)

double icvGetVect	(	CvPoint2D64f	basePoint,
		CvPoint2D64f	point1,
		CvPoint2D64f	point2
	)

void icvProjectPointToDirect	(	CvPoint2D64f	point,
		double *	lineCoeff,
		CvPoint2D64f *	projectPoint
	)

void icvProjectPointToImage	(	CvPoint3D64f	point,
		double *	camMatr,
		double *	rotMatr,
		double *	transVect,
		CvPoint2D64f *	projPoint
	)

CV_INLINE double icvSqDist2D32f	(	CvPoint2D32f	pt1,
		CvPoint2D32f	pt2
	)

int icvStereoCalibration	(	int	numImages,
		int *	nums,
		CvSize	imageSize,
		CvPoint2D32f *	imagePoints1,
		CvPoint2D32f *	imagePoints2,
		CvPoint3D32f *	objectPoints,
		CvStereoCamera *	stereoparams
	)

int icvSubdiv2DCheck ( CvSubdiv2D * subdiv )

CV_INLINE int iplHeight ( const IplImage * img )

CV_INLINE int iplWidth ( const IplImage * img )

unsigned int LSHSize ( struct CvLSH * lsh )

typedef void ( CV_CDECL * CvReleaseBGStatModel )

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation