opencv 2.2.0
/usr/src/RPM/BUILD/libopencv2.2-2.2.0/modules/legacy/include/opencv2/legacy/blobtrack.hpp
Go to the documentation of this file.
00001 /*M///////////////////////////////////////////////////////////////////////////////////////
00002 //
00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
00004 //
00005 //  By downloading, copying, installing or using the software you agree to this license.
00006 //  If you do not agree to this license, do not download, install,
00007 //  copy or use the software.
00008 //
00009 //
00010 //                        Intel License Agreement
00011 //                For Open Source Computer Vision Library
00012 //
00013 // Copyright (C) 2000, Intel Corporation, all rights reserved.
00014 // Third party copyrights are property of their respective owners.
00015 //
00016 // Redistribution and use in source and binary forms, with or without modification,
00017 // are permitted provided that the following conditions are met:
00018 //
00019 //   * Redistribution's of source code must retain the above copyright notice,
00020 //     this list of conditions and the following disclaimer.
00021 //
00022 //   * Redistribution's in binary form must reproduce the above copyright notice,
00023 //     this list of conditions and the following disclaimer in the documentation
00024 //     and/or other materials provided with the distribution.
00025 //
00026 //   * The name of Intel Corporation may not be used to endorse or promote products
00027 //     derived from this software without specific prior written permission.
00028 //
00029 // This software is provided by the copyright holders and contributors "as is" and
00030 // any express or implied warranties, including, but not limited to, the implied
00031 // warranties of merchantability and fitness for a particular purpose are disclaimed.
00032 // In no event shall the Intel Corporation or contributors be liable for any direct,
00033 // indirect, incidental, special, exemplary, or consequential damages
00034 // (including, but not limited to, procurement of substitute goods or services;
00035 // loss of use, data, or profits; or business interruption) however caused
00036 // and on any theory of liability, whether in contract, strict liability,
00037 // or tort (including negligence or otherwise) arising in any way out of
00038 // the use of this software, even if advised of the possibility of such damage.
00039 //
00040 //M*/
00041 
00042 
00043 #ifndef __OPENCV_VIDEOSURVEILLANCE_H__
00044 #define __OPENCV_VIDEOSURVEILLANCE_H__
00045 
00046 /* Turn off the functionality until cvaux/src/Makefile.am gets updated: */
00047 //#if _MSC_VER >= 1200
00048 
00049 #include "opencv2/core/core_c.h"
00050 #include <stdio.h>
00051 
00052 #if _MSC_VER >= 1200 || defined __BORLANDC__
00053 #define cv_stricmp stricmp
00054 #define cv_strnicmp strnicmp
00055 #if defined WINCE
00056 #define strdup _strdup
00057 #define stricmp _stricmp
00058 #endif
00059 #elif defined __GNUC__
00060 #define cv_stricmp strcasecmp
00061 #define cv_strnicmp strncasecmp
00062 #else
00063 #error Do not know how to make case-insensitive string comparison on this platform
00064 #endif
00065 
00066 //struct DefParam;
00067 struct CvDefParam
00068 {
00069     struct CvDefParam*    next;
00070     char*               pName;
00071     char*               pComment;
00072     double*             pDouble;
00073     double              Double;
00074     float*              pFloat;
00075     float               Float;
00076     int*                pInt;
00077     int                 Int;
00078     char**              pStr;
00079     char*               Str;
00080 };
00081 
00082 class CV_EXPORTS CvVSModule
00083 {
00084 private: /* Internal data: */
00085     CvDefParam*   m_pParamList;
00086     char*       m_pModuleTypeName;
00087     char*       m_pModuleName;
00088     char*       m_pNickName;
00089 protected:
00090     int         m_Wnd;
00091 public: /* Constructor and destructor: */
00092     CvVSModule();
00093     virtual ~CvVSModule();
00094 private: /* Internal functions: */
00095     void    FreeParam(CvDefParam** pp);
00096     CvDefParam* NewParam(const char* name);
00097     CvDefParam* GetParamPtr(int index);
00098     CvDefParam* GetParamPtr(const char* name);
00099 protected: /* INTERNAL INTERFACE */
00100     int  IsParam(const char* name);
00101     void AddParam(const char* name, double* pAddr);
00102     void AddParam(const char* name, float* pAddr);
00103     void AddParam(const char* name, int* pAddr);
00104     void AddParam(const char* name, const char** pAddr);
00105     void AddParam(const char* name);
00106     void CommentParam(const char* name, const char* pComment);
00107     void SetTypeName(const char* name);
00108     void SetModuleName(const char* name);
00109     void DelParam(const char* name);
00110 
00111 public: /* EXTERNAL INTERFACE */
00112     const char* GetParamName(int index);
00113     const char* GetParamComment(const char* name);
00114     double GetParam(const char* name);
00115     const char* GetParamStr(const char* name);
00116     void   SetParam(const char* name, double val);
00117     void   SetParamStr(const char* name, const char* str);
00118     void TransferParamsFromChild(CvVSModule* pM, const char* prefix = NULL);
00119     void TransferParamsToChild(CvVSModule* pM, char* prefix = NULL);
00120     virtual void ParamUpdate();
00121     const char*   GetTypeName();
00122     int     IsModuleTypeName(const char* name);
00123     char*   GetModuleName();
00124     int     IsModuleName(const char* name);
00125     void SetNickName(const char* pStr);
00126     const char* GetNickName();
00127     virtual void SaveState(CvFileStorage*);
00128     virtual void LoadState(CvFileStorage*, CvFileNode*);
00129 
00130     virtual void Release() = 0;
00131 };/* CvVMModule */
00132 
00133 CV_EXPORTS void cvWriteStruct(CvFileStorage* fs, const char* name, void* addr, const char* desc, int num=1);
00134 CV_EXPORTS void cvReadStructByName(CvFileStorage* fs, CvFileNode* node, const char* name, void* addr, const char* desc);
00135 
00136 /* FOREGROUND DETECTOR INTERFACE */
00137 class CV_EXPORTS CvFGDetector : public CvVSModule
00138 {
00139 public:
00140     CvFGDetector();
00141     virtual IplImage* GetMask() = 0;
00142     /* Process current image: */
00143     virtual void    Process(IplImage* pImg) = 0;
00144     /* Release foreground detector: */
00145     virtual void    Release() = 0;
00146 };
00147 
00148 CV_EXPORTS void cvReleaseFGDetector(CvFGDetector** ppT );
00149 CV_EXPORTS CvFGDetector* cvCreateFGDetectorBase(int type, void *param);
00150 
00151 
00152 /* BLOB STRUCTURE*/
00153 struct CvBlob
00154 {
00155     float   x,y; /* blob position   */
00156     float   w,h; /* blob sizes      */
00157     int     ID;  /* blob ID         */
00158 };
00159 
00160 inline CvBlob cvBlob(float x,float y, float w, float h)
00161 {
00162     CvBlob B = {x,y,w,h,0};
00163     return B;
00164 }
00165 #define CV_BLOB_MINW 5
00166 #define CV_BLOB_MINH 5
00167 #define CV_BLOB_ID(pB) (((CvBlob*)(pB))->ID)
00168 #define CV_BLOB_CENTER(pB) cvPoint2D32f(((CvBlob*)(pB))->x,((CvBlob*)(pB))->y)
00169 #define CV_BLOB_X(pB) (((CvBlob*)(pB))->x)
00170 #define CV_BLOB_Y(pB) (((CvBlob*)(pB))->y)
00171 #define CV_BLOB_WX(pB) (((CvBlob*)(pB))->w)
00172 #define CV_BLOB_WY(pB) (((CvBlob*)(pB))->h)
00173 #define CV_BLOB_RX(pB) (0.5f*CV_BLOB_WX(pB))
00174 #define CV_BLOB_RY(pB) (0.5f*CV_BLOB_WY(pB))
00175 #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)))
00176 /* END BLOB STRUCTURE*/
00177 
00178 
00179 /* simple BLOBLIST */
00180 class CV_EXPORTS CvBlobSeq
00181 {
00182 public:
00183     CvBlobSeq(int BlobSize = sizeof(CvBlob))
00184     {
00185         m_pMem = cvCreateMemStorage();
00186         m_pSeq = cvCreateSeq(0,sizeof(CvSeq),BlobSize,m_pMem);
00187         strcpy(m_pElemFormat,"ffffi");
00188     }
00189     virtual ~CvBlobSeq()
00190     {
00191         cvReleaseMemStorage(&m_pMem);
00192     };
00193     virtual CvBlob* GetBlob(int BlobIndex)
00194     {
00195         return (CvBlob*)cvGetSeqElem(m_pSeq,BlobIndex);
00196     };
00197     virtual CvBlob* GetBlobByID(int BlobID)
00198     {
00199         int i;
00200         for(i=0; i<m_pSeq->total; ++i)
00201             if(BlobID == CV_BLOB_ID(GetBlob(i)))
00202                 return GetBlob(i);
00203         return NULL;
00204     };
00205     virtual void DelBlob(int BlobIndex)
00206     {
00207         cvSeqRemove(m_pSeq,BlobIndex);
00208     };
00209     virtual void DelBlobByID(int BlobID)
00210     {
00211         int i;
00212         for(i=0; i<m_pSeq->total; ++i)
00213         {
00214             if(BlobID == CV_BLOB_ID(GetBlob(i)))
00215             {
00216                 DelBlob(i);
00217                 return;
00218             }
00219         }
00220     };
00221     virtual void Clear()
00222     {
00223         cvClearSeq(m_pSeq);
00224     };
00225     virtual void AddBlob(CvBlob* pB)
00226     {
00227         cvSeqPush(m_pSeq,pB);
00228     };
00229     virtual int GetBlobNum()
00230     {
00231         return m_pSeq->total;
00232     };
00233     virtual void Write(CvFileStorage* fs, const char* name)
00234     {
00235         const char*  attr[] = {"dt",m_pElemFormat,NULL};
00236         if(fs)
00237         {
00238             cvWrite(fs,name,m_pSeq,cvAttrList(attr,NULL));
00239         }
00240     }
00241     virtual void Load(CvFileStorage* fs, CvFileNode* node)
00242     {
00243         if(fs==NULL) return;
00244         CvSeq* pSeq = (CvSeq*)cvRead(fs, node);
00245         if(pSeq)
00246         {
00247             int i;
00248             cvClearSeq(m_pSeq);
00249             for(i=0;i<pSeq->total;++i)
00250             {
00251                 void* pB = cvGetSeqElem( pSeq, i );
00252                 cvSeqPush( m_pSeq, pB );
00253             }
00254         }
00255     }
00256     void AddFormat(const char* str){strcat(m_pElemFormat,str);}
00257 protected:
00258     CvMemStorage*   m_pMem;
00259     CvSeq*          m_pSeq;
00260     char            m_pElemFormat[1024];
00261 };
00262 /* simple BLOBLIST */
00263 
00264 
00265 /* simple TRACKLIST */
00266 struct CvBlobTrack
00267 {
00268     int         TrackID;
00269     int         StartFrame;
00270     CvBlobSeq*  pBlobSeq;
00271 };
00272 
00273 class CV_EXPORTS CvBlobTrackSeq
00274 {
00275 public:
00276     CvBlobTrackSeq(int TrackSize = sizeof(CvBlobTrack));
00277     virtual ~CvBlobTrackSeq();
00278     virtual CvBlobTrack* GetBlobTrack(int TrackIndex);
00279     virtual CvBlobTrack* GetBlobTrackByID(int TrackID);
00280     virtual void DelBlobTrack(int TrackIndex);
00281     virtual void DelBlobTrackByID(int TrackID);
00282     virtual void Clear();
00283     virtual void AddBlobTrack(int TrackID, int StartFrame = 0);
00284     virtual int GetBlobTrackNum();
00285 protected:
00286     CvMemStorage*   m_pMem;
00287     CvSeq*          m_pSeq;
00288 };
00289 
00290 /* simple TRACKLIST */
00291 
00292 
00293 /* BLOB DETECTOR INTERFACE */
00294 class CV_EXPORTS CvBlobDetector: public CvVSModule
00295 {
00296 public:
00297         CvBlobDetector(){SetTypeName("BlobDetector");};
00298     /* Try to detect new blob entrance based on foreground mask. */
00299     /* pFGMask - image of foreground mask */
00300     /* pNewBlob - pointer to CvBlob structure which will be filled if new blob entrance detected */
00301     /* pOldBlobList - pointer to blob list which already exist on image */
00302     virtual int DetectNewBlob(IplImage* pImg, IplImage* pImgFG, CvBlobSeq* pNewBlobList, CvBlobSeq* pOldBlobList) = 0;
00303     /* release blob detector */
00304     virtual void Release()=0;
00305 };
00306 
00307 /* Release any blob detector: */
00308 CV_EXPORTS void cvReleaseBlobDetector(CvBlobDetector** ppBD);
00309 
00310 /* Declarations of constructors of implemented modules: */
00311 CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorSimple();
00312 CV_EXPORTS CvBlobDetector* cvCreateBlobDetectorCC();
00313 
00314 struct CV_EXPORTS CvDetectedBlob : public CvBlob
00315 {
00316     float response;
00317 };
00318 
00319 CV_INLINE CvDetectedBlob cvDetectedBlob( float x, float y, float w, float h, int ID = 0, float response = 0.0F )
00320 {
00321     CvDetectedBlob b;
00322     b.x = x; b.y = y; b.w = w; b.h = h; b.ID = ID; b.response = response;
00323     return b;
00324 }
00325 
00326 
00327 class CV_EXPORTS CvObjectDetector
00328 {
00329 public:
00330     CvObjectDetector( const char* /*detector_file_name*/ = 0 );
00331     ~CvObjectDetector();
00332 
00333     /*
00334      * Release the current detector and load new detector from file
00335      * (if detector_file_name is not 0)
00336      * Return true on success:
00337      */
00338     bool Load( const char* /*detector_file_name*/ = 0 );
00339 
00340     /* Return min detector window size: */
00341     CvSize GetMinWindowSize() const;
00342 
00343     /* Return max border: */
00344     int GetMaxBorderSize() const;
00345 
00346     /*
00347      * Detect the object on the image and push the detected
00348      * blobs into <detected_blob_seq> which must be the sequence of <CvDetectedBlob>s
00349      */
00350     void Detect( const CvArr* /*img*/, /* out */ CvBlobSeq* /*detected_blob_seq*/ = 0 );
00351 
00352 protected:
00353     class CvObjectDetectorImpl* impl;
00354 };
00355 
00356 
00357 CV_INLINE CvRect cvRectIntersection( const CvRect r1, const CvRect r2 )
00358 {
00359     CvRect r = cvRect( MAX(r1.x, r2.x), MAX(r1.y, r2.y), 0, 0 );
00360 
00361     r.width  = MIN(r1.x + r1.width, r2.x + r2.width) - r.x;
00362     r.height = MIN(r1.y + r1.height, r2.y + r2.height) - r.y;
00363 
00364     return r;
00365 }
00366 
00367 
00368 /*
00369  * CvImageDrawer
00370  *
00371  * Draw on an image the specified ROIs from the source image and
00372  * given blobs as ellipses or rectangles:
00373  */
00374 
00375 struct CvDrawShape
00376 {
00377     enum {RECT, ELLIPSE} shape;
00378     CvScalar color;
00379 };
00380 
00381 /*extern const CvDrawShape icv_shape[] =
00382 {
00383     { CvDrawShape::ELLIPSE, CV_RGB(255,0,0) },
00384     { CvDrawShape::ELLIPSE, CV_RGB(0,255,0) },
00385     { CvDrawShape::ELLIPSE, CV_RGB(0,0,255) },
00386     { CvDrawShape::ELLIPSE, CV_RGB(255,255,0) },
00387     { CvDrawShape::ELLIPSE, CV_RGB(0,255,255) },
00388     { CvDrawShape::ELLIPSE, CV_RGB(255,0,255) }
00389 };*/
00390 
00391 class CV_EXPORTS CvImageDrawer
00392 {
00393 public:
00394     CvImageDrawer() : m_image(0) {}
00395     ~CvImageDrawer() { cvReleaseImage( &m_image ); }
00396     void SetShapes( const CvDrawShape* shapes, int num );
00397     /* <blob_seq> must be the sequence of <CvDetectedBlob>s */
00398     IplImage* Draw( const CvArr* src, CvBlobSeq* blob_seq = 0, const CvSeq* roi_seq = 0 );
00399     IplImage* GetImage() { return m_image; }
00400 protected:
00401     //static const int MAX_SHAPES = sizeof(icv_shape) / sizeof(icv_shape[0]);;
00402 
00403     IplImage* m_image;
00404     CvDrawShape m_shape[16];
00405 };
00406 
00407 
00408 
00409 /* Trajectory generation module: */
00410 class CV_EXPORTS CvBlobTrackGen: public CvVSModule
00411 {
00412 public:
00413         CvBlobTrackGen(){SetTypeName("BlobTrackGen");};
00414     virtual void    SetFileName(char* pFileName) = 0;
00415     virtual void    AddBlob(CvBlob* pBlob) = 0;
00416     virtual void    Process(IplImage* pImg = NULL, IplImage* pFG = NULL) = 0;
00417     virtual void    Release() = 0;
00418 };
00419 
00420 inline void cvReleaseBlobTrackGen(CvBlobTrackGen** pBTGen)
00421 {
00422     if(*pBTGen)(*pBTGen)->Release();
00423     *pBTGen = 0;
00424 }
00425 
00426 /* Declarations of constructors of implemented modules: */
00427 CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGen1();
00428 CV_EXPORTS CvBlobTrackGen* cvCreateModuleBlobTrackGenYML();
00429 
00430 
00431 
00432 /* BLOB TRACKER INTERFACE */
00433 class CV_EXPORTS CvBlobTracker: public CvVSModule
00434 {
00435 public:
00436     CvBlobTracker();
00437 
00438     /* Add new blob to track it and assign to this blob personal ID */
00439     /* pBlob - pointer to structure with blob parameters (ID is ignored)*/
00440     /* pImg - current image */
00441     /* pImgFG - current foreground mask */
00442     /* Return pointer to new added blob: */
00443     virtual CvBlob* AddBlob(CvBlob* pBlob, IplImage* pImg, IplImage* pImgFG = NULL ) = 0;
00444 
00445     /* Return number of currently tracked blobs: */
00446     virtual int     GetBlobNum() = 0;
00447 
00448     /* Return pointer to specified by index blob: */
00449     virtual CvBlob* GetBlob(int BlobIndex) = 0;
00450 
00451     /* Delete blob by its index: */
00452     virtual void    DelBlob(int BlobIndex) = 0;
00453 
00454     /* Process current image and track all existed blobs: */
00455     virtual void    Process(IplImage* pImg, IplImage* pImgFG = NULL) = 0;
00456 
00457     /* Release blob tracker: */
00458     virtual void    Release() = 0;
00459 
00460 
00461     /* Process one blob (for multi hypothesis tracing): */
00462     virtual void ProcessBlob(int BlobIndex, CvBlob* pBlob, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
00463 
00464     /* Get confidence/wieght/probability (0-1) for blob: */
00465     virtual double  GetConfidence(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
00466 
00467     virtual double GetConfidenceList(CvBlobSeq* pBlobList, IplImage* pImg, IplImage* pImgFG = NULL);
00468 
00469     virtual void UpdateBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL);
00470 
00471     /* Update all blob models: */
00472     virtual void Update(IplImage* pImg, IplImage* pImgFG = NULL);
00473 
00474     /* Return pointer to blob by its unique ID: */
00475     virtual int     GetBlobIndexByID(int BlobID);
00476 
00477     /* Return pointer to blob by its unique ID: */
00478     virtual CvBlob* GetBlobByID(int BlobID);
00479 
00480     /* Delete blob by its ID: */
00481     virtual void    DelBlobByID(int BlobID);
00482 
00483     /* Set new parameters for specified (by index) blob: */
00484     virtual void    SetBlob(int /*BlobIndex*/, CvBlob* /*pBlob*/);
00485 
00486     /* Set new parameters for specified (by ID) blob: */
00487     virtual void    SetBlobByID(int BlobID, CvBlob* pBlob);
00488 
00489     /*  ===============  MULTI HYPOTHESIS INTERFACE ==================  */
00490 
00491     /* Return number of position hyposetis of currently tracked blob: */
00492     virtual int     GetBlobHypNum(int /*BlobIdx*/);
00493 
00494     /* Return pointer to specified blob hypothesis by index blob: */
00495     virtual CvBlob* GetBlobHyp(int BlobIndex, int /*hypothesis*/);
00496 
00497     /* Set new parameters for specified (by index) blob hyp
00498      * (can be called several times for each hyp ):
00499      */
00500     virtual void    SetBlobHyp(int /*BlobIndex*/, CvBlob* /*pBlob*/);
00501 };
00502 
00503 CV_EXPORTS void cvReleaseBlobTracker(CvBlobTracker**ppT );
00504 /* BLOB TRACKER INTERFACE */
00505 
00506 /*BLOB TRACKER ONE INTERFACE */
00507 class CV_EXPORTS CvBlobTrackerOne : public CvVSModule
00508 {
00509 public:
00510     virtual void Init(CvBlob* pBlobInit, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
00511     virtual CvBlob* Process(CvBlob* pBlobPrev, IplImage* pImg, IplImage* pImgFG = NULL) = 0;
00512     virtual void Release() =  0;
00513 
00514     /* Non-required methods: */
00515     virtual void SkipProcess(CvBlob* /*pBlobPrev*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
00516     virtual void Update(CvBlob* /*pBlob*/, IplImage* /*pImg*/, IplImage* /*pImgFG*/ = NULL){};
00517     virtual void SetCollision(int /*CollisionFlag*/){}; /* call in case of blob collision situation*/
00518     virtual double GetConfidence(CvBlob* /*pBlob*/, IplImage* /*pImg*/,
00519                                  IplImage* /*pImgFG*/ = NULL, IplImage* /*pImgUnusedReg*/ = NULL)
00520     {
00521         return 1;
00522     };
00523 };
00524 inline void cvReleaseBlobTrackerOne(CvBlobTrackerOne **ppT )
00525 {
00526     ppT[0]->Release();
00527     ppT[0] = 0;
00528 }
00529 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerList(CvBlobTrackerOne* (*create)());
00530 /*BLOB TRACKER ONE INTERFACE */
00531 
00532 /* Declarations of constructors of implemented modules: */
00533 
00534 /* Some declarations for specific MeanShift tracker: */
00535 #define PROFILE_EPANECHNIKOV    0
00536 #define PROFILE_DOG             1
00537 struct CvBlobTrackerParamMS
00538 {
00539     int     noOfSigBits;
00540     int     appearance_profile;
00541     int     meanshift_profile;
00542     float   sigma;
00543 };
00544 
00545 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1(CvBlobTrackerParamMS* param);
00546 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS2(CvBlobTrackerParamMS* param);
00547 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS1ByList();
00548 
00549 /* Some declarations for specific Likelihood tracker: */
00550 struct CvBlobTrackerParamLH
00551 {
00552     int     HistType; /* see Prob.h */
00553     int     ScaleAfter;
00554 };
00555 
00556 /* Without scale optimization: */
00557 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHR(CvBlobTrackerParamLH* /*param*/ = NULL);
00558 
00559 /* With scale optimization: */
00560 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerLHRS(CvBlobTrackerParamLH* /*param*/ = NULL);
00561 
00562 /* Simple blob tracker based on connected component tracking: */
00563 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCC();
00564 
00565 /* Connected component tracking and mean-shift particle filter collion-resolver: */
00566 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerCCMSPF();
00567 
00568 /* Blob tracker that integrates meanshift and connected components: */
00569 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFG();
00570 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSFGS();
00571 
00572 /* Meanshift without connected-components */
00573 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMS();
00574 
00575 /* Particle filtering via Bhattacharya coefficient, which        */
00576 /* is roughly the dot-product of two probability densities.      */
00577 /* See: Real-Time Tracking of Non-Rigid Objects using Mean Shift */
00578 /*      Comanicius, Ramesh, Meer, 2000, 8p                       */
00579 /*      http://citeseer.ist.psu.edu/321441.html                  */
00580 CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerMSPF();
00581 
00582 /* =========== tracker integrators trackers =============*/
00583 
00584 /* Integrator based on Particle Filtering method: */
00585 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPF();
00586 
00587 /* Rule based integrator: */
00588 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIRB();
00589 
00590 /* Integrator based on data fusion using particle filtering: */
00591 //CV_EXPORTS CvBlobTracker* cvCreateBlobTrackerIPFDF();
00592 
00593 
00594 
00595 
00596 /* Trajectory postprocessing module: */
00597 class CV_EXPORTS CvBlobTrackPostProc: public CvVSModule
00598 {
00599 public:
00600         CvBlobTrackPostProc(){SetTypeName("BlobTrackPostProc");};
00601     virtual void    AddBlob(CvBlob* pBlob) = 0;
00602     virtual void    Process() = 0;
00603     virtual int     GetBlobNum() = 0;
00604     virtual CvBlob* GetBlob(int index) = 0;
00605     virtual void    Release() = 0;
00606 
00607     /* Additional functionality: */
00608     virtual CvBlob* GetBlobByID(int BlobID)
00609     {
00610         int i;
00611         for(i=GetBlobNum();i>0;i--)
00612         {
00613             CvBlob* pB=GetBlob(i-1);
00614             if(pB->ID==BlobID) return pB;
00615         }
00616         return NULL;
00617     };
00618 };
00619 
00620 inline void cvReleaseBlobTrackPostProc(CvBlobTrackPostProc** pBTPP)
00621 {
00622     if(pBTPP == NULL) return;
00623     if(*pBTPP)(*pBTPP)->Release();
00624     *pBTPP = 0;
00625 }
00626 
00627 /* Trajectory generation module: */
00628 class CV_EXPORTS CvBlobTrackPostProcOne: public CvVSModule
00629 {
00630 public:
00631         CvBlobTrackPostProcOne(){SetTypeName("BlobTrackPostOne");};
00632     virtual CvBlob* Process(CvBlob* pBlob) = 0;
00633     virtual void    Release() = 0;
00634 };
00635 
00636 /* Create blob tracking post processing module based on simle module: */
00637 CV_EXPORTS CvBlobTrackPostProc* cvCreateBlobTrackPostProcList(CvBlobTrackPostProcOne* (*create)());
00638 
00639 
00640 /* Declarations of constructors of implemented modules: */
00641 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcKalman();
00642 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverRect();
00643 CV_EXPORTS CvBlobTrackPostProc* cvCreateModuleBlobTrackPostProcTimeAverExp();
00644 
00645 
00646 /* PREDICTORS */
00647 /* blob PREDICTOR */
00648 class CvBlobTrackPredictor: public CvVSModule
00649 {
00650 public:
00651         CvBlobTrackPredictor(){SetTypeName("BlobTrackPredictor");};
00652     virtual CvBlob* Predict() = 0;
00653     virtual void    Update(CvBlob* pBlob) = 0;
00654     virtual void    Release() = 0;
00655 };
00656 CV_EXPORTS CvBlobTrackPredictor* cvCreateModuleBlobTrackPredictKalman();
00657 
00658 
00659 
00660 /* Trajectory analyser module: */
00661 class CV_EXPORTS CvBlobTrackAnalysis: public CvVSModule
00662 {
00663 public:
00664         CvBlobTrackAnalysis(){SetTypeName("BlobTrackAnalysis");};
00665     virtual void    AddBlob(CvBlob* pBlob) = 0;
00666     virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
00667     virtual float   GetState(int BlobID) = 0;
00668     /* return 0 if trajectory is normal
00669        return >0 if trajectory abnormal */
00670     virtual const char*   GetStateDesc(int /*BlobID*/){return NULL;};
00671     virtual void    SetFileName(char* /*DataBaseName*/){};
00672     virtual void    Release() = 0;
00673 };
00674 
00675 
00676 inline void cvReleaseBlobTrackAnalysis(CvBlobTrackAnalysis** pBTPP)
00677 {
00678     if(pBTPP == NULL) return;
00679     if(*pBTPP)(*pBTPP)->Release();
00680     *pBTPP = 0;
00681 }
00682 
00683 /* Feature-vector generation module: */
00684 class CV_EXPORTS CvBlobTrackFVGen : public CvVSModule
00685 {
00686 public:
00687         CvBlobTrackFVGen(){SetTypeName("BlobTrackFVGen");};
00688     virtual void    AddBlob(CvBlob* pBlob) = 0;
00689     virtual void    Process(IplImage* pImg, IplImage* pFG) = 0;
00690     virtual void    Release() = 0;
00691     virtual int     GetFVSize() = 0;
00692     virtual int     GetFVNum() = 0;
00693     virtual float*  GetFV(int index, int* pFVID) = 0; /* Returns pointer to FV, if return 0 then FV not created */
00694     virtual float*  GetFVVar(){return NULL;}; /* Returns pointer to array of variation of values of FV, if returns 0 then FVVar does not exist. */
00695     virtual float*  GetFVMin() = 0; /* Returns pointer to array of minimal values of FV, if returns 0 then FVrange does not exist */
00696     virtual float*  GetFVMax() = 0; /* Returns pointer to array of maximal values of FV, if returns 0 then FVrange does not exist */
00697 };
00698 
00699 
00700 /* Trajectory Analyser module: */
00701 class CV_EXPORTS CvBlobTrackAnalysisOne
00702 {
00703 public:
00704     virtual ~CvBlobTrackAnalysisOne() {};
00705     virtual int     Process(CvBlob* pBlob, IplImage* pImg, IplImage* pFG) = 0;
00706     /* return 0 if trajectory is normal
00707        return >0 if trajectory abnormal */
00708     virtual void    Release() = 0;
00709 };
00710 
00711 /* Create blob tracking post processing module based on simle module: */
00712 CV_EXPORTS CvBlobTrackAnalysis* cvCreateBlobTrackAnalysisList(CvBlobTrackAnalysisOne* (*create)());
00713 
00714 /* Declarations of constructors of implemented modules: */
00715 
00716 /* Based on histogram analysis of 2D FV (x,y): */
00717 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistP();
00718 
00719 /* Based on histogram analysis of 4D FV (x,y,vx,vy): */
00720 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPV();
00721 
00722 /* Based on histogram analysis of 5D FV (x,y,vx,vy,state): */
00723 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPVS();
00724 
00725 /* Based on histogram analysis of 4D FV (startpos,stoppos): */
00726 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistSS();
00727 
00728 
00729 
00730 /* Based on SVM classifier analysis of 2D FV (x,y): */
00731 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMP();
00732 
00733 /* Based on SVM classifier analysis of 4D FV (x,y,vx,vy): */
00734 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPV();
00735 
00736 /* Based on SVM classifier analysis of 5D FV (x,y,vx,vy,state): */
00737 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPVS();
00738 
00739 /* Based on SVM classifier analysis of 4D FV (startpos,stoppos): */
00740 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMSS();
00741 
00742 /* Track analysis based on distance between tracks: */
00743 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisTrackDist();
00744 
00745 /* Analyzer based on reation Road and height map: */
00746 //CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysis3DRoadMap();
00747 
00748 /* Analyzer that makes OR decision using set of analyzers: */
00749 CV_EXPORTS CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisIOR();
00750 
00751 /* Estimator of human height: */
00752 class CV_EXPORTS CvBlobTrackAnalysisHeight: public CvBlobTrackAnalysis
00753 {
00754 public:
00755     virtual double  GetHeight(CvBlob* pB) = 0;
00756 };
00757 //CV_EXPORTS CvBlobTrackAnalysisHeight* cvCreateModuleBlobTrackAnalysisHeightScale();
00758 
00759 
00760 
00761 /* AUTO BLOB TRACKER INTERFACE -- pipeline of 3 modules: */
00762 class CV_EXPORTS CvBlobTrackerAuto: public CvVSModule
00763 {
00764 public:
00765         CvBlobTrackerAuto(){SetTypeName("BlobTrackerAuto");};
00766     virtual void        Process(IplImage* pImg, IplImage* pMask = NULL) = 0;
00767     virtual CvBlob*     GetBlob(int index) = 0;
00768     virtual CvBlob*     GetBlobByID(int ID) = 0;
00769     virtual int         GetBlobNum() = 0;
00770     virtual IplImage*   GetFGMask(){return NULL;};
00771     virtual float       GetState(int BlobID) = 0;
00772     virtual const char*       GetStateDesc(int BlobID) = 0;
00773     /* return 0 if trajectory is normal;
00774      * return >0 if trajectory abnormal. */
00775     virtual void    Release() = 0;
00776 };
00777 inline void cvReleaseBlobTrackerAuto(CvBlobTrackerAuto** ppT)
00778 {
00779     ppT[0]->Release();
00780     ppT[0] = 0;
00781 }
00782 /* END AUTO BLOB TRACKER INTERFACE */
00783 
00784 
00785 /* Constructor functions and data for specific BlobTRackerAuto modules: */
00786 
00787 /* Parameters of blobtracker auto ver1: */
00788 struct CvBlobTrackerAutoParam1
00789 {
00790     int                     FGTrainFrames; /* Number of frames needed for FG (foreground) detector to train.        */
00791 
00792     CvFGDetector*           pFG;           /* FGDetector module. If this field is NULL the Process FG mask is used. */
00793 
00794     CvBlobDetector*         pBD;           /* Selected blob detector module.                                        */
00795                                            /* If this field is NULL default blobdetector module will be created.    */
00796 
00797     CvBlobTracker*          pBT;           /* Selected blob tracking module.                                        */
00798                                            /* If this field is NULL default blobtracker module will be created.     */
00799 
00800     CvBlobTrackGen*         pBTGen;        /* Selected blob trajectory generator.                                   */
00801                                            /* If this field is NULL no generator is used.                           */
00802 
00803     CvBlobTrackPostProc*    pBTPP;         /* Selected blob trajectory postprocessing module.                       */
00804                                            /* If this field is NULL no postprocessing is done.                      */
00805 
00806     int                     UsePPData;
00807 
00808     CvBlobTrackAnalysis*    pBTA;          /* Selected blob trajectory analysis module.                             */
00809                                            /* If this field is NULL no track analysis is done.                      */
00810 };
00811 
00812 /* Create blob tracker auto ver1: */
00813 CV_EXPORTS CvBlobTrackerAuto* cvCreateBlobTrackerAuto1(CvBlobTrackerAutoParam1* param = NULL);
00814 
00815 /* Simple loader for many auto trackers by its type : */
00816 inline CvBlobTrackerAuto* cvCreateBlobTrackerAuto(int type, void* param)
00817 {
00818     if(type == 0) return cvCreateBlobTrackerAuto1((CvBlobTrackerAutoParam1*)param);
00819     return 0;
00820 }
00821 
00822 
00823 
00824 struct CvTracksTimePos
00825 {
00826     int len1,len2;
00827     int beg1,beg2;
00828     int end1,end2;
00829     int comLen; //common length for two tracks
00830     int shift1,shift2;
00831 };
00832 
00833 /*CV_EXPORTS int cvCompareTracks( CvBlobTrackSeq *groundTruth,
00834                    CvBlobTrackSeq *result,
00835                    FILE *file);*/
00836 
00837 
00838 /* Constructor functions:  */
00839 
00840 CV_EXPORTS void cvCreateTracks_One(CvBlobTrackSeq *TS);
00841 CV_EXPORTS void cvCreateTracks_Same(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2);
00842 CV_EXPORTS void cvCreateTracks_AreaErr(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2, int addW, int addH);
00843 
00844 
00845 /* HIST API */
00846 class CV_EXPORTS CvProb
00847 {
00848 public:
00849     virtual ~CvProb() {};
00850 
00851     /* Calculate probability value: */
00852     virtual double Value(int* /*comp*/, int /*x*/ = 0, int /*y*/ = 0){return -1;};
00853 
00854     /* Update histograpp Pnew = (1-W)*Pold + W*Padd*/
00855     /* W weight of new added prob */
00856     /* comps - matrix of new fetature vectors used to update prob */
00857     virtual void AddFeature(float W, int* comps, int x =0, int y = 0) = 0;
00858     virtual void Scale(float factor = 0, int x = -1, int y = -1) = 0;
00859     virtual void Release() = 0;
00860 };
00861 inline void cvReleaseProb(CvProb** ppProb){ppProb[0]->Release();ppProb[0]=NULL;}
00862 /* HIST API */
00863 
00864 /* Some Prob: */
00865 CV_EXPORTS CvProb* cvCreateProbS(int dim, CvSize size, int sample_num);
00866 CV_EXPORTS CvProb* cvCreateProbMG(int dim, CvSize size, int sample_num);
00867 CV_EXPORTS CvProb* cvCreateProbMG2(int dim, CvSize size, int sample_num);
00868 CV_EXPORTS CvProb* cvCreateProbHist(int dim, CvSize size);
00869 
00870 #define CV_BT_HIST_TYPE_S     0
00871 #define CV_BT_HIST_TYPE_MG    1
00872 #define CV_BT_HIST_TYPE_MG2   2
00873 #define CV_BT_HIST_TYPE_H     3
00874 inline CvProb* cvCreateProb(int type, int dim, CvSize size = cvSize(1,1), void* /*param*/ = NULL)
00875 {
00876     if(type == CV_BT_HIST_TYPE_S) return cvCreateProbS(dim, size, -1);
00877     if(type == CV_BT_HIST_TYPE_MG) return cvCreateProbMG(dim, size, -1);
00878     if(type == CV_BT_HIST_TYPE_MG2) return cvCreateProbMG2(dim, size, -1);
00879     if(type == CV_BT_HIST_TYPE_H) return cvCreateProbHist(dim, size);
00880     return NULL;
00881 }
00882 
00883 
00884 
00885 /* Noise type definitions: */
00886 #define CV_NOISE_NONE               0
00887 #define CV_NOISE_GAUSSIAN           1
00888 #define CV_NOISE_UNIFORM            2
00889 #define CV_NOISE_SPECKLE            3
00890 #define CV_NOISE_SALT_AND_PEPPER    4
00891 
00892 /* Add some noise to image: */
00893 /* pImg - (input) image without noise */
00894 /* pImg - (output) image with noise */
00895 /* noise_type - type of added noise */
00896 /*  CV_NOISE_GAUSSIAN - pImg += n , n - is gaussian noise with Ampl standart deviation */
00897 /*  CV_NOISE_UNIFORM - pImg += n , n - is uniform noise with Ampl standart deviation */
00898 /*  CV_NOISE_SPECKLE - pImg += n*pImg , n - is gaussian noise with Ampl standart deviation */
00899 /*  CV_NOISE_SALT_AND_PAPPER - pImg = pImg with blacked and whited pixels,
00900             Ampl is density of brocken pixels (0-there are not broken pixels, 1 - all pixels are broken)*/
00901 /* Ampl - "amplitude" of noise */
00902 //CV_EXPORTS void cvAddNoise(IplImage* pImg, int noise_type, double Ampl, CvRNG* rnd_state = NULL);
00903 
00904 /*================== GENERATOR OF TEST VIDEO SEQUENCE ===================== */
00905 typedef void CvTestSeq;
00906 
00907 /* pConfigfile - Name of file (yml or xml) with description of test sequence */
00908 /* videos - array of names of test videos described in "pConfigfile" file */
00909 /* numvideos - size of "videos" array */
00910 CV_EXPORTS CvTestSeq* cvCreateTestSeq(char* pConfigfile, char** videos, int numvideo, float Scale = 1, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
00911 CV_EXPORTS void cvReleaseTestSeq(CvTestSeq** ppTestSeq);
00912 
00913 /* Generate next frame from test video seq and return pointer to it: */
00914 CV_EXPORTS IplImage* cvTestSeqQueryFrame(CvTestSeq* pTestSeq);
00915 
00916 /* Return pointer to current foreground mask: */
00917 CV_EXPORTS IplImage* cvTestSeqGetFGMask(CvTestSeq* pTestSeq);
00918 
00919 /* Return pointer to current image: */
00920 CV_EXPORTS IplImage* cvTestSeqGetImage(CvTestSeq* pTestSeq);
00921 
00922 /* Return frame size of result test video: */
00923 CV_EXPORTS CvSize cvTestSeqGetImageSize(CvTestSeq* pTestSeq);
00924 
00925 /* Return number of frames result test video: */
00926 CV_EXPORTS int cvTestSeqFrameNum(CvTestSeq* pTestSeq);
00927 
00928 /* Return number of existing objects.
00929  * This is general number of any objects.
00930  * For example number of trajectories may be equal or less than returned value:
00931  */
00932 CV_EXPORTS int cvTestSeqGetObjectNum(CvTestSeq* pTestSeq);
00933 
00934 /* Return 0 if there is not position for current defined on current frame */
00935 /* Return 1 if there is object position and pPos was filled */
00936 CV_EXPORTS int cvTestSeqGetObjectPos(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pPos);
00937 CV_EXPORTS int cvTestSeqGetObjectSize(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pSize);
00938 
00939 /* Add noise to final image: */
00940 CV_EXPORTS void cvTestSeqAddNoise(CvTestSeq* pTestSeq, int noise_type = CV_NOISE_NONE, double noise_ampl = 0);
00941 
00942 /* Add Intensity variation: */
00943 CV_EXPORTS void cvTestSeqAddIntensityVariation(CvTestSeq* pTestSeq, float DI_per_frame, float MinI, float MaxI);
00944 CV_EXPORTS void cvTestSeqSetFrame(CvTestSeq* pTestSeq, int n);
00945 
00946 #endif
00947 
00948 /* End of file. */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines