1/*M/////////////////////////////////////////////////////////////////////////////////////// 2// 3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4// 5// By downloading, copying, installing or using the software you agree to this license. 6// If you do not agree to this license, do not download, install, 7// copy or use the software. 8// 9// 10// Intel License Agreement 11// For Open Source Computer Vision Library 12// 13// Copyright (C) 2000, Intel Corporation, all rights reserved. 14// Third party copyrights are property of their respective owners. 15// 16// Redistribution and use in source and binary forms, with or without modification, 17// are permitted provided that the following conditions are met: 18// 19// * Redistribution's of source code must retain the above copyright notice, 20// this list of conditions and the following disclaimer. 21// 22// * Redistribution's in binary form must reproduce the above copyright notice, 23// this list of conditions and the following disclaimer in the documentation 24// and/or other materials provided with the distribution. 25// 26// * The name of Intel Corporation may not be used to endorse or promote products 27// derived from this software without specific prior written permission. 28// 29// This software is provided by the copyright holders and contributors "as is" and 30// any express or implied warranties, including, but not limited to, the implied 31// warranties of merchantability and fitness for a particular purpose are disclaimed. 32// In no event shall the Intel Corporation or contributors be liable for any direct, 33// indirect, incidental, special, exemplary, or consequential damages 34// (including, but not limited to, procurement of substitute goods or services; 35// loss of use, data, or profits; or business interruption) however caused 36// and on any theory of liability, whether in contract, strict liability, 37// or tort (including negligence or otherwise) arising in any way out of 38// the use of this software, even if advised of the possibility of such damage. 39// 40//M*/ 41 42#ifndef __CVAUX__H__ 43#define __CVAUX__H__ 44 45#include "cv.h" 46 47#ifdef __cplusplus 48extern "C" { 49#endif 50 51CVAPI(CvSeq*) cvSegmentImage( const CvArr* srcarr, CvArr* dstarr, 52 double canny_threshold, 53 double ffill_threshold, 54 CvMemStorage* storage ); 55 56/****************************************************************************************\ 57* Eigen objects * 58\****************************************************************************************/ 59 60typedef int (CV_CDECL * CvCallback)(int index, void* buffer, void* user_data); 61typedef union 62{ 63 CvCallback callback; 64 void* data; 65} 66CvInput; 67 68#define CV_EIGOBJ_NO_CALLBACK 0 69#define CV_EIGOBJ_INPUT_CALLBACK 1 70#define CV_EIGOBJ_OUTPUT_CALLBACK 2 71#define CV_EIGOBJ_BOTH_CALLBACK 3 72 73/* Calculates covariation matrix of a set of arrays */ 74CVAPI(void) cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags, 75 int ioBufSize, uchar* buffer, void* userData, 76 IplImage* avg, float* covarMatrix ); 77 78/* Calculates eigen values and vectors of covariation matrix of a set of 79 arrays */ 80CVAPI(void) cvCalcEigenObjects( int nObjects, void* input, void* output, 81 int ioFlags, int ioBufSize, void* userData, 82 CvTermCriteria* calcLimit, IplImage* avg, 83 float* eigVals ); 84 85/* Calculates dot product (obj - avg) * eigObj (i.e. projects image to eigen vector) */ 86CVAPI(double) cvCalcDecompCoeff( IplImage* obj, IplImage* eigObj, IplImage* avg ); 87 88/* Projects image to eigen space (finds all decomposion coefficients */ 89CVAPI(void) cvEigenDecomposite( IplImage* obj, int nEigObjs, void* eigInput, 90 int ioFlags, void* userData, IplImage* avg, 91 float* coeffs ); 92 93/* Projects original objects used to calculate eigen space basis to that space */ 94CVAPI(void) cvEigenProjection( void* eigInput, int nEigObjs, int ioFlags, 95 void* userData, float* coeffs, IplImage* avg, 96 IplImage* proj ); 97 98/****************************************************************************************\ 99* 1D/2D HMM * 100\****************************************************************************************/ 101 102typedef struct CvImgObsInfo 103{ 104 int obs_x; 105 int obs_y; 106 int obs_size; 107 float* obs;//consequtive observations 108 109 int* state;/* arr of pairs superstate/state to which observation belong */ 110 int* mix; /* number of mixture to which observation belong */ 111 112} 113CvImgObsInfo;/*struct for 1 image*/ 114 115typedef CvImgObsInfo Cv1DObsInfo; 116 117typedef struct CvEHMMState 118{ 119 int num_mix; /*number of mixtures in this state*/ 120 float* mu; /*mean vectors corresponding to each mixture*/ 121 float* inv_var; /* square root of inversed variances corresp. to each mixture*/ 122 float* log_var_val; /* sum of 0.5 (LN2PI + ln(variance[i]) ) for i=1,n */ 123 float* weight; /*array of mixture weights. Summ of all weights in state is 1. */ 124 125} 126CvEHMMState; 127 128typedef struct CvEHMM 129{ 130 int level; /* 0 - lowest(i.e its states are real states), ..... */ 131 int num_states; /* number of HMM states */ 132 float* transP;/*transition probab. matrices for states */ 133 float** obsProb; /* if level == 0 - array of brob matrices corresponding to hmm 134 if level == 1 - martix of matrices */ 135 union 136 { 137 CvEHMMState* state; /* if level == 0 points to real states array, 138 if not - points to embedded hmms */ 139 struct CvEHMM* ehmm; /* pointer to an embedded model or NULL, if it is a leaf */ 140 } u; 141 142} 143CvEHMM; 144 145/*CVAPI(int) icvCreate1DHMM( CvEHMM** this_hmm, 146 int state_number, int* num_mix, int obs_size ); 147 148CVAPI(int) icvRelease1DHMM( CvEHMM** phmm ); 149 150CVAPI(int) icvUniform1DSegm( Cv1DObsInfo* obs_info, CvEHMM* hmm ); 151 152CVAPI(int) icvInit1DMixSegm( Cv1DObsInfo** obs_info_array, int num_img, CvEHMM* hmm); 153 154CVAPI(int) icvEstimate1DHMMStateParams( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm); 155 156CVAPI(int) icvEstimate1DObsProb( CvImgObsInfo* obs_info, CvEHMM* hmm ); 157 158CVAPI(int) icvEstimate1DTransProb( Cv1DObsInfo** obs_info_array, 159 int num_seq, 160 CvEHMM* hmm ); 161 162CVAPI(float) icvViterbi( Cv1DObsInfo* obs_info, CvEHMM* hmm); 163 164CVAPI(int) icv1DMixSegmL2( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm );*/ 165 166/*********************************** Embedded HMMs *************************************/ 167 168/* Creates 2D HMM */ 169CVAPI(CvEHMM*) cvCreate2DHMM( int* stateNumber, int* numMix, int obsSize ); 170 171/* Releases HMM */ 172CVAPI(void) cvRelease2DHMM( CvEHMM** hmm ); 173 174#define CV_COUNT_OBS(roi, win, delta, numObs ) \ 175{ \ 176 (numObs)->width =((roi)->width -(win)->width +(delta)->width)/(delta)->width; \ 177 (numObs)->height =((roi)->height -(win)->height +(delta)->height)/(delta)->height;\ 178} 179 180/* Creates storage for observation vectors */ 181CVAPI(CvImgObsInfo*) cvCreateObsInfo( CvSize numObs, int obsSize ); 182 183/* Releases storage for observation vectors */ 184CVAPI(void) cvReleaseObsInfo( CvImgObsInfo** obs_info ); 185 186 187/* The function takes an image on input and and returns the sequnce of observations 188 to be used with an embedded HMM; Each observation is top-left block of DCT 189 coefficient matrix */ 190CVAPI(void) cvImgToObs_DCT( const CvArr* arr, float* obs, CvSize dctSize, 191 CvSize obsSize, CvSize delta ); 192 193 194/* Uniformly segments all observation vectors extracted from image */ 195CVAPI(void) cvUniformImgSegm( CvImgObsInfo* obs_info, CvEHMM* ehmm ); 196 197/* Does mixture segmentation of the states of embedded HMM */ 198CVAPI(void) cvInitMixSegm( CvImgObsInfo** obs_info_array, 199 int num_img, CvEHMM* hmm ); 200 201/* Function calculates means, variances, weights of every Gaussian mixture 202 of every low-level state of embedded HMM */ 203CVAPI(void) cvEstimateHMMStateParams( CvImgObsInfo** obs_info_array, 204 int num_img, CvEHMM* hmm ); 205 206/* Function computes transition probability matrices of embedded HMM 207 given observations segmentation */ 208CVAPI(void) cvEstimateTransProb( CvImgObsInfo** obs_info_array, 209 int num_img, CvEHMM* hmm ); 210 211/* Function computes probabilities of appearing observations at any state 212 (i.e. computes P(obs|state) for every pair(obs,state)) */ 213CVAPI(void) cvEstimateObsProb( CvImgObsInfo* obs_info, 214 CvEHMM* hmm ); 215 216/* Runs Viterbi algorithm for embedded HMM */ 217CVAPI(float) cvEViterbi( CvImgObsInfo* obs_info, CvEHMM* hmm ); 218 219 220/* Function clusters observation vectors from several images 221 given observations segmentation. 222 Euclidean distance used for clustering vectors. 223 Centers of clusters are given means of every mixture */ 224CVAPI(void) cvMixSegmL2( CvImgObsInfo** obs_info_array, 225 int num_img, CvEHMM* hmm ); 226 227/****************************************************************************************\ 228* A few functions from old stereo gesture recognition demosions * 229\****************************************************************************************/ 230 231/* Creates hand mask image given several points on the hand */ 232CVAPI(void) cvCreateHandMask( CvSeq* hand_points, 233 IplImage *img_mask, CvRect *roi); 234 235/* Finds hand region in range image data */ 236CVAPI(void) cvFindHandRegion (CvPoint3D32f* points, int count, 237 CvSeq* indexs, 238 float* line, CvSize2D32f size, int flag, 239 CvPoint3D32f* center, 240 CvMemStorage* storage, CvSeq **numbers); 241 242/* Finds hand region in range image data (advanced version) */ 243CVAPI(void) cvFindHandRegionA( CvPoint3D32f* points, int count, 244 CvSeq* indexs, 245 float* line, CvSize2D32f size, int jc, 246 CvPoint3D32f* center, 247 CvMemStorage* storage, CvSeq **numbers); 248 249/****************************************************************************************\ 250* Additional operations on Subdivisions * 251\****************************************************************************************/ 252 253// paints voronoi diagram: just demo function 254CVAPI(void) icvDrawMosaic( CvSubdiv2D* subdiv, IplImage* src, IplImage* dst ); 255 256// checks planar subdivision for correctness. It is not an absolute check, 257// but it verifies some relations between quad-edges 258CVAPI(int) icvSubdiv2DCheck( CvSubdiv2D* subdiv ); 259 260// returns squared distance between two 2D points with floating-point coordinates. 261CV_INLINE double icvSqDist2D32f( CvPoint2D32f pt1, CvPoint2D32f pt2 ) 262{ 263 double dx = pt1.x - pt2.x; 264 double dy = pt1.y - pt2.y; 265 266 return dx*dx + dy*dy; 267} 268 269 270/****************************************************************************************\ 271* More operations on sequences * 272\****************************************************************************************/ 273 274/*****************************************************************************************/ 275 276#define CV_CURRENT_INT( reader ) (*((int *)(reader).ptr)) 277#define CV_PREV_INT( reader ) (*((int *)(reader).prev_elem)) 278 279#define CV_GRAPH_WEIGHTED_VERTEX_FIELDS() CV_GRAPH_VERTEX_FIELDS()\ 280 float weight; 281 282#define CV_GRAPH_WEIGHTED_EDGE_FIELDS() CV_GRAPH_EDGE_FIELDS() 283 284typedef struct CvGraphWeightedVtx 285{ 286 CV_GRAPH_WEIGHTED_VERTEX_FIELDS() 287} 288CvGraphWeightedVtx; 289 290typedef struct CvGraphWeightedEdge 291{ 292 CV_GRAPH_WEIGHTED_EDGE_FIELDS() 293} 294CvGraphWeightedEdge; 295 296typedef enum CvGraphWeightType 297{ 298 CV_NOT_WEIGHTED, 299 CV_WEIGHTED_VTX, 300 CV_WEIGHTED_EDGE, 301 CV_WEIGHTED_ALL 302} CvGraphWeightType; 303 304 305/*****************************************************************************************/ 306 307 308/*******************************Stereo correspondence*************************************/ 309 310typedef struct CvCliqueFinder 311{ 312 CvGraph* graph; 313 int** adj_matr; 314 int N; //graph size 315 316 // stacks, counters etc/ 317 int k; //stack size 318 int* current_comp; 319 int** All; 320 321 int* ne; 322 int* ce; 323 int* fixp; //node with minimal disconnections 324 int* nod; 325 int* s; //for selected candidate 326 int status; 327 int best_score; 328 int weighted; 329 int weighted_edges; 330 float best_weight; 331 float* edge_weights; 332 float* vertex_weights; 333 float* cur_weight; 334 float* cand_weight; 335 336} CvCliqueFinder; 337 338#define CLIQUE_TIME_OFF 2 339#define CLIQUE_FOUND 1 340#define CLIQUE_END 0 341 342/*CVAPI(void) cvStartFindCliques( CvGraph* graph, CvCliqueFinder* finder, int reverse, 343 int weighted CV_DEFAULT(0), int weighted_edges CV_DEFAULT(0)); 344CVAPI(int) cvFindNextMaximalClique( CvCliqueFinder* finder, int* clock_rest CV_DEFAULT(0) ); 345CVAPI(void) cvEndFindCliques( CvCliqueFinder* finder ); 346 347CVAPI(void) cvBronKerbosch( CvGraph* graph );*/ 348 349 350/*F/////////////////////////////////////////////////////////////////////////////////////// 351// 352// Name: cvSubgraphWeight 353// Purpose: finds weight of subgraph in a graph 354// Context: 355// Parameters: 356// graph - input graph. 357// subgraph - sequence of pairwise different ints. These are indices of vertices of subgraph. 358// weight_type - describes the way we measure weight. 359// one of the following: 360// CV_NOT_WEIGHTED - weight of a clique is simply its size 361// CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices 362// CV_WEIGHTED_EDGE - the same but edges 363// CV_WEIGHTED_ALL - the same but both edges and vertices 364// weight_vtx - optional vector of floats, with size = graph->total. 365// If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL 366// weights of vertices must be provided. If weight_vtx not zero 367// these weights considered to be here, otherwise function assumes 368// that vertices of graph are inherited from CvGraphWeightedVtx. 369// weight_edge - optional matrix of floats, of width and height = graph->total. 370// If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL 371// weights of edges ought to be supplied. If weight_edge is not zero 372// function finds them here, otherwise function expects 373// edges of graph to be inherited from CvGraphWeightedEdge. 374// If this parameter is not zero structure of the graph is determined from matrix 375// rather than from CvGraphEdge's. In particular, elements corresponding to 376// absent edges should be zero. 377// Returns: 378// weight of subgraph. 379// Notes: 380//F*/ 381/*CVAPI(float) cvSubgraphWeight( CvGraph *graph, CvSeq *subgraph, 382 CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED), 383 CvVect32f weight_vtx CV_DEFAULT(0), 384 CvMatr32f weight_edge CV_DEFAULT(0) );*/ 385 386 387/*F/////////////////////////////////////////////////////////////////////////////////////// 388// 389// Name: cvFindCliqueEx 390// Purpose: tries to find clique with maximum possible weight in a graph 391// Context: 392// Parameters: 393// graph - input graph. 394// storage - memory storage to be used by the result. 395// is_complementary - optional flag showing whether function should seek for clique 396// in complementary graph. 397// weight_type - describes our notion about weight. 398// one of the following: 399// CV_NOT_WEIGHTED - weight of a clique is simply its size 400// CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices 401// CV_WEIGHTED_EDGE - the same but edges 402// CV_WEIGHTED_ALL - the same but both edges and vertices 403// weight_vtx - optional vector of floats, with size = graph->total. 404// If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL 405// weights of vertices must be provided. If weight_vtx not zero 406// these weights considered to be here, otherwise function assumes 407// that vertices of graph are inherited from CvGraphWeightedVtx. 408// weight_edge - optional matrix of floats, of width and height = graph->total. 409// If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL 410// weights of edges ought to be supplied. If weight_edge is not zero 411// function finds them here, otherwise function expects 412// edges of graph to be inherited from CvGraphWeightedEdge. 413// Note that in case of CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL 414// nonzero is_complementary implies nonzero weight_edge. 415// start_clique - optional sequence of pairwise different ints. They are indices of 416// vertices that shall be present in the output clique. 417// subgraph_of_ban - optional sequence of (maybe equal) ints. They are indices of 418// vertices that shall not be present in the output clique. 419// clique_weight_ptr - optional output parameter. Weight of found clique stored here. 420// num_generations - optional number of generations in evolutionary part of algorithm, 421// zero forces to return first found clique. 422// quality - optional parameter determining degree of required quality/speed tradeoff. 423// Must be in the range from 0 to 9. 424// 0 is fast and dirty, 9 is slow but hopefully yields good clique. 425// Returns: 426// sequence of pairwise different ints. 427// These are indices of vertices that form found clique. 428// Notes: 429// in cases of CV_WEIGHTED_EDGE and CV_WEIGHTED_ALL weights should be nonnegative. 430// start_clique has a priority over subgraph_of_ban. 431//F*/ 432/*CVAPI(CvSeq*) cvFindCliqueEx( CvGraph *graph, CvMemStorage *storage, 433 int is_complementary CV_DEFAULT(0), 434 CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED), 435 CvVect32f weight_vtx CV_DEFAULT(0), 436 CvMatr32f weight_edge CV_DEFAULT(0), 437 CvSeq *start_clique CV_DEFAULT(0), 438 CvSeq *subgraph_of_ban CV_DEFAULT(0), 439 float *clique_weight_ptr CV_DEFAULT(0), 440 int num_generations CV_DEFAULT(3), 441 int quality CV_DEFAULT(2) );*/ 442 443 444#define CV_UNDEF_SC_PARAM 12345 //default value of parameters 445 446#define CV_IDP_BIRCHFIELD_PARAM1 25 447#define CV_IDP_BIRCHFIELD_PARAM2 5 448#define CV_IDP_BIRCHFIELD_PARAM3 12 449#define CV_IDP_BIRCHFIELD_PARAM4 15 450#define CV_IDP_BIRCHFIELD_PARAM5 25 451 452 453#define CV_DISPARITY_BIRCHFIELD 0 454 455 456/*F/////////////////////////////////////////////////////////////////////////// 457// 458// Name: cvFindStereoCorrespondence 459// Purpose: find stereo correspondence on stereo-pair 460// Context: 461// Parameters: 462// leftImage - left image of stereo-pair (format 8uC1). 463// rightImage - right image of stereo-pair (format 8uC1). 464// mode - mode of correspondence retrieval (now CV_DISPARITY_BIRCHFIELD only) 465// dispImage - destination disparity image 466// maxDisparity - maximal disparity 467// param1, param2, param3, param4, param5 - parameters of algorithm 468// Returns: 469// Notes: 470// Images must be rectified. 471// All images must have format 8uC1. 472//F*/ 473CVAPI(void) 474cvFindStereoCorrespondence( 475 const CvArr* leftImage, const CvArr* rightImage, 476 int mode, 477 CvArr* dispImage, 478 int maxDisparity, 479 double param1 CV_DEFAULT(CV_UNDEF_SC_PARAM), 480 double param2 CV_DEFAULT(CV_UNDEF_SC_PARAM), 481 double param3 CV_DEFAULT(CV_UNDEF_SC_PARAM), 482 double param4 CV_DEFAULT(CV_UNDEF_SC_PARAM), 483 double param5 CV_DEFAULT(CV_UNDEF_SC_PARAM) ); 484 485/*****************************************************************************************/ 486/************ Epiline functions *******************/ 487 488 489 490typedef struct CvStereoLineCoeff 491{ 492 double Xcoef; 493 double XcoefA; 494 double XcoefB; 495 double XcoefAB; 496 497 double Ycoef; 498 double YcoefA; 499 double YcoefB; 500 double YcoefAB; 501 502 double Zcoef; 503 double ZcoefA; 504 double ZcoefB; 505 double ZcoefAB; 506}CvStereoLineCoeff; 507 508 509typedef struct CvCamera 510{ 511 float imgSize[2]; /* size of the camera view, used during calibration */ 512 float matrix[9]; /* intinsic camera parameters: [ fx 0 cx; 0 fy cy; 0 0 1 ] */ 513 float distortion[4]; /* distortion coefficients - two coefficients for radial distortion 514 and another two for tangential: [ k1 k2 p1 p2 ] */ 515 float rotMatr[9]; 516 float transVect[3]; /* rotation matrix and transition vector relatively 517 to some reference point in the space. */ 518} 519CvCamera; 520 521typedef struct CvStereoCamera 522{ 523 CvCamera* camera[2]; /* two individual camera parameters */ 524 float fundMatr[9]; /* fundamental matrix */ 525 526 /* New part for stereo */ 527 CvPoint3D32f epipole[2]; 528 CvPoint2D32f quad[2][4]; /* coordinates of destination quadrangle after 529 epipolar geometry rectification */ 530 double coeffs[2][3][3];/* coefficients for transformation */ 531 CvPoint2D32f border[2][4]; 532 CvSize warpSize; 533 CvStereoLineCoeff* lineCoeffs; 534 int needSwapCameras;/* flag set to 1 if need to swap cameras for good reconstruction */ 535 float rotMatrix[9]; 536 float transVector[3]; 537} 538CvStereoCamera; 539 540 541typedef struct CvContourOrientation 542{ 543 float egvals[2]; 544 float egvects[4]; 545 546 float max, min; // minimum and maximum projections 547 int imax, imin; 548} CvContourOrientation; 549 550#define CV_CAMERA_TO_WARP 1 551#define CV_WARP_TO_CAMERA 2 552 553CVAPI(int) icvConvertWarpCoordinates(double coeffs[3][3], 554 CvPoint2D32f* cameraPoint, 555 CvPoint2D32f* warpPoint, 556 int direction); 557 558CVAPI(int) icvGetSymPoint3D( CvPoint3D64f pointCorner, 559 CvPoint3D64f point1, 560 CvPoint3D64f point2, 561 CvPoint3D64f *pointSym2); 562 563CVAPI(void) icvGetPieceLength3D(CvPoint3D64f point1,CvPoint3D64f point2,double* dist); 564 565CVAPI(int) icvCompute3DPoint( double alpha,double betta, 566 CvStereoLineCoeff* coeffs, 567 CvPoint3D64f* point); 568 569CVAPI(int) icvCreateConvertMatrVect( CvMatr64d rotMatr1, 570 CvMatr64d transVect1, 571 CvMatr64d rotMatr2, 572 CvMatr64d transVect2, 573 CvMatr64d convRotMatr, 574 CvMatr64d convTransVect); 575 576CVAPI(int) icvConvertPointSystem(CvPoint3D64f M2, 577 CvPoint3D64f* M1, 578 CvMatr64d rotMatr, 579 CvMatr64d transVect 580 ); 581 582CVAPI(int) icvComputeCoeffForStereo( CvStereoCamera* stereoCamera); 583 584CVAPI(int) icvGetCrossPieceVector(CvPoint2D32f p1_start,CvPoint2D32f p1_end,CvPoint2D32f v2_start,CvPoint2D32f v2_end,CvPoint2D32f *cross); 585CVAPI(int) icvGetCrossLineDirect(CvPoint2D32f p1,CvPoint2D32f p2,float a,float b,float c,CvPoint2D32f* cross); 586CVAPI(float) icvDefinePointPosition(CvPoint2D32f point1,CvPoint2D32f point2,CvPoint2D32f point); 587CVAPI(int) icvStereoCalibration( int numImages, 588 int* nums, 589 CvSize imageSize, 590 CvPoint2D32f* imagePoints1, 591 CvPoint2D32f* imagePoints2, 592 CvPoint3D32f* objectPoints, 593 CvStereoCamera* stereoparams 594 ); 595 596 597CVAPI(int) icvComputeRestStereoParams(CvStereoCamera *stereoparams); 598 599CVAPI(void) cvComputePerspectiveMap( const double coeffs[3][3], CvArr* rectMapX, CvArr* rectMapY ); 600 601CVAPI(int) icvComCoeffForLine( CvPoint2D64f point1, 602 CvPoint2D64f point2, 603 CvPoint2D64f point3, 604 CvPoint2D64f point4, 605 CvMatr64d camMatr1, 606 CvMatr64d rotMatr1, 607 CvMatr64d transVect1, 608 CvMatr64d camMatr2, 609 CvMatr64d rotMatr2, 610 CvMatr64d transVect2, 611 CvStereoLineCoeff* coeffs, 612 int* needSwapCameras); 613 614CVAPI(int) icvGetDirectionForPoint( CvPoint2D64f point, 615 CvMatr64d camMatr, 616 CvPoint3D64f* direct); 617 618CVAPI(int) icvGetCrossLines(CvPoint3D64f point11,CvPoint3D64f point12, 619 CvPoint3D64f point21,CvPoint3D64f point22, 620 CvPoint3D64f* midPoint); 621 622CVAPI(int) icvComputeStereoLineCoeffs( CvPoint3D64f pointA, 623 CvPoint3D64f pointB, 624 CvPoint3D64f pointCam1, 625 double gamma, 626 CvStereoLineCoeff* coeffs); 627 628/*CVAPI(int) icvComputeFundMatrEpipoles ( CvMatr64d camMatr1, 629 CvMatr64d rotMatr1, 630 CvVect64d transVect1, 631 CvMatr64d camMatr2, 632 CvMatr64d rotMatr2, 633 CvVect64d transVect2, 634 CvPoint2D64f* epipole1, 635 CvPoint2D64f* epipole2, 636 CvMatr64d fundMatr);*/ 637 638CVAPI(int) icvGetAngleLine( CvPoint2D64f startPoint, CvSize imageSize,CvPoint2D64f *point1,CvPoint2D64f *point2); 639 640CVAPI(void) icvGetCoefForPiece( CvPoint2D64f p_start,CvPoint2D64f p_end, 641 double *a,double *b,double *c, 642 int* result); 643 644/*CVAPI(void) icvGetCommonArea( CvSize imageSize, 645 CvPoint2D64f epipole1,CvPoint2D64f epipole2, 646 CvMatr64d fundMatr, 647 CvVect64d coeff11,CvVect64d coeff12, 648 CvVect64d coeff21,CvVect64d coeff22, 649 int* result);*/ 650 651CVAPI(void) icvComputeeInfiniteProject1(CvMatr64d rotMatr, 652 CvMatr64d camMatr1, 653 CvMatr64d camMatr2, 654 CvPoint2D32f point1, 655 CvPoint2D32f *point2); 656 657CVAPI(void) icvComputeeInfiniteProject2(CvMatr64d rotMatr, 658 CvMatr64d camMatr1, 659 CvMatr64d camMatr2, 660 CvPoint2D32f* point1, 661 CvPoint2D32f point2); 662 663CVAPI(void) icvGetCrossDirectDirect( CvVect64d direct1,CvVect64d direct2, 664 CvPoint2D64f *cross,int* result); 665 666CVAPI(void) icvGetCrossPieceDirect( CvPoint2D64f p_start,CvPoint2D64f p_end, 667 double a,double b,double c, 668 CvPoint2D64f *cross,int* result); 669 670CVAPI(void) icvGetCrossPiecePiece( CvPoint2D64f p1_start,CvPoint2D64f p1_end, 671 CvPoint2D64f p2_start,CvPoint2D64f p2_end, 672 CvPoint2D64f* cross, 673 int* result); 674 675CVAPI(void) icvGetPieceLength(CvPoint2D64f point1,CvPoint2D64f point2,double* dist); 676 677CVAPI(void) icvGetCrossRectDirect( CvSize imageSize, 678 double a,double b,double c, 679 CvPoint2D64f *start,CvPoint2D64f *end, 680 int* result); 681 682CVAPI(void) icvProjectPointToImage( CvPoint3D64f point, 683 CvMatr64d camMatr,CvMatr64d rotMatr,CvVect64d transVect, 684 CvPoint2D64f* projPoint); 685 686CVAPI(void) icvGetQuadsTransform( CvSize imageSize, 687 CvMatr64d camMatr1, 688 CvMatr64d rotMatr1, 689 CvVect64d transVect1, 690 CvMatr64d camMatr2, 691 CvMatr64d rotMatr2, 692 CvVect64d transVect2, 693 CvSize* warpSize, 694 double quad1[4][2], 695 double quad2[4][2], 696 CvMatr64d fundMatr, 697 CvPoint3D64f* epipole1, 698 CvPoint3D64f* epipole2 699 ); 700 701CVAPI(void) icvGetQuadsTransformStruct( CvStereoCamera* stereoCamera); 702 703CVAPI(void) icvComputeStereoParamsForCameras(CvStereoCamera* stereoCamera); 704 705CVAPI(void) icvGetCutPiece( CvVect64d areaLineCoef1,CvVect64d areaLineCoef2, 706 CvPoint2D64f epipole, 707 CvSize imageSize, 708 CvPoint2D64f* point11,CvPoint2D64f* point12, 709 CvPoint2D64f* point21,CvPoint2D64f* point22, 710 int* result); 711 712CVAPI(void) icvGetMiddleAnglePoint( CvPoint2D64f basePoint, 713 CvPoint2D64f point1,CvPoint2D64f point2, 714 CvPoint2D64f* midPoint); 715 716CVAPI(void) icvGetNormalDirect(CvVect64d direct,CvPoint2D64f point,CvVect64d normDirect); 717 718CVAPI(double) icvGetVect(CvPoint2D64f basePoint,CvPoint2D64f point1,CvPoint2D64f point2); 719 720CVAPI(void) icvProjectPointToDirect( CvPoint2D64f point,CvVect64d lineCoeff, 721 CvPoint2D64f* projectPoint); 722 723CVAPI(void) icvGetDistanceFromPointToDirect( CvPoint2D64f point,CvVect64d lineCoef,double*dist); 724 725CVAPI(IplImage*) icvCreateIsometricImage( IplImage* src, IplImage* dst, 726 int desired_depth, int desired_num_channels ); 727 728CVAPI(void) cvDeInterlace( const CvArr* frame, CvArr* fieldEven, CvArr* fieldOdd ); 729 730/*CVAPI(int) icvSelectBestRt( int numImages, 731 int* numPoints, 732 CvSize imageSize, 733 CvPoint2D32f* imagePoints1, 734 CvPoint2D32f* imagePoints2, 735 CvPoint3D32f* objectPoints, 736 737 CvMatr32f cameraMatrix1, 738 CvVect32f distortion1, 739 CvMatr32f rotMatrs1, 740 CvVect32f transVects1, 741 742 CvMatr32f cameraMatrix2, 743 CvVect32f distortion2, 744 CvMatr32f rotMatrs2, 745 CvVect32f transVects2, 746 747 CvMatr32f bestRotMatr, 748 CvVect32f bestTransVect 749 );*/ 750 751/****************************************************************************************\ 752* Contour Morphing * 753\****************************************************************************************/ 754 755/* finds correspondence between two contours */ 756CvSeq* cvCalcContoursCorrespondence( const CvSeq* contour1, 757 const CvSeq* contour2, 758 CvMemStorage* storage); 759 760/* morphs contours using the pre-calculated correspondence: 761 alpha=0 ~ contour1, alpha=1 ~ contour2 */ 762CvSeq* cvMorphContours( const CvSeq* contour1, const CvSeq* contour2, 763 CvSeq* corr, double alpha, 764 CvMemStorage* storage ); 765 766/****************************************************************************************\ 767* Texture Descriptors * 768\****************************************************************************************/ 769 770#define CV_GLCM_OPTIMIZATION_NONE -2 771#define CV_GLCM_OPTIMIZATION_LUT -1 772#define CV_GLCM_OPTIMIZATION_HISTOGRAM 0 773 774#define CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST 10 775#define CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST 11 776#define CV_GLCMDESC_OPTIMIZATION_HISTOGRAM 4 777 778#define CV_GLCMDESC_ENTROPY 0 779#define CV_GLCMDESC_ENERGY 1 780#define CV_GLCMDESC_HOMOGENITY 2 781#define CV_GLCMDESC_CONTRAST 3 782#define CV_GLCMDESC_CLUSTERTENDENCY 4 783#define CV_GLCMDESC_CLUSTERSHADE 5 784#define CV_GLCMDESC_CORRELATION 6 785#define CV_GLCMDESC_CORRELATIONINFO1 7 786#define CV_GLCMDESC_CORRELATIONINFO2 8 787#define CV_GLCMDESC_MAXIMUMPROBABILITY 9 788 789#define CV_GLCM_ALL 0 790#define CV_GLCM_GLCM 1 791#define CV_GLCM_DESC 2 792 793typedef struct CvGLCM CvGLCM; 794 795CVAPI(CvGLCM*) cvCreateGLCM( const IplImage* srcImage, 796 int stepMagnitude, 797 const int* stepDirections CV_DEFAULT(0), 798 int numStepDirections CV_DEFAULT(0), 799 int optimizationType CV_DEFAULT(CV_GLCM_OPTIMIZATION_NONE)); 800 801CVAPI(void) cvReleaseGLCM( CvGLCM** GLCM, int flag CV_DEFAULT(CV_GLCM_ALL)); 802 803CVAPI(void) cvCreateGLCMDescriptors( CvGLCM* destGLCM, 804 int descriptorOptimizationType 805 CV_DEFAULT(CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST)); 806 807CVAPI(double) cvGetGLCMDescriptor( CvGLCM* GLCM, int step, int descriptor ); 808 809CVAPI(void) cvGetGLCMDescriptorStatistics( CvGLCM* GLCM, int descriptor, 810 double* average, double* standardDeviation ); 811 812CVAPI(IplImage*) cvCreateGLCMImage( CvGLCM* GLCM, int step ); 813 814/****************************************************************************************\ 815* Face eyes&mouth tracking * 816\****************************************************************************************/ 817 818 819typedef struct CvFaceTracker CvFaceTracker; 820 821#define CV_NUM_FACE_ELEMENTS 3 822enum CV_FACE_ELEMENTS 823{ 824 CV_FACE_MOUTH = 0, 825 CV_FACE_LEFT_EYE = 1, 826 CV_FACE_RIGHT_EYE = 2 827}; 828 829CVAPI(CvFaceTracker*) cvInitFaceTracker(CvFaceTracker* pFaceTracking, const IplImage* imgGray, 830 CvRect* pRects, int nRects); 831CVAPI(int) cvTrackFace( CvFaceTracker* pFaceTracker, IplImage* imgGray, 832 CvRect* pRects, int nRects, 833 CvPoint* ptRotate, double* dbAngleRotate); 834CVAPI(void) cvReleaseFaceTracker(CvFaceTracker** ppFaceTracker); 835 836 837typedef struct CvFace 838{ 839 CvRect MouthRect; 840 CvRect LeftEyeRect; 841 CvRect RightEyeRect; 842} CvFaceData; 843 844CvSeq * cvFindFace(IplImage * Image,CvMemStorage* storage); 845CvSeq * cvPostBoostingFindFace(IplImage * Image,CvMemStorage* storage); 846 847 848/****************************************************************************************\ 849* 3D Tracker * 850\****************************************************************************************/ 851 852typedef unsigned char CvBool; 853 854typedef struct 855{ 856 int id; 857 CvPoint2D32f p; // pgruebele: So we do not loose precision, this needs to be float 858} Cv3dTracker2dTrackedObject; 859 860CV_INLINE Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id, CvPoint2D32f p) 861{ 862 Cv3dTracker2dTrackedObject r; 863 r.id = id; 864 r.p = p; 865 return r; 866} 867 868typedef struct 869{ 870 int id; 871 CvPoint3D32f p; // location of the tracked object 872} Cv3dTrackerTrackedObject; 873 874CV_INLINE Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id, CvPoint3D32f p) 875{ 876 Cv3dTrackerTrackedObject r; 877 r.id = id; 878 r.p = p; 879 return r; 880} 881 882typedef struct 883{ 884 CvBool valid; 885 float mat[4][4]; /* maps camera coordinates to world coordinates */ 886 CvPoint2D32f principal_point; /* copied from intrinsics so this structure */ 887 /* has all the info we need */ 888} Cv3dTrackerCameraInfo; 889 890typedef struct 891{ 892 CvPoint2D32f principal_point; 893 float focal_length[2]; 894 float distortion[4]; 895} Cv3dTrackerCameraIntrinsics; 896 897CVAPI(CvBool) cv3dTrackerCalibrateCameras(int num_cameras, 898 const Cv3dTrackerCameraIntrinsics camera_intrinsics[], /* size is num_cameras */ 899 CvSize etalon_size, 900 float square_size, 901 IplImage *samples[], /* size is num_cameras */ 902 Cv3dTrackerCameraInfo camera_info[]); /* size is num_cameras */ 903 904CVAPI(int) cv3dTrackerLocateObjects(int num_cameras, int num_objects, 905 const Cv3dTrackerCameraInfo camera_info[], /* size is num_cameras */ 906 const Cv3dTracker2dTrackedObject tracking_info[], /* size is num_objects*num_cameras */ 907 Cv3dTrackerTrackedObject tracked_objects[]); /* size is num_objects */ 908/**************************************************************************************** 909 tracking_info is a rectangular array; one row per camera, num_objects elements per row. 910 The id field of any unused slots must be -1. Ids need not be ordered or consecutive. On 911 completion, the return value is the number of objects located; i.e., the number of objects 912 visible by more than one camera. The id field of any unused slots in tracked objects is 913 set to -1. 914****************************************************************************************/ 915 916 917/****************************************************************************************\ 918* Skeletons and Linear-Contour Models * 919\****************************************************************************************/ 920 921typedef enum CvLeeParameters 922{ 923 CV_LEE_INT = 0, 924 CV_LEE_FLOAT = 1, 925 CV_LEE_DOUBLE = 2, 926 CV_LEE_AUTO = -1, 927 CV_LEE_ERODE = 0, 928 CV_LEE_ZOOM = 1, 929 CV_LEE_NON = 2 930} CvLeeParameters; 931 932#define CV_NEXT_VORONOISITE2D( SITE ) ((SITE)->edge[0]->site[((SITE)->edge[0]->site[0] == (SITE))]) 933#define CV_PREV_VORONOISITE2D( SITE ) ((SITE)->edge[1]->site[((SITE)->edge[1]->site[0] == (SITE))]) 934#define CV_FIRST_VORONOIEDGE2D( SITE ) ((SITE)->edge[0]) 935#define CV_LAST_VORONOIEDGE2D( SITE ) ((SITE)->edge[1]) 936#define CV_NEXT_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[(EDGE)->site[0] != (SITE)]) 937#define CV_PREV_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[2 + ((EDGE)->site[0] != (SITE))]) 938#define CV_VORONOIEDGE2D_BEGINNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] != (SITE))]) 939#define CV_VORONOIEDGE2D_ENDNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] == (SITE))]) 940#define CV_TWIN_VORONOISITE2D( SITE, EDGE ) ( (EDGE)->site[((EDGE)->site[0] == (SITE))]) 941 942#define CV_VORONOISITE2D_FIELDS() \ 943 struct CvVoronoiNode2D *node[2]; \ 944 struct CvVoronoiEdge2D *edge[2]; 945 946typedef struct CvVoronoiSite2D 947{ 948 CV_VORONOISITE2D_FIELDS() 949 struct CvVoronoiSite2D *next[2]; 950} CvVoronoiSite2D; 951 952#define CV_VORONOIEDGE2D_FIELDS() \ 953 struct CvVoronoiNode2D *node[2]; \ 954 struct CvVoronoiSite2D *site[2]; \ 955 struct CvVoronoiEdge2D *next[4]; 956 957typedef struct CvVoronoiEdge2D 958{ 959 CV_VORONOIEDGE2D_FIELDS() 960} CvVoronoiEdge2D; 961 962#define CV_VORONOINODE2D_FIELDS() \ 963 CV_SET_ELEM_FIELDS(CvVoronoiNode2D) \ 964 CvPoint2D32f pt; \ 965 float radius; 966 967typedef struct CvVoronoiNode2D 968{ 969 CV_VORONOINODE2D_FIELDS() 970} CvVoronoiNode2D; 971 972#define CV_VORONOIDIAGRAM2D_FIELDS() \ 973 CV_GRAPH_FIELDS() \ 974 CvSet *sites; 975 976typedef struct CvVoronoiDiagram2D 977{ 978 CV_VORONOIDIAGRAM2D_FIELDS() 979} CvVoronoiDiagram2D; 980 981/* Computes Voronoi Diagram for given polygons with holes */ 982CVAPI(int) cvVoronoiDiagramFromContour(CvSeq* ContourSeq, 983 CvVoronoiDiagram2D** VoronoiDiagram, 984 CvMemStorage* VoronoiStorage, 985 CvLeeParameters contour_type CV_DEFAULT(CV_LEE_INT), 986 int contour_orientation CV_DEFAULT(-1), 987 int attempt_number CV_DEFAULT(10)); 988 989/* Computes Voronoi Diagram for domains in given image */ 990CVAPI(int) cvVoronoiDiagramFromImage(IplImage* pImage, 991 CvSeq** ContourSeq, 992 CvVoronoiDiagram2D** VoronoiDiagram, 993 CvMemStorage* VoronoiStorage, 994 CvLeeParameters regularization_method CV_DEFAULT(CV_LEE_NON), 995 float approx_precision CV_DEFAULT(CV_LEE_AUTO)); 996 997/* Deallocates the storage */ 998CVAPI(void) cvReleaseVoronoiStorage(CvVoronoiDiagram2D* VoronoiDiagram, 999 CvMemStorage** pVoronoiStorage); 1000 1001/*********************** Linear-Contour Model ****************************/ 1002 1003struct CvLCMEdge; 1004struct CvLCMNode; 1005 1006typedef struct CvLCMEdge 1007{ 1008 CV_GRAPH_EDGE_FIELDS() 1009 CvSeq* chain; 1010 float width; 1011 int index1; 1012 int index2; 1013} CvLCMEdge; 1014 1015typedef struct CvLCMNode 1016{ 1017 CV_GRAPH_VERTEX_FIELDS() 1018 CvContour* contour; 1019} CvLCMNode; 1020 1021 1022/* Computes hybrid model from Voronoi Diagram */ 1023CVAPI(CvGraph*) cvLinearContorModelFromVoronoiDiagram(CvVoronoiDiagram2D* VoronoiDiagram, 1024 float maxWidth); 1025 1026/* Releases hybrid model storage */ 1027CVAPI(int) cvReleaseLinearContorModelStorage(CvGraph** Graph); 1028 1029 1030/* two stereo-related functions */ 1031 1032CVAPI(void) cvInitPerspectiveTransform( CvSize size, const CvPoint2D32f vertex[4], double matrix[3][3], 1033 CvArr* rectMap ); 1034 1035/*CVAPI(void) cvInitStereoRectification( CvStereoCamera* params, 1036 CvArr* rectMap1, CvArr* rectMap2, 1037 int do_undistortion );*/ 1038 1039/*************************** View Morphing Functions ************************/ 1040 1041/* The order of the function corresponds to the order they should appear in 1042 the view morphing pipeline */ 1043 1044/* Finds ending points of scanlines on left and right images of stereo-pair */ 1045CVAPI(void) cvMakeScanlines( const CvMatrix3* matrix, CvSize img_size, 1046 int* scanlines1, int* scanlines2, 1047 int* lengths1, int* lengths2, 1048 int* line_count ); 1049 1050/* Grab pixel values from scanlines and stores them sequentially 1051 (some sort of perspective image transform) */ 1052CVAPI(void) cvPreWarpImage( int line_count, 1053 IplImage* img, 1054 uchar* dst, 1055 int* dst_nums, 1056 int* scanlines); 1057 1058/* Approximate each grabbed scanline by a sequence of runs 1059 (lossy run-length compression) */ 1060CVAPI(void) cvFindRuns( int line_count, 1061 uchar* prewarp1, 1062 uchar* prewarp2, 1063 int* line_lengths1, 1064 int* line_lengths2, 1065 int* runs1, 1066 int* runs2, 1067 int* num_runs1, 1068 int* num_runs2); 1069 1070/* Compares two sets of compressed scanlines */ 1071CVAPI(void) cvDynamicCorrespondMulti( int line_count, 1072 int* first, 1073 int* first_runs, 1074 int* second, 1075 int* second_runs, 1076 int* first_corr, 1077 int* second_corr); 1078 1079/* Finds scanline ending coordinates for some intermediate "virtual" camera position */ 1080CVAPI(void) cvMakeAlphaScanlines( int* scanlines1, 1081 int* scanlines2, 1082 int* scanlinesA, 1083 int* lengths, 1084 int line_count, 1085 float alpha); 1086 1087/* Blends data of the left and right image scanlines to get 1088 pixel values of "virtual" image scanlines */ 1089CVAPI(void) cvMorphEpilinesMulti( int line_count, 1090 uchar* first_pix, 1091 int* first_num, 1092 uchar* second_pix, 1093 int* second_num, 1094 uchar* dst_pix, 1095 int* dst_num, 1096 float alpha, 1097 int* first, 1098 int* first_runs, 1099 int* second, 1100 int* second_runs, 1101 int* first_corr, 1102 int* second_corr); 1103 1104/* Does reverse warping of the morphing result to make 1105 it fill the destination image rectangle */ 1106CVAPI(void) cvPostWarpImage( int line_count, 1107 uchar* src, 1108 int* src_nums, 1109 IplImage* img, 1110 int* scanlines); 1111 1112/* Deletes Moire (missed pixels that appear due to discretization) */ 1113CVAPI(void) cvDeleteMoire( IplImage* img ); 1114 1115 1116/****************************************************************************************\ 1117* Background/foreground segmentation * 1118\****************************************************************************************/ 1119 1120/* We discriminate between foreground and background pixels 1121 * by building and maintaining a model of the background. 1122 * Any pixel which does not fit this model is then deemed 1123 * to be foreground. 1124 * 1125 * At present we support two core background models, 1126 * one of which has two variations: 1127 * 1128 * o CV_BG_MODEL_FGD: latest and greatest algorithm, described in 1129 * 1130 * Foreground Object Detection from Videos Containing Complex Background. 1131 * Liyuan Li, Weimin Huang, Irene Y.H. Gu, and Qi Tian. 1132 * ACM MM2003 9p 1133 * 1134 * o CV_BG_MODEL_FGD_SIMPLE: 1135 * A code comment describes this as a simplified version of the above, 1136 * but the code is in fact currently identical 1137 * 1138 * o CV_BG_MODEL_MOG: "Mixture of Gaussians", older algorithm, described in 1139 * 1140 * Moving target classification and tracking from real-time video. 1141 * A Lipton, H Fujijoshi, R Patil 1142 * Proceedings IEEE Workshop on Application of Computer Vision pp 8-14 1998 1143 * 1144 * Learning patterns of activity using real-time tracking 1145 * C Stauffer and W Grimson August 2000 1146 * IEEE Transactions on Pattern Analysis and Machine Intelligence 22(8):747-757 1147 */ 1148 1149 1150#define CV_BG_MODEL_FGD 0 1151#define CV_BG_MODEL_MOG 1 /* "Mixture of Gaussians". */ 1152#define CV_BG_MODEL_FGD_SIMPLE 2 1153 1154struct CvBGStatModel; 1155 1156typedef void (CV_CDECL * CvReleaseBGStatModel)( struct CvBGStatModel** bg_model ); 1157typedef int (CV_CDECL * CvUpdateBGStatModel)( IplImage* curr_frame, struct CvBGStatModel* bg_model ); 1158 1159#define CV_BG_STAT_MODEL_FIELDS() \ 1160 int type; /*type of BG model*/ \ 1161 CvReleaseBGStatModel release; \ 1162 CvUpdateBGStatModel update; \ 1163 IplImage* background; /*8UC3 reference background image*/ \ 1164 IplImage* foreground; /*8UC1 foreground image*/ \ 1165 IplImage** layers; /*8UC3 reference background image, can be null */ \ 1166 int layer_count; /* can be zero */ \ 1167 CvMemStorage* storage; /*storage for �foreground_regions�*/ \ 1168 CvSeq* foreground_regions /*foreground object contours*/ 1169 1170typedef struct CvBGStatModel 1171{ 1172 CV_BG_STAT_MODEL_FIELDS(); 1173} 1174CvBGStatModel; 1175 1176// 1177 1178// Releases memory used by BGStatModel 1179CV_INLINE void cvReleaseBGStatModel( CvBGStatModel** bg_model ) 1180{ 1181 if( bg_model && *bg_model && (*bg_model)->release ) 1182 (*bg_model)->release( bg_model ); 1183} 1184 1185// Updates statistical model and returns number of found foreground regions 1186CV_INLINE int cvUpdateBGStatModel( IplImage* current_frame, CvBGStatModel* bg_model ) 1187{ 1188 return bg_model && bg_model->update ? bg_model->update( current_frame, bg_model ) : 0; 1189} 1190 1191// Performs FG post-processing using segmentation 1192// (all pixels of a region will be classified as foreground if majority of pixels of the region are FG). 1193// parameters: 1194// segments - pointer to result of segmentation (for example MeanShiftSegmentation) 1195// bg_model - pointer to CvBGStatModel structure 1196CVAPI(void) cvRefineForegroundMaskBySegm( CvSeq* segments, CvBGStatModel* bg_model ); 1197 1198/* Common use change detection function */ 1199CVAPI(int) cvChangeDetection( IplImage* prev_frame, 1200 IplImage* curr_frame, 1201 IplImage* change_mask ); 1202 1203/* 1204 Interface of ACM MM2003 algorithm 1205*/ 1206 1207/* Default parameters of foreground detection algorithm: */ 1208#define CV_BGFG_FGD_LC 128 1209#define CV_BGFG_FGD_N1C 15 1210#define CV_BGFG_FGD_N2C 25 1211 1212#define CV_BGFG_FGD_LCC 64 1213#define CV_BGFG_FGD_N1CC 25 1214#define CV_BGFG_FGD_N2CC 40 1215 1216/* Background reference image update parameter: */ 1217#define CV_BGFG_FGD_ALPHA_1 0.1f 1218 1219/* stat model update parameter 1220 * 0.002f ~ 1K frame(~45sec), 0.005 ~ 18sec (if 25fps and absolutely static BG) 1221 */ 1222#define CV_BGFG_FGD_ALPHA_2 0.005f 1223 1224/* start value for alpha parameter (to fast initiate statistic model) */ 1225#define CV_BGFG_FGD_ALPHA_3 0.1f 1226 1227#define CV_BGFG_FGD_DELTA 2 1228 1229#define CV_BGFG_FGD_T 0.9f 1230 1231#define CV_BGFG_FGD_MINAREA 15.f 1232 1233#define CV_BGFG_FGD_BG_UPDATE_TRESH 0.5f 1234 1235/* See the above-referenced Li/Huang/Gu/Tian paper 1236 * for a full description of these background-model 1237 * tuning parameters. 1238 * 1239 * Nomenclature: 'c' == "color", a three-component red/green/blue vector. 1240 * We use histograms of these to model the range of 1241 * colors we've seen at a given background pixel. 1242 * 1243 * 'cc' == "color co-occurrence", a six-component vector giving 1244 * RGB color for both this frame and preceding frame. 1245 * We use histograms of these to model the range of 1246 * color CHANGES we've seen at a given background pixel. 1247 */ 1248typedef struct CvFGDStatModelParams 1249{ 1250 int Lc; /* Quantized levels per 'color' component. Power of two, typically 32, 64 or 128. */ 1251 int N1c; /* Number of color vectors used to model normal background color variation at a given pixel. */ 1252 int N2c; /* Number of color vectors retained at given pixel. Must be > N1c, typically ~ 5/3 of N1c. */ 1253 /* Used to allow the first N1c vectors to adapt over time to changing background. */ 1254 1255 int Lcc; /* Quantized levels per 'color co-occurrence' component. Power of two, typically 16, 32 or 64. */ 1256 int N1cc; /* Number of color co-occurrence vectors used to model normal background color variation at a given pixel. */ 1257 int N2cc; /* Number of color co-occurrence vectors retained at given pixel. Must be > N1cc, typically ~ 5/3 of N1cc. */ 1258 /* Used to allow the first N1cc vectors to adapt over time to changing background. */ 1259 1260 int is_obj_without_holes;/* If TRUE we ignore holes within foreground blobs. Defaults to TRUE. */ 1261 int perform_morphing; /* Number of erode-dilate-erode foreground-blob cleanup iterations. */ 1262 /* These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1. */ 1263 1264 float alpha1; /* How quickly we forget old background pixel values seen. Typically set to 0.1 */ 1265 float alpha2; /* "Controls speed of feature learning". Depends on T. Typical value circa 0.005. */ 1266 float alpha3; /* Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1. */ 1267 1268 float delta; /* Affects color and color co-occurrence quantization, typically set to 2. */ 1269 float T; /* "A percentage value which determines when new features can be recognized as new background." (Typically 0.9).*/ 1270 float minArea; /* Discard foreground blobs whose bounding box is smaller than this threshold. */ 1271} 1272CvFGDStatModelParams; 1273 1274typedef struct CvBGPixelCStatTable 1275{ 1276 float Pv, Pvb; 1277 uchar v[3]; 1278} 1279CvBGPixelCStatTable; 1280 1281typedef struct CvBGPixelCCStatTable 1282{ 1283 float Pv, Pvb; 1284 uchar v[6]; 1285} 1286CvBGPixelCCStatTable; 1287 1288typedef struct CvBGPixelStat 1289{ 1290 float Pbc; 1291 float Pbcc; 1292 CvBGPixelCStatTable* ctable; 1293 CvBGPixelCCStatTable* cctable; 1294 uchar is_trained_st_model; 1295 uchar is_trained_dyn_model; 1296} 1297CvBGPixelStat; 1298 1299 1300typedef struct CvFGDStatModel 1301{ 1302 CV_BG_STAT_MODEL_FIELDS(); 1303 CvBGPixelStat* pixel_stat; 1304 IplImage* Ftd; 1305 IplImage* Fbd; 1306 IplImage* prev_frame; 1307 CvFGDStatModelParams params; 1308} 1309CvFGDStatModel; 1310 1311/* Creates FGD model */ 1312CVAPI(CvBGStatModel*) cvCreateFGDStatModel( IplImage* first_frame, 1313 CvFGDStatModelParams* parameters CV_DEFAULT(NULL)); 1314 1315/* 1316 Interface of Gaussian mixture algorithm 1317 1318 "An improved adaptive background mixture model for real-time tracking with shadow detection" 1319 P. KadewTraKuPong and R. Bowden, 1320 Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001." 1321 http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf 1322*/ 1323 1324/* Note: "MOG" == "Mixture Of Gaussians": */ 1325 1326#define CV_BGFG_MOG_MAX_NGAUSSIANS 500 1327 1328/* default parameters of gaussian background detection algorithm */ 1329#define CV_BGFG_MOG_BACKGROUND_THRESHOLD 0.7 /* threshold sum of weights for background test */ 1330#define CV_BGFG_MOG_STD_THRESHOLD 2.5 /* lambda=2.5 is 99% */ 1331#define CV_BGFG_MOG_WINDOW_SIZE 200 /* Learning rate; alpha = 1/CV_GBG_WINDOW_SIZE */ 1332#define CV_BGFG_MOG_NGAUSSIANS 5 /* = K = number of Gaussians in mixture */ 1333#define CV_BGFG_MOG_WEIGHT_INIT 0.05 1334#define CV_BGFG_MOG_SIGMA_INIT 30 1335#define CV_BGFG_MOG_MINAREA 15.f 1336 1337 1338#define CV_BGFG_MOG_NCOLORS 3 1339 1340typedef struct CvGaussBGStatModelParams 1341{ 1342 int win_size; /* = 1/alpha */ 1343 int n_gauss; 1344 double bg_threshold, std_threshold, minArea; 1345 double weight_init, variance_init; 1346}CvGaussBGStatModelParams; 1347 1348typedef struct CvGaussBGValues 1349{ 1350 int match_sum; 1351 double weight; 1352 double variance[CV_BGFG_MOG_NCOLORS]; 1353 double mean[CV_BGFG_MOG_NCOLORS]; 1354} 1355CvGaussBGValues; 1356 1357typedef struct CvGaussBGPoint 1358{ 1359 CvGaussBGValues* g_values; 1360} 1361CvGaussBGPoint; 1362 1363 1364typedef struct CvGaussBGModel 1365{ 1366 CV_BG_STAT_MODEL_FIELDS(); 1367 CvGaussBGStatModelParams params; 1368 CvGaussBGPoint* g_point; 1369 int countFrames; 1370} 1371CvGaussBGModel; 1372 1373 1374/* Creates Gaussian mixture background model */ 1375CVAPI(CvBGStatModel*) cvCreateGaussianBGModel( IplImage* first_frame, 1376 CvGaussBGStatModelParams* parameters CV_DEFAULT(NULL)); 1377 1378 1379typedef struct CvBGCodeBookElem 1380{ 1381 struct CvBGCodeBookElem* next; 1382 int tLastUpdate; 1383 int stale; 1384 uchar boxMin[3]; 1385 uchar boxMax[3]; 1386 uchar learnMin[3]; 1387 uchar learnMax[3]; 1388} 1389CvBGCodeBookElem; 1390 1391typedef struct CvBGCodeBookModel 1392{ 1393 CvSize size; 1394 int t; 1395 uchar cbBounds[3]; 1396 uchar modMin[3]; 1397 uchar modMax[3]; 1398 CvBGCodeBookElem** cbmap; 1399 CvMemStorage* storage; 1400 CvBGCodeBookElem* freeList; 1401} 1402CvBGCodeBookModel; 1403 1404CVAPI(CvBGCodeBookModel*) cvCreateBGCodeBookModel(); 1405CVAPI(void) cvReleaseBGCodeBookModel( CvBGCodeBookModel** model ); 1406 1407CVAPI(void) cvBGCodeBookUpdate( CvBGCodeBookModel* model, const CvArr* image, 1408 CvRect roi CV_DEFAULT(cvRect(0,0,0,0)), 1409 const CvArr* mask CV_DEFAULT(0) ); 1410 1411CVAPI(int) cvBGCodeBookDiff( const CvBGCodeBookModel* model, const CvArr* image, 1412 CvArr* fgmask, CvRect roi CV_DEFAULT(cvRect(0,0,0,0)) ); 1413 1414CVAPI(void) cvBGCodeBookClearStale( CvBGCodeBookModel* model, int staleThresh, 1415 CvRect roi CV_DEFAULT(cvRect(0,0,0,0)), 1416 const CvArr* mask CV_DEFAULT(0) ); 1417 1418CVAPI(CvSeq*) cvSegmentFGMask( CvArr *fgmask, int poly1Hull0 CV_DEFAULT(1), 1419 float perimScale CV_DEFAULT(4.f), 1420 CvMemStorage* storage CV_DEFAULT(0), 1421 CvPoint offset CV_DEFAULT(cvPoint(0,0))); 1422 1423#ifdef __cplusplus 1424} 1425#endif 1426 1427#ifdef __cplusplus 1428 1429/****************************************************************************************\ 1430* Calibration engine * 1431\****************************************************************************************/ 1432 1433typedef enum CvCalibEtalonType 1434{ 1435 CV_CALIB_ETALON_USER = -1, 1436 CV_CALIB_ETALON_CHESSBOARD = 0, 1437 CV_CALIB_ETALON_CHECKERBOARD = CV_CALIB_ETALON_CHESSBOARD 1438} 1439CvCalibEtalonType; 1440 1441class CV_EXPORTS CvCalibFilter 1442{ 1443public: 1444 /* Constructor & destructor */ 1445 CvCalibFilter(); 1446 virtual ~CvCalibFilter(); 1447 1448 /* Sets etalon type - one for all cameras. 1449 etalonParams is used in case of pre-defined etalons (such as chessboard). 1450 Number of elements in etalonParams is determined by etalonType. 1451 E.g., if etalon type is CV_ETALON_TYPE_CHESSBOARD then: 1452 etalonParams[0] is number of squares per one side of etalon 1453 etalonParams[1] is number of squares per another side of etalon 1454 etalonParams[2] is linear size of squares in the board in arbitrary units. 1455 pointCount & points are used in case of 1456 CV_CALIB_ETALON_USER (user-defined) etalon. */ 1457 virtual bool 1458 SetEtalon( CvCalibEtalonType etalonType, double* etalonParams, 1459 int pointCount = 0, CvPoint2D32f* points = 0 ); 1460 1461 /* Retrieves etalon parameters/or and points */ 1462 virtual CvCalibEtalonType 1463 GetEtalon( int* paramCount = 0, const double** etalonParams = 0, 1464 int* pointCount = 0, const CvPoint2D32f** etalonPoints = 0 ) const; 1465 1466 /* Sets number of cameras calibrated simultaneously. It is equal to 1 initially */ 1467 virtual void SetCameraCount( int cameraCount ); 1468 1469 /* Retrieves number of cameras */ 1470 int GetCameraCount() const { return cameraCount; } 1471 1472 /* Starts cameras calibration */ 1473 virtual bool SetFrames( int totalFrames ); 1474 1475 /* Stops cameras calibration */ 1476 virtual void Stop( bool calibrate = false ); 1477 1478 /* Retrieves number of cameras */ 1479 bool IsCalibrated() const { return isCalibrated; } 1480 1481 /* Feeds another serie of snapshots (one per each camera) to filter. 1482 Etalon points on these images are found automatically. 1483 If the function can't locate points, it returns false */ 1484 virtual bool FindEtalon( IplImage** imgs ); 1485 1486 /* The same but takes matrices */ 1487 virtual bool FindEtalon( CvMat** imgs ); 1488 1489 /* Lower-level function for feeding filter with already found etalon points. 1490 Array of point arrays for each camera is passed. */ 1491 virtual bool Push( const CvPoint2D32f** points = 0 ); 1492 1493 /* Returns total number of accepted frames and, optionally, 1494 total number of frames to collect */ 1495 virtual int GetFrameCount( int* framesTotal = 0 ) const; 1496 1497 /* Retrieves camera parameters for specified camera. 1498 If camera is not calibrated the function returns 0 */ 1499 virtual const CvCamera* GetCameraParams( int idx = 0 ) const; 1500 1501 virtual const CvStereoCamera* GetStereoParams() const; 1502 1503 /* Sets camera parameters for all cameras */ 1504 virtual bool SetCameraParams( CvCamera* params ); 1505 1506 /* Saves all camera parameters to file */ 1507 virtual bool SaveCameraParams( const char* filename ); 1508 1509 /* Loads all camera parameters from file */ 1510 virtual bool LoadCameraParams( const char* filename ); 1511 1512 /* Undistorts images using camera parameters. Some of src pointers can be NULL. */ 1513 virtual bool Undistort( IplImage** src, IplImage** dst ); 1514 1515 /* Undistorts images using camera parameters. Some of src pointers can be NULL. */ 1516 virtual bool Undistort( CvMat** src, CvMat** dst ); 1517 1518 /* Returns array of etalon points detected/partally detected 1519 on the latest frame for idx-th camera */ 1520 virtual bool GetLatestPoints( int idx, CvPoint2D32f** pts, 1521 int* count, bool* found ); 1522 1523 /* Draw the latest detected/partially detected etalon */ 1524 virtual void DrawPoints( IplImage** dst ); 1525 1526 /* Draw the latest detected/partially detected etalon */ 1527 virtual void DrawPoints( CvMat** dst ); 1528 1529 virtual bool Rectify( IplImage** srcarr, IplImage** dstarr ); 1530 virtual bool Rectify( CvMat** srcarr, CvMat** dstarr ); 1531 1532protected: 1533 1534 enum { MAX_CAMERAS = 3 }; 1535 1536 /* etalon data */ 1537 CvCalibEtalonType etalonType; 1538 int etalonParamCount; 1539 double* etalonParams; 1540 int etalonPointCount; 1541 CvPoint2D32f* etalonPoints; 1542 CvSize imgSize; 1543 CvMat* grayImg; 1544 CvMat* tempImg; 1545 CvMemStorage* storage; 1546 1547 /* camera data */ 1548 int cameraCount; 1549 CvCamera cameraParams[MAX_CAMERAS]; 1550 CvStereoCamera stereo; 1551 CvPoint2D32f* points[MAX_CAMERAS]; 1552 CvMat* undistMap[MAX_CAMERAS][2]; 1553 CvMat* undistImg; 1554 int latestCounts[MAX_CAMERAS]; 1555 CvPoint2D32f* latestPoints[MAX_CAMERAS]; 1556 CvMat* rectMap[MAX_CAMERAS][2]; 1557 1558 /* Added by Valery */ 1559 //CvStereoCamera stereoParams; 1560 1561 int maxPoints; 1562 int framesTotal; 1563 int framesAccepted; 1564 bool isCalibrated; 1565}; 1566 1567#include "cvaux.hpp" 1568#include "cvvidsurv.hpp" 1569/*#include "cvmat.hpp"*/ 1570#endif 1571 1572#endif 1573 1574/* End of file. */ 1575