modules/legacy/include/opencv2/legacy/blobtrack.hpp

   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
  43 #ifndef __OPENCV_VIDEOSURVEILLANCE_H__
  44 #define __OPENCV_VIDEOSURVEILLANCE_H__
  45
  46 /* Turn off the functionality until cvaux/src/Makefile.am gets updated: */
  47 //#if _MSC_VER >= 1200
  48
  49 #include "opencv2/core/core_c.h"
  50 #include <stdio.h>
  51
  52 #if (defined _MSC_VER && _MSC_VER >= 1200) || defined __BORLANDC__
  53 #define cv_stricmp stricmp
  54 #define cv_strnicmp strnicmp
  55 #if defined WINCE
  56 #define strdup _strdup
  57 #define stricmp _stricmp
  58 #endif
  59 #elif defined __GNUC__ || defined __sun
  60 #define cv_stricmp strcasecmp
  61 #define cv_strnicmp strncasecmp
  62 #else
  63 #error Do not know how to make case-insensitive string comparison on this platform
  64 #endif
  65
  66 //struct DefParam;
  67 struct CvDefParam
  68 {
  69     struct CvDefParam*    next;
  70     char*               pName;
  71     char*               pComment;
  72     double*             pDouble;
  73     double              Double;
  74     float*              pFloat;
  75     float               Float;
  76     int*                pInt;
  77     int                 Int;
  78     char**              pStr;
  79     char*               Str;
  80 };
  81
  82 class CV_EXPORTS CvVSModule
  83 {
  84 private: /* Internal data: */
  85     CvDefParam*   m_pParamList;
  86     char*       m_pModuleTypeName;
  87     char*       m_pModuleName;
  88     char*       m_pNickName;
  89 protected:
  90     int         m_Wnd;
  91 public: /* Constructor and destructor: */
  92     CvVSModule();
  93     virtual ~CvVSModule();
  94 private: /* Internal functions: */
  95     void    FreeParam(CvDefParam** pp);
  96     CvDefParam* NewParam(const char* name);
  97     CvDefParam* GetParamPtr(int index);
  98     CvDefParam* GetParamPtr(const char* name);
  99 protected: /* INTERNAL INTERFACE */
 100     int  IsParam(const char* name);
 101     void AddParam(const char* name, double* pAddr);
 102     void AddParam(const char* name, float* pAddr);
 103     void AddParam(const char* name, int* pAddr);
 104     void AddParam(const char* name, const char** pAddr);
 105     void AddParam(const char* name);
 106     void CommentParam(const char* name, const char* pComment);
 107     void SetTypeName(const char* name);
 108     void SetModuleName(const char* name);
 109     void DelParam(const char* name);
 110
 111 public: /* EXTERNAL INTERFACE */
 112     const char* GetParamName(int index);
 113     const char* GetParamComment(const char* name);
 114     double GetParam(const char* name);
 115     const char* GetParamStr(const char* name);
 116     void   SetParam(const char* name, double val);
 117     void   SetParamStr(const char* name, const char* str);
 118     void TransferParamsFromChild(CvVSModule* pM, const char* prefix = NULL);
 119     void TransferParamsToChild(CvVSModule* pM, char* prefix = NULL);
 120     virtual void ParamUpdate();
 121     const char*   GetTypeName();
 122     int     IsModuleTypeName(const char* name);
 123     char*   GetModuleName();
 124     int     IsModuleName(const char* name);
 125     void SetNickName(const char* pStr);
 126     const char* GetNickName();
 127     virtual void SaveState(CvFileStorage*);
 128     virtual void LoadState(CvFileStorage*, CvFileNode*);
 129
 130     virtual void Release() = 0;
 131 };/* CvVMModule */
 132
 133 CV_EXPORTS void cvWriteStruct(CvFileStorage* fs, const char* name, void* addr, const char* desc, int num=1);
 134 CV_EXPORTS void cvReadStructByName(CvFileStorage* fs, CvFileNode* node, const char* name, void* addr, const char* desc);
 135
 136 /* FOREGROUND DETECTOR INTERFACE */
 137 class CV_EXPORTS CvFGDetector : public CvVSModule
 138 {
 139 public:
 140     CvFGDetector();
 141     virtual IplImage* GetMask() = 0;
 142     /* Process current image: */
 143     virtual void    Process(IplImage* pImg) = 0;
 144     /* Release foreground detector: */
 145     virtual void    Release() = 0;
 146 };
 147
 148 CV_EXPORTS void cvReleaseFGDetector(CvFGDetector** ppT );
 149 CV_EXPORTS CvFGDetector* cvCreateFGDetectorBase(int type, void *param);
 150
 151
 152 /* BLOB STRUCTURE*/
 153 struct CvBlob
 154 {
 155     float   x,y; /* blob position   */
 156     float   w,h; /* blob sizes      */
 157     int     ID;  /* blob ID         */
 158 };
 159
 160 inline CvBlob cvBlob(float x,float y, float w, float h)
 161 {
 162     CvBlob B = {x,y,w,h,0};
 163     return B;
 164 }
 165 #define CV_BLOB_MINW 5
 166 #define CV_BLOB_MINH 5
 167 #define CV_BLOB_ID(pB) (((CvBlob*)(pB))->ID)
 168 #define CV_BLOB_CENTER(pB) cvPoint2D32f(((CvBlob*)(pB))->x,((CvBlob*)(pB))->y)
 169 #define CV_BLOB_X(pB) (((CvBlob*)(pB))->x)
 170 #define CV_BLOB_Y(pB) (((CvBlob*)(pB))->y)
 171 #define CV_BLOB_WX(pB) (((CvBlob*)(pB))->w)
 172 #define CV_BLOB_WY(pB) (((CvBlob*)(pB))->h)
 173 #define CV_BLOB_RX(pB) (0.5f*CV_BLOB_WX(pB))
 174 #define CV_BLOB_RY(pB) (0.5f*CV_BLOB_WY(pB))
 175 #define CV_BLOB_RECT(pB) cvRect(cvRound(((CvBlob*)(pB))->x-CV_BLOB_RX(pB)),cvRound(((CvBlob*)(pB))->y-CV_BLOB_RY(pB)),cvRound(CV_BLOB_WX(pB)),cvRound(CV_BLOB_WY(pB)))
 176 /* END BLOB STRUCTURE*/
 177
 178
 179 /* simple BLOBLIST */
 180 class CV_EXPORTS CvBlobSeq
 181 {
 182 public:
 183     CvBlobSeq(int BlobSize = sizeof(CvBlob))
 184     {
 185         m_pMem = cvCreateMemStorage();
 186         m_pSeq = cvCreateSeq(0,sizeof(CvSeq),BlobSize,m_pMem);
 187         strcpy(m_pElemFormat,"ffffi");
 188     }
 189     virtual ~CvBlobSeq()
 190     {
 191         cvReleaseMemStorage(&m_pMem);
 192     };
 193     virtual CvBlob* GetBlob(int BlobIndex)
 194     {
 195         return (CvBlob*)cvGetSeqElem(m_pSeq,BlobIndex);
 196     };
 197     virtual CvBlob* GetBlobByID(int BlobID)
 198     {
 199         int i;
 200         for(i=0; i<m_pSeq->total; ++i)
 201             if(BlobID == CV_BLOB_ID(GetBlob(i)))
 202                 return GetBlob(i);
 203         return NULL;
 204     };
 205     virtual void DelBlob(int BlobIndex)
 206     {
 207         cvSeqRemove(m_pSeq,BlobIndex);
 208     };
 209     virtual void DelBlobByID(int BlobID)
 210     {
 211         int i;
 212         for(i=0; i<m_pSeq->total; ++i)
 213         {
 214             if(BlobID == CV_BLOB_ID(GetBlob(i)))
 215             {
 216                 DelBlob(i);
 217                 return;
 218             }
 219         }
 220     };
 221     virtual void Clear()
 222     {
 223         cvClearSeq(m_pSeq);
 224     };
 225     virtual void AddBlob(CvBlob* pB)
 226     {
 227         cvSeqPush(m_pSeq,pB);
 228     };
 229     virtual int GetBlobNum()
 230     {
 231         return m_pSeq->total;
 232     };
 233     virtual void Write(CvFileStorage* fs, const char* name)
 234     {
 235         const char*  attr[] = {"dt",m_pElemFormat,NULL};
 236         if(fs)
 237         {
 238             cvWrite(fs,name,m_pSeq,cvAttrList(attr,NULL));
 239         }
 240     }
 241     virtual void Load(CvFileStorage* fs, CvFileNode* node)
 242     {
 243         if(fs==NULL) return;
 244         CvSeq* pSeq = (CvSeq*)cvRead(fs, node);
 245         if(pSeq)
 246         {
 247             int i;
 248             cvClearSeq(m_pSeq);
 249             for(i=0;i<pSeq->total;++i)
 250             {
 251                 void* pB = cvGetSeqElem( pSeq, i );
 252                 cvSeqPush( m_pSeq, pB );
 253             }
 254         }
 255     }
 256     void AddFormat(const char* str){strcat(m_pElemFormat,str);}
 257 protected:
 258     CvMemStorage*   m_pMem;
 259     CvSeq*          m_pSeq;
 260     char            m_pElemFormat[1024];
 261 };
 262 /* simple BLOBLIST */
 263
 264
 265 /* simple TRACKLIST */
 266 struct CvBlobTrack
 267 {
 268     int         TrackID;
 269     int         StartFrame;
 270     CvBlobSeq*  pBlobSeq;
 271 };
 272
 273 class CV_EXPORTS CvBlobTrackSeq
 274 {
 275 public:
 276     CvBlobTrackSeq(int TrackSize = sizeof(CvBlobTrack));
 277     virtual ~CvBlobTrackSeq();
 278     virtual CvBlobTrack* GetBlobTrack(int TrackIndex);
 279     virtual CvBlobTrack* GetBlobTrackByID(int TrackID);
 280     virtual void DelBlobTrack(int TrackIndex);
 281     virtual void DelBlobTrackByID(int TrackID);
 282     virtual void Clear();
 283     virtual void AddBlobTrack(int TrackID, int StartFrame = 0);
 284     virtual int GetBlobTrackNum();
 285 protected:
 286     CvMemStorage*   m_pMem;
 287     CvSeq*          m_pSeq;
 288 };
 289
 290 /* simple TRACKLIST */
 291
 292
 293 /* BLOB DETECTOR INTERFACE */
 294 class CV_EXPORTS CvBlobDetector: public CvVSModule
 295 {
 296 public:
 297     CvBlobDetector(){SetTypeName("BlobDetector");};
 298     /* Try to detect new blob entrance based on foreground mask. */
 299     /* pFGMask - image of foreground mask */
 300     /* pNewBlob - pointer to CvBlob structure which will be filled if new blob entrance detected */
 301     /* pOldBlobList - pointer to blob list which already exist on image */
 302     virtual int DetectNewBlob(IplImage* pImg, IplImage* pImgFG, CvBlobSeq* pNewBlobList, CvBlobSeq* pOldBlobList) = 0;
 303     /* release blob detector */
 304     virtual void Release()=0;
 305 };
 306
 307 /* Release any blob detector: */
 308 CV_EXPORTS void cvReleaseBlobDetector(CvBlobDetector** ppBD);
 309
 310 /* Declarations of constructors of implemented modules: */
 311 CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorSimple();
 312 CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorCC();
 313
 314 struct CV_EXPORTS CvDetectedBlob : public CvBlob
 315 {
 316     float response;
 317 };
 318
 319 CV_INLINE CvDetectedBlob cvDetectedBlob( float x, float y, float w, float h, int ID = 0, float response = 0.0F )
 320 {
 321     CvDetectedBlob b;
 322     b.x = x; b.y = y; b.w = w; b.h = h; b.ID = ID; b.response = response;
 323     return b;
 324 }
 325
 326
 327 class CV_EXPORTS CvObjectDetector
 328 {
 329 public:
 330     CvObjectDetector( const char* /*detector_file_name*/ = 0 );
 331     ~CvObjectDetector();
 332
 333     /*
 334      * Release the current detector and load new detector from file
 335      * (if detector_file_name is not 0)
 336      * Return true on success:
 337      */
 338     bool Load( const char* /*detector_file_name*/ = 0 );
 339
 340     /* Return min detector window size: */
 341     CvSize GetMinWindowSize() const;
 342
 343     /* Return max border: */
 344     int GetMaxBorderSize() const;
 345
 346     /*
 347      * Detect the object on the image and push the detected
 348      * blobs into <detected_blob_seq> which must be the sequence of <CvDetectedBlob>s
 349      */
 350     void Detect( const CvArr* /*img*/, /* out */ CvBlobSeq* /*detected_blob_seq*/ = 0 );
 351
 352 protected:
 353     class CvObjectDetectorImpl* impl;
 354 };
 355
 356
 357 CV_INLINE CvRect cvRectIntersection( const CvRect r1, const CvRect r2 )
 358 {
 359     CvRect r = cvRect( MAX(r1.x, r2.x), MAX(r1.y, r2.y), 0, 0 );
 360
 361     r.width  = MIN(r1.x + r1.width, r2.x + r2.width) - r.x;
 362     r.height = MIN(r1.y + r1.height, r2.y + r2.height) - r.y;
 363
 364     return r;
 365 }
 366
 367
 368 /*
 369  * CvImageDrawer
 370  *
 371  * Draw on an image the specified ROIs from the source image and
 372  * given blobs as ellipses or rectangles:
 373  */
 374
 375 struct CvDrawShape
 376 {
 377     enum {RECT, ELLIPSE} shape;
 378     CvScalar color;
 379 };
 380
 381 /*extern const CvDrawShape icv_shape[] =
 382 {
 383     { CvDrawShape::ELLIPSE, CV_RGB(255,0,0) },
 384     { CvDrawShape::ELLIPSE, CV_RGB(0,255,0) },
 385     { CvDrawShape::ELLIPSE, CV_RGB(0,0,255) },
 386     { CvDrawShape::ELLIPSE, CV_RGB(255,255,0) },
 387     { CvDrawShape::ELLIPSE, CV_RGB(0,255,255) },
 388     { CvDrawShape::ELLIPSE, CV_RGB(255,0,255) }
 389 };*/
 390
 391 class CV_EXPORTS CvImageDrawer
 392 {
 393 public:
 394     CvImageDrawer() : m_image(0) {}
 395     ~CvImageDrawer() { cvReleaseImage( &m_image ); }
 396     void SetShapes( const CvDrawShape* shapes, int num );
 397     /* <blob_seq> must be the sequence of <CvDetectedBlob>s */
 398     IplImage* Draw( const CvArr* src, CvBlobSeq* blob_seq = 0, const CvSeq* roi_seq = 0 );
 399     IplImage* GetImage() { return m_image; }
 400 protected:
 401     //static const int MAX_SHAPES = sizeof(icv_shape) / sizeof(icv_shape[0]);;
 402
 403     IplImage* m_image;
 404     CvDrawShape m_shape[16];
 405 };
 406
 407
 408
 409 /* Trajectory generation module: */
 410 class CV_EXPORTS CvBlobTrackGen: public CvVSModule
 411 {
 412 public:
 413     CvBlobTrackGen(){SetTypeName("BlobTrackGen");};
 414     virtual void    SetFileName(char* pFileName) = 0;
 415     virtual void    AddBlob(CvBlob* pBlob) = 0;
 416     virtual void    Process(IplImage* pImg = NULL, IplImage* pFG = NULL) = 0;
 417     virtual void    Release() = 0;
 418 };
 419
 420 inline void cvReleaseBlobTrackGen(CvBlobTrackGen** pBTGen)
 421 {
 422     if(*pBTGen)(*pBTGen)->Release();
 423     *pBTGen = 0;
 424 }
 425
 426 /* Declarations of constructors of implemented modules: */
 427 CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGen1();
 428 CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGenYML();
 429
 430
 431
 432 /* BLOB TRACKER INTERFACE */
 433 class CV_EXPORTS CvBlobTracker: public CvVSModule
 434 {
 435 public:
 436     CvBlobTracker();
 437
 438     /* Add new blob to track it and assign to this blob personal ID */
 439     /* pBlob - pointer to structure with blob parameters (ID is ignored)*/
 440     /* pImg - current image */
 441     /* pImgFG - current foreground mask */
 442     /* Return pointer to new added blob: */
 443     virtual CvBlob* AddBlob(CvBlob* pBlob, IplImage* pImg, IplImage* pImgFG = NULL ) = 0;
 444
 445     /* Return number of currently tracked blobs: */
 446     virtual int     GetBlobNum() = 0;
 447
 448     /* Return pointer to specified by index blob: */
 449     virtual CvBlob* GetBlob(int BlobIndex) = 0;
 450
 451     /* Delete blob by its index: */
 452     virtual void    DelBlob(int BlobIndex) = 0;
 453
 454     /* Process current image and track all existed blobs: */
 455     virtual void    Process(IplImage* pImg, IplImage* pImgFG = NULL) = 0;
 456
 457     /* Release blob tracker: */
 458     virtual void    Release() = 0;
 459
 460
 461     /* Process one blob (for multi hypothesis tracing): */
 462     virtual void ProcessBlob(int BlobIndex, CvBlob* pBlob, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
 463
 464     /* Get confidence/wieght/probability (0-1) for blob: */
 465     virtual double  GetConfidence(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
 466
 467     virtual double GetConfidenceList(CvBlobSeq* pBlobList, IplImage* pImg, IplImage* pImgFG = NULL);
 468
 469     virtual void UpdateBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
 470
 471     /* Update all blob models: */
 472     virtual void Update(IplImage* pImg, IplImage* pImgFG = NULL);
 473
 474     /* Return pointer to blob by its unique ID: */
 475     virtual int     GetBlobIndexByID(int BlobID);
 476
 477     /* Return pointer to blob by its unique ID: */
 478     virtual CvBlob* GetBlobByID(int BlobID);
 479
 480     /* Delete blob by its ID: */
 481     virtual void    DelBlobByID(int BlobID);
 482
 483     /* Set new parameters for specified (by index) blob: */
 484     virtual void    SetBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/);
 485
 486     /* Set new parameters for specified (by ID) blob: */
 487     virtual void    SetBlobByID(int BlobID, CvBlob* pBlob);
 488
 489     /*  ===============  MULTI HYPOTHESIS INTERFACE ==================  */
 490
 491     /* Return number of position hyposetis of currently tracked blob: */
 492     virtual int     GetBlobHypNum(int /*BlobIdx*/);
 493
 494     /* Return pointer to specified blob hypothesis by index blob: */
 495     virtual CvBlob* GetBlobHyp(int BlobIndex, int /*hypothesis*/);
 496
 497     /* Set new parameters for specified (by index) blob hyp
 498      * (can be called several times for each hyp ):
 499      */
 500     virtual void    SetBlobHyp(int /*BlobIndex*/, CvBlob* /*pBlob*/);
 501 };
 502
 503 CV_EXPORTS void cvReleaseBlobTracker(CvBlobTracker**ppT );
 504 /* BLOB TRACKER INTERFACE */
 505
 506 /*BLOB TRACKER ONE INTERFACE */
 507 class CV_EXPORTS CvBlobTrackerOne : public CvVSModule
 508 {
 509 public:
 510     virtual void Init(CvBlob* pBlobInit, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
 511     virtual CvBlob* Process(CvBlob* pBlobPrev, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
 512     virtual void Release() =  0;
 513
 514     /* Non-required methods: */
 515     virtual void SkipProcess(CvBlob* /*pBlobPrev*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
 516     virtual void Update(CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
 517     virtual void SetCollision(int /*CollisionFlag*/){}; /* call in case of blob collision situation*/
 518     virtual double GetConfidence(CvBlob* /*pBlob*/, IplImage* /*pImg*/,
 519                                  IplImage* /*pImgFG*/ = NULL, IplImage* /*pImgUnusedReg*/ = NULL)
 520     {
 521         return 1;
 522     };
 523 };
 524 inline void cvReleaseBlobTrackerOne(CvBlobTrackerOne **ppT )
 525 {
 526     ppT[0]->Release();
 527     ppT[0] = 0;
 528 }
 529 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerList(CvBlobTrackerOne* (*create)());
 530 /*BLOB TRACKER ONE INTERFACE */
 531
 532 /* Declarations of constructors of implemented modules: */
 533
 534 /* Some declarations for specific MeanShift tracker: */
 535 #define PROFILE_EPANECHNIKOV    0
 536 #define PROFILE_DOG             1
 537 struct CvBlobTrackerParamMS
 538 {
 539     int     noOfSigBits;
 540     int     appearance_profile;
 541     int     meanshift_profile;
 542     float   sigma;
 543 };
 544
 545 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1(CvBlobTrackerParamMS* param);
 546 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS2(CvBlobTrackerParamMS* param);
 547 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1ByList();
 548
 549 /* Some declarations for specific Likelihood tracker: */
 550 struct CvBlobTrackerParamLH
 551 {
 552     int     HistType; /* see Prob.h */
 553     int     ScaleAfter;
 554 };
 555
 556 /* Without scale optimization: */
 557 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHR(CvBlobTrackerParamLH* /*param*/ = NULL);
 558
 559 /* With scale optimization: */
 560 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHRS(CvBlobTrackerParamLH* /*param*/ = NULL);
 561
 562 /* Simple blob tracker based on connected component tracking: */
 563 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCC();
 564
 565 /* Connected component tracking and mean-shift particle filter collion-resolver: */
 566 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCCMSPF();
 567
 568 /* Blob tracker that integrates meanshift and connected components: */
 569 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFG();
 570 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFGS();
 571
 572 /* Meanshift without connected-components */
 573 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS();
 574
 575 /* Particle filtering via Bhattacharya coefficient, which        */
 576 /* is roughly the dot-product of two probability densities.      */
 577 /* See: Real-Time Tracking of Non-Rigid Objects using Mean Shift */
 578 /*      Comanicius, Ramesh, Meer, 2000, 8p                       */
 579 /*      http://citeseer.ist.psu.edu/321441.html                  */
 580 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSPF();
 581
 582 /* =========== tracker integrators trackers =============*/
 583
 584 /* Integrator based on Particle Filtering method: */
 585 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPF();
 586
 587 /* Rule based integrator: */
 588 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIRB();
 589
 590 /* Integrator based on data fusion using particle filtering: */
 591 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPFDF();
 592
 593
 594
 595
 596 /* Trajectory postprocessing module: */
 597 class CV_EXPORTS CvBlobTrackPostProc: public CvVSModule
 598 {
 599 public:
 600     CvBlobTrackPostProc(){SetTypeName("BlobTrackPostProc");};
 601     virtual void    AddBlob(CvBlob* pBlob) = 0;
 602     virtual void    Process() = 0;
 603     virtual int     GetBlobNum() = 0;
 604     virtual CvBlob* GetBlob(int index) = 0;
 605     virtual void    Release() = 0;
 606
 607     /* Additional functionality: */
 608     virtual CvBlob* GetBlobByID(int BlobID)
 609     {
 610         int i;
 611         for(i=GetBlobNum();i>0;i--)
 612         {
 613             CvBlob* pB=GetBlob(i-1);
 614             if(pB->ID==BlobID) return pB;
 615         }
 616         return NULL;
 617     };
 618 };
 619
 620 inline void cvReleaseBlobTrackPostProc(CvBlobTrackPostProc** pBTPP)
 621 {
 622     if(pBTPP == NULL) return;
 623     if(*pBTPP)(*pBTPP)->Release();
 624     *pBTPP = 0;
 625 }
 626
 627 /* Trajectory generation module: */
 628 class CV_EXPORTS CvBlobTrackPostProcOne: public CvVSModule
 629 {
 630 public:
 631     CvBlobTrackPostProcOne(){SetTypeName("BlobTrackPostOne");};
 632     virtual CvBlob* Process(CvBlob* pBlob) = 0;
 633     virtual void    Release() = 0;
 634 };
 635
 636 /* Create blob tracking post processing module based on simle module: */
 637 CV_EXPORTS CvBlobTrackPostProc* cvCreateBlobTrackPostProcList(CvBlobTrackPostProcOne* (*create)());
 638
 639
 640 /* Declarations of constructors of implemented modules: */
 641 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcKalman();
 642 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverRect();
 643 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverExp();
 644
 645
 646 /* PREDICTORS */
 647 /* blob PREDICTOR */
 648 class CvBlobTrackPredictor: public CvVSModule
 649 {
 650 public:
 651     CvBlobTrackPredictor(){SetTypeName("BlobTrackPredictor");};
 652     virtual CvBlob* Predict() = 0;
 653     virtual void    Update(CvBlob* pBlob) = 0;
 654     virtual void    Release() = 0;
 655 };
 656 CV_EXPORTS CvBlobTrackPredictor* cvCreateModuleBlobTrackPredictKalman();
 657
 658
 659
 660 /* Trajectory analyser module: */
 661 class CV_EXPORTS CvBlobTrackAnalysis: public CvVSModule
 662 {
 663 public:
 664     CvBlobTrackAnalysis(){SetTypeName("BlobTrackAnalysis");};
 665     virtual void    AddBlob(CvBlob* pBlob) = 0;
 666     virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
 667     virtual float   GetState(int BlobID) = 0;
 668     /* return 0 if trajectory is normal
 669        return >0 if trajectory abnormal */
 670     virtual const char*   GetStateDesc(int /*BlobID*/){return NULL;};
 671     virtual void    SetFileName(char* /*DataBaseName*/){};
 672     virtual void    Release() = 0;
 673 };
 674
 675
 676 inline void cvReleaseBlobTrackAnalysis(CvBlobTrackAnalysis** pBTPP)
 677 {
 678     if(pBTPP == NULL) return;
 679     if(*pBTPP)(*pBTPP)->Release();
 680     *pBTPP = 0;
 681 }
 682
 683 /* Feature-vector generation module: */
 684 class CV_EXPORTS CvBlobTrackFVGen : public CvVSModule
 685 {
 686 public:
 687     CvBlobTrackFVGen(){SetTypeName("BlobTrackFVGen");};
 688     virtual void    AddBlob(CvBlob* pBlob) = 0;
 689     virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
 690     virtual void    Release() = 0;
 691     virtual int     GetFVSize() = 0;
 692     virtual int     GetFVNum() = 0;
 693     virtual float*  GetFV(int index, int* pFVID) = 0; /* Returns pointer to FV, if return 0 then FV not created */
 694     virtual float*  GetFVVar(){return NULL;}; /* Returns pointer to array of variation of values of FV, if returns 0 then FVVar does not exist. */
 695     virtual float*  GetFVMin() = 0; /* Returns pointer to array of minimal values of FV, if returns 0 then FVrange does not exist */
 696     virtual float*  GetFVMax() = 0; /* Returns pointer to array of maximal values of FV, if returns 0 then FVrange does not exist */
 697 };
 698
 699
 700 /* Trajectory Analyser module: */
 701 class CV_EXPORTS CvBlobTrackAnalysisOne
 702 {
 703 public:
 704     virtual ~CvBlobTrackAnalysisOne() {};
 705     virtual int     Process(CvBlob* pBlob, IplImage* pImg, IplImage* pFG) = 0;
 706     /* return 0 if trajectory is normal
 707        return >0 if trajectory abnormal */
 708     virtual void    Release() = 0;
 709 };
 710
 711 /* Create blob tracking post processing module based on simle module: */
 712 CV_EXPORTS CvBlobTrackAnalysis* cvCreateBlobTrackAnalysisList(CvBlobTrackAnalysisOne* (*create)());
 713
 714 /* Declarations of constructors of implemented modules: */
 715
 716 /* Based on histogram analysis of 2D FV (x,y): */
 717 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistP();
 718
 719 /* Based on histogram analysis of 4D FV (x,y,vx,vy): */
 720 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPV();
 721
 722 /* Based on histogram analysis of 5D FV (x,y,vx,vy,state): */
 723 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPVS();
 724
 725 /* Based on histogram analysis of 4D FV (startpos,stoppos): */
 726 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistSS();
 727
 728
 729
 730 /* Based on SVM classifier analysis of 2D FV (x,y): */
 731 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMP();
 732
 733 /* Based on SVM classifier analysis of 4D FV (x,y,vx,vy): */
 734 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPV();
 735
 736 /* Based on SVM classifier analysis of 5D FV (x,y,vx,vy,state): */
 737 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPVS();
 738
 739 /* Based on SVM classifier analysis of 4D FV (startpos,stoppos): */
 740 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMSS();
 741
 742 /* Track analysis based on distance between tracks: */
 743 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisTrackDist();
 744
 745 /* Analyzer based on reation Road and height map: */
 746 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysis3DRoadMap();
 747
 748 /* Analyzer that makes OR decision using set of analyzers: */
 749 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisIOR();
 750
 751 /* Estimator of human height: */
 752 class CV_EXPORTS CvBlobTrackAnalysisHeight: public CvBlobTrackAnalysis
 753 {
 754 public:
 755     virtual double  GetHeight(CvBlob* pB) = 0;
 756 };
 757 //CV_EXPORTS CvBlobTrackAnalysisHeight* cvCreateModuleBlobTrackAnalysisHeightScale();
 758
 759
 760
 761 /* AUTO BLOB TRACKER INTERFACE -- pipeline of 3 modules: */
 762 class CV_EXPORTS CvBlobTrackerAuto: public CvVSModule
 763 {
 764 public:
 765     CvBlobTrackerAuto(){SetTypeName("BlobTrackerAuto");};
 766     virtual void        Process(IplImage* pImg, IplImage* pMask = NULL) = 0;
 767     virtual CvBlob*     GetBlob(int index) = 0;
 768     virtual CvBlob*     GetBlobByID(int ID) = 0;
 769     virtual int         GetBlobNum() = 0;
 770     virtual IplImage*   GetFGMask(){return NULL;};
 771     virtual float       GetState(int BlobID) = 0;
 772     virtual const char*       GetStateDesc(int BlobID) = 0;
 773     /* return 0 if trajectory is normal;
 774      * return >0 if trajectory abnormal. */
 775     virtual void    Release() = 0;
 776 };
 777 inline void cvReleaseBlobTrackerAuto(CvBlobTrackerAuto** ppT)
 778 {
 779     ppT[0]->Release();
 780     ppT[0] = 0;
 781 }
 782 /* END AUTO BLOB TRACKER INTERFACE */
 783
 784
 785 /* Constructor functions and data for specific BlobTRackerAuto modules: */
 786
 787 /* Parameters of blobtracker auto ver1: */
 788 struct CvBlobTrackerAutoParam1
 789 {
 790     int                     FGTrainFrames; /* Number of frames needed for FG (foreground) detector to train.        */
 791
 792     CvFGDetector*           pFG;           /* FGDetector module. If this field is NULL the Process FG mask is used. */
 793
 794     CvBlobDetector*         pBD;           /* Selected blob detector module.                                        */
 795                                            /* If this field is NULL default blobdetector module will be created.    */
 796
 797     CvBlobTracker*          pBT;           /* Selected blob tracking module.                                        */
 798                                            /* If this field is NULL default blobtracker module will be created.     */
 799
 800     CvBlobTrackGen*         pBTGen;        /* Selected blob trajectory generator.                                   */
 801                                            /* If this field is NULL no generator is used.                           */
 802
 803     CvBlobTrackPostProc*    pBTPP;         /* Selected blob trajectory postprocessing module.                       */
 804                                            /* If this field is NULL no postprocessing is done.                      */
 805
 806     int                     UsePPData;
 807
 808     CvBlobTrackAnalysis*    pBTA;          /* Selected blob trajectory analysis module.                             */
 809                                            /* If this field is NULL no track analysis is done.                      */
 810 };
 811
 812 /* Create blob tracker auto ver1: */
 813 CV_EXPORTS CvBlobTrackerAuto* cvCreateBlobTrackerAuto1(CvBlobTrackerAutoParam1* param = NULL);
 814
 815 /* Simple loader for many auto trackers by its type : */
 816 inline CvBlobTrackerAuto* cvCreateBlobTrackerAuto(int type, void* param)
 817 {
 818     if(type == 0) return cvCreateBlobTrackerAuto1((CvBlobTrackerAutoParam1*)param);
 819     return 0;
 820 }
 821
 822
 823
 824 struct CvTracksTimePos
 825 {
 826     int len1,len2;
 827     int beg1,beg2;
 828     int end1,end2;
 829     int comLen; //common length for two tracks
 830     int shift1,shift2;
 831 };
 832
 833 /*CV_EXPORTS int cvCompareTracks( CvBlobTrackSeq *groundTruth,
 834                    CvBlobTrackSeq *result,
 835                    FILE *file);*/
 836
 837
 838 /* Constructor functions:  */
 839
 840 CV_EXPORTS void cvCreateTracks_One(CvBlobTrackSeq *TS);
 841 CV_EXPORTS void cvCreateTracks_Same(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2);
 842 CV_EXPORTS void cvCreateTracks_AreaErr(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2, int addW, int addH);
 843
 844
 845 /* HIST API */
 846 class CV_EXPORTS CvProb
 847 {
 848 public:
 849     virtual ~CvProb() {};
 850
 851     /* Calculate probability value: */
 852     virtual double Value(int* /*comp*/, int /*x*/ = 0, int /*y*/ = 0){return -1;};
 853
 854     /* Update histograpp Pnew = (1-W)*Pold + W*Padd*/
 855     /* W weight of new added prob */
 856     /* comps - matrix of new fetature vectors used to update prob */
 857     virtual void AddFeature(float W, int* comps, int x =0, int y = 0) = 0;
 858     virtual void Scale(float factor = 0, int x = -1, int y = -1) = 0;
 859     virtual void Release() = 0;
 860 };
 861 inline void cvReleaseProb(CvProb** ppProb){ppProb[0]->Release();ppProb[0]=NULL;}
 862 /* HIST API */
 863
 864 /* Some Prob: */
 865 CV_EXPORTS CvProb* cvCreateProbS(int dim, CvSize size, int sample_num);
 866 CV_EXPORTS CvProb* cvCreateProbMG(int dim, CvSize size, int sample_num);
 867 CV_EXPORTS CvProb* cvCreateProbMG2(int dim, CvSize size, int sample_num);
 868 CV_EXPORTS CvProb* cvCreateProbHist(int dim, CvSize size);
 869
 870 #define CV_BT_HIST_TYPE_S     0
 871 #define CV_BT_HIST_TYPE_MG    1
 872 #define CV_BT_HIST_TYPE_MG2   2
 873 #define CV_BT_HIST_TYPE_H     3
 874 inline CvProb* cvCreateProb(int type, int dim, CvSize size = cvSize(1,1), void* /*param*/ = NULL)
 875 {
 876     if(type == CV_BT_HIST_TYPE_S) return cvCreateProbS(dim, size, -1);
 877     if(type == CV_BT_HIST_TYPE_MG) return cvCreateProbMG(dim, size, -1);
 878     if(type == CV_BT_HIST_TYPE_MG2) return cvCreateProbMG2(dim, size, -1);
 879     if(type == CV_BT_HIST_TYPE_H) return cvCreateProbHist(dim, size);
 880     return NULL;
 881 }
 882
 883
 884
 885 /* Noise type definitions: */
 886 #define CV_NOISE_NONE               0
 887 #define CV_NOISE_GAUSSIAN           1
 888 #define CV_NOISE_UNIFORM            2
 889 #define CV_NOISE_SPECKLE            3
 890 #define CV_NOISE_SALT_AND_PEPPER    4
 891
 892 /* Add some noise to image: */
 893 /* pImg - (input) image without noise */
 894 /* pImg - (output) image with noise */
 895 /* noise_type - type of added noise */
 896 /*  CV_NOISE_GAUSSIAN - pImg += n , n - is gaussian noise with Ampl standart deviation */
 897 /*  CV_NOISE_UNIFORM - pImg += n , n - is uniform noise with Ampl standart deviation */
 898 /*  CV_NOISE_SPECKLE - pImg += n*pImg , n - is gaussian noise with Ampl standart deviation */
 899 /*  CV_NOISE_SALT_AND_PAPPER - pImg = pImg with blacked and whited pixels,
 900             Ampl is density of brocken pixels (0-there are not broken pixels, 1 - all pixels are broken)*/
 901 /* Ampl - "amplitude" of noise */
 902 //CV_EXPORTS void cvAddNoise(IplImage* pImg, int noise_type, double Ampl, CvRNG* rnd_state = NULL);
 903
 904 /*================== GENERATOR OF TEST VIDEO SEQUENCE ===================== */
 905 typedef void CvTestSeq;
 906
 907 /* pConfigfile - Name of file (yml or xml) with description of test sequence */
 908 /* videos - array of names of test videos described in "pConfigfile" file */
 909 /* numvideos - size of "videos" array */
 910 CV_EXPORTS CvTestSeq* cvCreateTestSeq(char* pConfigfile, char** videos, int numvideo, float Scale = 1, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
 911 CV_EXPORTS void cvReleaseTestSeq(CvTestSeq** ppTestSeq);
 912
 913 /* Generate next frame from test video seq and return pointer to it: */
 914 CV_EXPORTS IplImage* cvTestSeqQueryFrame(CvTestSeq* pTestSeq);
 915
 916 /* Return pointer to current foreground mask: */
 917 CV_EXPORTS IplImage* cvTestSeqGetFGMask(CvTestSeq* pTestSeq);
 918
 919 /* Return pointer to current image: */
 920 CV_EXPORTS IplImage* cvTestSeqGetImage(CvTestSeq* pTestSeq);
 921
 922 /* Return frame size of result test video: */
 923 CV_EXPORTS CvSize cvTestSeqGetImageSize(CvTestSeq* pTestSeq);
 924
 925 /* Return number of frames result test video: */
 926 CV_EXPORTS int cvTestSeqFrameNum(CvTestSeq* pTestSeq);
 927
 928 /* Return number of existing objects.
 929  * This is general number of any objects.
 930  * For example number of trajectories may be equal or less than returned value:
 931  */
 932 CV_EXPORTS int cvTestSeqGetObjectNum(CvTestSeq* pTestSeq);
 933
 934 /* Return 0 if there is not position for current defined on current frame */
 935 /* Return 1 if there is object position and pPos was filled */
 936 CV_EXPORTS int cvTestSeqGetObjectPos(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pPos);
 937 CV_EXPORTS int cvTestSeqGetObjectSize(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pSize);
 938
 939 /* Add noise to final image: */
 940 CV_EXPORTS void cvTestSeqAddNoise(CvTestSeq* pTestSeq, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
 941
 942 /* Add Intensity variation: */
 943 CV_EXPORTS void cvTestSeqAddIntensityVariation(CvTestSeq* pTestSeq, float DI_per_frame, float MinI, float MaxI);
 944 CV_EXPORTS void cvTestSeqSetFrame(CvTestSeq* pTestSeq, int n);
 945
 946 #endif
 947
 948 /* End of file. */