samples/c/blobtrack_sample.cpp

   1 #include "opencv2/video/background_segm.hpp"
   2 #include "opencv2/legacy/blobtrack.hpp"
   3 #include "opencv2/highgui/highgui.hpp"
   4 #include <opencv2/imgproc/imgproc_c.h>
   5
   6 #include <stdio.h>
   7
   8 /* Select appropriate case insensitive string comparison function: */
   9 #if defined WIN32 || defined _MSC_VER
  10   #define MY_STRNICMP strnicmp
  11   #define MY_STRICMP stricmp
  12 #else
  13   #define MY_STRNICMP strncasecmp
  14   #define MY_STRICMP strcasecmp
  15 #endif
  16
  17 /* List of foreground (FG) DETECTION modules: */
  18 static CvFGDetector* cvCreateFGDetector0      () { return cvCreateFGDetectorBase(CV_BG_MODEL_FGD,        NULL); }
  19 static CvFGDetector* cvCreateFGDetector0Simple() { return cvCreateFGDetectorBase(CV_BG_MODEL_FGD_SIMPLE, NULL); }
  20 static CvFGDetector* cvCreateFGDetector1      () { return cvCreateFGDetectorBase(CV_BG_MODEL_MOG,        NULL); }
  21
  22 typedef struct DefModule_FGDetector
  23 {
  24     CvFGDetector* (*create)();
  25     const char* nickname;
  26     const char* description;
  27 } DefModule_FGDetector;
  28
  29 DefModule_FGDetector FGDetector_Modules[] =
  30 {
  31     {cvCreateFGDetector0,"FG_0","Foreground Object Detection from Videos Containing Complex Background. ACM MM2003."},
  32     {cvCreateFGDetector0Simple,"FG_0S","Simplified version of FG_0"},
  33     {cvCreateFGDetector1,"FG_1","Adaptive background mixture models for real-time tracking. CVPR1999"},
  34     {NULL,NULL,NULL}
  35 };
  36
  37 /* List of BLOB DETECTION modules: */
  38 typedef struct DefModule_BlobDetector
  39 {
  40     CvBlobDetector* (*create)();
  41     const char* nickname;
  42     const char* description;
  43 } DefModule_BlobDetector;
  44
  45 DefModule_BlobDetector BlobDetector_Modules[] =
  46 {
  47     {cvCreateBlobDetectorCC,"BD_CC","Detect new blob by tracking CC of FG mask"},
  48     {cvCreateBlobDetectorSimple,"BD_Simple","Detect new blob by uniform moving of connected components of FG mask"},
  49     {NULL,NULL,NULL}
  50 };
  51
  52 /* List of BLOB TRACKING modules: */
  53 typedef struct DefModule_BlobTracker
  54 {
  55     CvBlobTracker* (*create)();
  56     const char* nickname;
  57     const char* description;
  58 } DefModule_BlobTracker;
  59
  60 DefModule_BlobTracker BlobTracker_Modules[] =
  61 {
  62     {cvCreateBlobTrackerCCMSPF,"CCMSPF","connected component tracking and MSPF resolver for collision"},
  63     {cvCreateBlobTrackerCC,"CC","Simple connected component tracking"},
  64     {cvCreateBlobTrackerMS,"MS","Mean shift algorithm "},
  65     {cvCreateBlobTrackerMSFG,"MSFG","Mean shift algorithm with FG mask using"},
  66     {cvCreateBlobTrackerMSPF,"MSPF","Particle filtering based on MS weight"},
  67     {NULL,NULL,NULL}
  68 };
  69
  70 /* List of BLOB TRAJECTORY GENERATION modules: */
  71 typedef struct DefModule_BlobTrackGen
  72 {
  73     CvBlobTrackGen* (*create)();
  74     const char* nickname;
  75     const char* description;
  76 } DefModule_BlobTrackGen;
  77
  78 DefModule_BlobTrackGen BlobTrackGen_Modules[] =
  79 {
  80     {cvCreateModuleBlobTrackGenYML,"YML","Generate track record in YML format as synthetic video data"},
  81     {cvCreateModuleBlobTrackGen1,"RawTracks","Generate raw track record (x,y,sx,sy),()... in each line"},
  82     {NULL,NULL,NULL}
  83 };
  84
  85 /* List of BLOB TRAJECTORY POST PROCESSING modules: */
  86 typedef struct DefModule_BlobTrackPostProc
  87 {
  88     CvBlobTrackPostProc* (*create)();
  89     const char* nickname;
  90     const char* description;
  91 } DefModule_BlobTrackPostProc;
  92
  93 DefModule_BlobTrackPostProc BlobTrackPostProc_Modules[] =
  94 {
  95     {cvCreateModuleBlobTrackPostProcKalman,"Kalman","Kalman filtering of blob position and size"},
  96     {NULL,"None","No post processing filter"},
  97 //    {cvCreateModuleBlobTrackPostProcTimeAverRect,"TimeAverRect","Average by time using rectangle window"},
  98 //    {cvCreateModuleBlobTrackPostProcTimeAverExp,"TimeAverExp","Average by time using exponential window"},
  99     {NULL,NULL,NULL}
 100 };
 101
 102 /* List of BLOB TRAJECTORY ANALYSIS modules: */
 103 CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisDetector();
 104
 105 typedef struct DefModule_BlobTrackAnalysis
 106 {
 107     CvBlobTrackAnalysis* (*create)();
 108     const char* nickname;
 109     const char* description;
 110 } DefModule_BlobTrackAnalysis;
 111
 112 DefModule_BlobTrackAnalysis BlobTrackAnalysis_Modules[] =
 113 {
 114     {cvCreateModuleBlobTrackAnalysisHistPVS,"HistPVS","Histogram of 5D feature vector analysis (x,y,vx,vy,state)"},
 115     {NULL,"None","No trajectory analiser"},
 116     {cvCreateModuleBlobTrackAnalysisHistP,"HistP","Histogram of 2D feature vector analysis (x,y)"},
 117     {cvCreateModuleBlobTrackAnalysisHistPV,"HistPV","Histogram of 4D feature vector analysis (x,y,vx,vy)"},
 118     {cvCreateModuleBlobTrackAnalysisHistSS,"HistSS","Histogram of 4D feature vector analysis (startpos,endpos)"},
 119     {cvCreateModuleBlobTrackAnalysisTrackDist,"TrackDist","Compare tracks directly"},
 120     {cvCreateModuleBlobTrackAnalysisIOR,"IOR","Integrator (by OR operation) of several analysers "},
 121     {NULL,NULL,NULL}
 122 };
 123
 124 /* List of Blob Trajectory ANALYSIS modules: */
 125 /*================= END MODULES DECRIPTION ===================================*/
 126
 127 /* Run pipeline on all frames: */
 128 static int RunBlobTrackingAuto( CvCapture* pCap, CvBlobTrackerAuto* pTracker,char* fgavi_name = NULL, char* btavi_name = NULL )
 129 {
 130     int                     OneFrameProcess = 0;
 131     int                     key;
 132     int                     FrameNum = 0;
 133     CvVideoWriter*          pFGAvi = NULL;
 134     CvVideoWriter*          pBTAvi = NULL;
 135
 136     //cvNamedWindow( "FG", 0 );
 137
 138     /* Main loop: */
 139     for( FrameNum=0; pCap && (key=cvWaitKey(OneFrameProcess?0:1))!=27;
 140          FrameNum++)
 141     {   /* Main loop: */
 142         IplImage*   pImg  = NULL;
 143         IplImage*   pMask = NULL;
 144
 145         if(key!=-1)
 146         {
 147             OneFrameProcess = 1;
 148             if(key=='r')OneFrameProcess = 0;
 149         }
 150
 151         pImg = cvQueryFrame(pCap);
 152         if(pImg == NULL) break;
 153
 154
 155         /* Process: */
 156         pTracker->Process(pImg, pMask);
 157
 158         if(fgavi_name)
 159         if(pTracker->GetFGMask())
 160         {   /* Debug FG: */
 161             IplImage*           pFG = pTracker->GetFGMask();
 162             CvSize              S = cvSize(pFG->width,pFG->height);
 163             static IplImage*    pI = NULL;
 164
 165             if(pI==NULL)pI = cvCreateImage(S,pFG->depth,3);
 166             cvCvtColor( pFG, pI, CV_GRAY2BGR );
 167
 168             if(fgavi_name)
 169             {   /* Save fg to avi file: */
 170                 if(pFGAvi==NULL)
 171                 {
 172                     pFGAvi=cvCreateVideoWriter(
 173                         fgavi_name,
 174                         CV_FOURCC('x','v','i','d'),
 175                         25,
 176                         S );
 177                 }
 178                 cvWriteFrame( pFGAvi, pI );
 179             }
 180
 181             if(pTracker->GetBlobNum()>0)
 182             {   /* Draw detected blobs: */
 183                 int i;
 184                 for(i=pTracker->GetBlobNum();i>0;i--)
 185                 {
 186                     CvBlob* pB = pTracker->GetBlob(i-1);
 187                     CvPoint p = cvPointFrom32f(CV_BLOB_CENTER(pB));
 188                     CvSize  s = cvSize(MAX(1,cvRound(CV_BLOB_RX(pB))), MAX(1,cvRound(CV_BLOB_RY(pB))));
 189                     int c = cvRound(255*pTracker->GetState(CV_BLOB_ID(pB)));
 190                     cvEllipse( pI,
 191                         p,
 192                         s,
 193                         0, 0, 360,
 194                         CV_RGB(c,255-c,0), cvRound(1+(3*c)/255) );
 195                 }   /* Next blob: */;
 196             }
 197
 198             cvNamedWindow( "FG",0);
 199             cvShowImage( "FG",pI);
 200         }   /* Debug FG. */
 201
 202
 203         /* Draw debug info: */
 204         if(pImg)
 205         {   /* Draw all information about test sequence: */
 206             char        str[1024];
 207             int         line_type = CV_AA;   // Change it to 8 to see non-antialiased graphics.
 208             CvFont      font;
 209             int         i;
 210             IplImage*   pI = cvCloneImage(pImg);
 211
 212             cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, 0.7, 0.7, 0, 1, line_type );
 213
 214             for(i=pTracker->GetBlobNum(); i>0; i--)
 215             {
 216                 CvSize  TextSize;
 217                 CvBlob* pB = pTracker->GetBlob(i-1);
 218                 CvPoint p = cvPoint(cvRound(pB->x*256),cvRound(pB->y*256));
 219                 CvSize  s = cvSize(MAX(1,cvRound(CV_BLOB_RX(pB)*256)), MAX(1,cvRound(CV_BLOB_RY(pB)*256)));
 220                 int c = cvRound(255*pTracker->GetState(CV_BLOB_ID(pB)));
 221
 222                 cvEllipse( pI,
 223                     p,
 224                     s,
 225                     0, 0, 360,
 226                     CV_RGB(c,255-c,0), cvRound(1+(3*0)/255), CV_AA, 8 );
 227
 228                 p.x >>= 8;
 229                 p.y >>= 8;
 230                 s.width >>= 8;
 231                 s.height >>= 8;
 232                 sprintf(str,"%03d",CV_BLOB_ID(pB));
 233                 cvGetTextSize( str, &font, &TextSize, NULL );
 234                 p.y -= s.height;
 235                 cvPutText( pI, str, p, &font, CV_RGB(0,255,255));
 236                 {
 237                     const char* pS = pTracker->GetStateDesc(CV_BLOB_ID(pB));
 238
 239                     if(pS)
 240                     {
 241                         char* pStr = strdup(pS);
 242                         char* pStrFree = pStr;
 243
 244                         while (pStr && strlen(pStr) > 0)
 245                         {
 246                             char* str_next = strchr(pStr,'\n');
 247
 248                             if(str_next)
 249                             {
 250                                 str_next[0] = 0;
 251                                 str_next++;
 252                             }
 253
 254                             p.y += TextSize.height+1;
 255                             cvPutText( pI, pStr, p, &font, CV_RGB(0,255,255));
 256                             pStr = str_next;
 257                         }
 258                         free(pStrFree);
 259                     }
 260                 }
 261
 262             }   /* Next blob. */;
 263
 264             cvNamedWindow( "Tracking", 0);
 265             cvShowImage( "Tracking",pI );
 266
 267             if(btavi_name && pI)
 268             {   /* Save to avi file: */
 269                 CvSize      S = cvSize(pI->width,pI->height);
 270                 if(pBTAvi==NULL)
 271                 {
 272                     pBTAvi=cvCreateVideoWriter(
 273                         btavi_name,
 274                         CV_FOURCC('x','v','i','d'),
 275                         25,
 276                         S );
 277                 }
 278                 cvWriteFrame( pBTAvi, pI );
 279             }
 280
 281             cvReleaseImage(&pI);
 282         }   /* Draw all information about test sequence. */
 283     }   /*  Main loop. */
 284
 285     if(pFGAvi)cvReleaseVideoWriter( &pFGAvi );
 286     if(pBTAvi)cvReleaseVideoWriter( &pBTAvi );
 287     return 0;
 288 }   /* RunBlobTrackingAuto */
 289
 290 /* Read parameters from command line
 291  * and transfer to specified module:
 292  */
 293 static void set_params(int argc, char* argv[], CvVSModule* pM, const char* prefix, const char* module)
 294 {
 295     int prefix_len = strlen(prefix);
 296     int i;
 297     for(i=0; i<argc; ++i)
 298     {
 299         int j;
 300         char* ptr_eq = NULL;
 301         int   cmd_param_len=0;
 302         char* cmd = argv[i];
 303         if(MY_STRNICMP(prefix,cmd,prefix_len)!=0) continue;
 304         cmd += prefix_len;
 305         if(cmd[0]!=':')continue;
 306         cmd++;
 307
 308         ptr_eq = strchr(cmd,'=');
 309         if(ptr_eq)cmd_param_len = ptr_eq-cmd;
 310
 311         for(j=0; ; ++j)
 312         {
 313             int     param_len;
 314             const char*   param = pM->GetParamName(j);
 315             if(param==NULL) break;
 316             param_len = strlen(param);
 317             if(cmd_param_len!=param_len) continue;
 318             if(MY_STRNICMP(param,cmd,param_len)!=0) continue;
 319             cmd+=param_len;
 320             if(cmd[0]!='=')continue;
 321             cmd++;
 322             pM->SetParamStr(param,cmd);
 323             printf("%s:%s param set to %g\n",module,param,pM->GetParam(param));
 324         }
 325     }
 326
 327     pM->ParamUpdate();
 328
 329 }   /* set_params */
 330
 331 /* Print all parameter values for given module: */
 332 static void print_params(CvVSModule* pM, const char* module, const char* log_name)
 333 {
 334     FILE* log = log_name?fopen(log_name,"at"):NULL;
 335     int i;
 336     if(pM->GetParamName(0) == NULL ) return;
 337
 338
 339     printf("%s(%s) module parameters:\n",module,pM->GetNickName());
 340     if(log)
 341         fprintf(log,"%s(%s) module parameters:\n",module,pM->GetNickName());
 342
 343     for (i=0; ; ++i)
 344     {
 345         const char*   param = pM->GetParamName(i);
 346         const char*   str = param?pM->GetParamStr(param):NULL;
 347         if(param == NULL)break;
 348         if(str)
 349         {
 350             printf("  %s: %s\n",param,str);
 351             if(log)
 352                 fprintf(log,"  %s: %s\n",param,str);
 353         }
 354         else
 355         {
 356             printf("  %s: %g\n",param,pM->GetParam(param));
 357             if(log)
 358                 fprintf(log,"  %s: %g\n",param,pM->GetParam(param));
 359         }
 360     }
 361
 362     if(log) fclose(log);
 363
 364 }   /* print_params */
 365
 366 int main(int argc, char* argv[])
 367 {   /* Main function: */
 368     CvCapture*                  pCap = NULL;
 369     CvBlobTrackerAutoParam1     param = {0};
 370     CvBlobTrackerAuto*          pTracker = NULL;
 371
 372     float       scale = 1;
 373     const char* scale_name = NULL;
 374     char*       yml_name = NULL;
 375     char**      yml_video_names = NULL;
 376     int         yml_video_num = 0;
 377     char*       avi_name = NULL;
 378     const char* fg_name = NULL;
 379     char*       fgavi_name = NULL;
 380     char*       btavi_name = NULL;
 381     const char* bd_name = NULL;
 382     const char* bt_name = NULL;
 383     const char* btgen_name = NULL;
 384     const char* btpp_name = NULL;
 385     const char* bta_name = NULL;
 386     char*       bta_data_name = NULL;
 387     char*       track_name = NULL;
 388     char*       comment_name = NULL;
 389     char*       FGTrainFrames = NULL;
 390     char*       log_name = NULL;
 391     char*       savestate_name = NULL;
 392     char*       loadstate_name = NULL;
 393     const char* bt_corr = NULL;
 394     DefModule_FGDetector*           pFGModule = NULL;
 395     DefModule_BlobDetector*         pBDModule = NULL;
 396     DefModule_BlobTracker*          pBTModule = NULL;
 397     DefModule_BlobTrackPostProc*    pBTPostProcModule = NULL;
 398     DefModule_BlobTrackGen*         pBTGenModule = NULL;
 399     DefModule_BlobTrackAnalysis*    pBTAnalysisModule = NULL;
 400
 401     cvInitSystem(argc, argv);
 402
 403     if(argc < 2)
 404     {   /* Print help: */
 405         int i;
 406         printf("blobtrack [fg=<fg_name>] [bd=<bd_name>]\n"
 407             "          [bt=<bt_name>] [btpp=<btpp_name>]\n"
 408             "          [bta=<bta_name>\n"
 409             "          [bta_data=<bta_data_name>\n"
 410             "          [bt_corr=<bt_corr_way>]\n"
 411             "          [btgen=<btgen_name>]\n"
 412             "          [track=<track_file_name>]\n"
 413             "          [scale=<scale val>] [noise=<noise_name>] [IVar=<IVar_name>]\n"
 414             "          [FGTrainFrames=<FGTrainFrames>]\n"
 415             "          [btavi=<avi output>] [fgavi=<avi output on FG>]\n"
 416             "          <avi_file>\n");
 417
 418         printf("  <bt_corr_way> is the method of blob position correction for the \"Blob Tracking\" module\n"
 419             "     <bt_corr_way>=none,PostProcRes\n"
 420             "  <FGTrainFrames> is number of frames for FG training\n"
 421             "  <track_file_name> is file name for save tracked trajectories\n"
 422             "  <bta_data> is file name for data base of trajectory analysis module\n"
 423             "  <avi_file> is file name of avi to process by BlobTrackerAuto\n");
 424
 425         puts("\nModules:");
 426 #define PR(_name,_m,_mt)\
 427         printf("<%s> is \"%s\" module name and can be:\n",_name,_mt);\
 428         for(i=0; _m[i].nickname; ++i)\
 429         {\
 430             printf("  %d. %s",i+1,_m[i].nickname);\
 431             if(_m[i].description)printf(" - %s",_m[i].description);\
 432             printf("\n");\
 433         }
 434
 435         PR("fg_name",FGDetector_Modules,"FG/BG Detection");
 436         PR("bd_name",BlobDetector_Modules,"Blob Entrance Detection");
 437         PR("bt_name",BlobTracker_Modules,"Blob Tracking");
 438         PR("btpp_name",BlobTrackPostProc_Modules, "Blob Trajectory Post Processing");
 439         PR("btgen_name",BlobTrackGen_Modules, "Blob Trajectory Generation");
 440         PR("bta_name",BlobTrackAnalysis_Modules, "Blob Trajectory Analysis");
 441 #undef PR
 442         return 0;
 443     }   /* Print help. */
 444
 445     {   /* Parse arguments: */
 446         int i;
 447         for(i=1; i<argc; ++i)
 448         {
 449             int bParsed = 0;
 450             size_t len = strlen(argv[i]);
 451 #define RO(_n1,_n2) if(strncmp(argv[i],_n1,strlen(_n1))==0) {_n2 = argv[i]+strlen(_n1);bParsed=1;};
 452             RO("fg=",fg_name);
 453             RO("fgavi=",fgavi_name);
 454             RO("btavi=",btavi_name);
 455             RO("bd=",bd_name);
 456             RO("bt=",bt_name);
 457             RO("bt_corr=",bt_corr);
 458             RO("btpp=",btpp_name);
 459             RO("bta=",bta_name);
 460             RO("bta_data=",bta_data_name);
 461             RO("btgen=",btgen_name);
 462             RO("track=",track_name);
 463             RO("comment=",comment_name);
 464             RO("FGTrainFrames=",FGTrainFrames);
 465             RO("log=",log_name);
 466             RO("savestate=",savestate_name);
 467             RO("loadstate=",loadstate_name);
 468 #undef RO
 469             {
 470                 char* ext = argv[i] + len-4;
 471                 if( strrchr(argv[i],'=') == NULL &&
 472                     !bParsed &&
 473                     (len>3 && (MY_STRICMP(ext,".avi") == 0 )))
 474                 {
 475                     avi_name = argv[i];
 476                     break;
 477                 }
 478             }   /* Next argument. */
 479         }
 480     }   /* Parse arguments. */
 481
 482     if(track_name)
 483     {   /* Set Trajectory Generator module: */
 484         int i;
 485         if(!btgen_name)btgen_name=BlobTrackGen_Modules[0].nickname;
 486
 487         for(i=0; BlobTrackGen_Modules[i].nickname; ++i)
 488         {
 489             if(MY_STRICMP(BlobTrackGen_Modules[i].nickname,btgen_name)==0)
 490                 pBTGenModule = BlobTrackGen_Modules + i;
 491         }
 492     }   /* Set Trajectory Generato module. */
 493
 494     /* Initialize postprocessing module if tracker
 495      * correction by postprocessing is required.
 496      */
 497     if(bt_corr && MY_STRICMP(bt_corr,"PostProcRes")!=0 && !btpp_name)
 498     {
 499         btpp_name = bt_corr;
 500         if(MY_STRICMP(btpp_name,"none")!=0)bt_corr = "PostProcRes";
 501     }
 502
 503     {   /* Set default parameters for one processing: */
 504         if(!bt_corr) bt_corr = "none";
 505         if(!fg_name) fg_name = FGDetector_Modules[0].nickname;
 506         if(!bd_name) bd_name = BlobDetector_Modules[0].nickname;
 507         if(!bt_name) bt_name = BlobTracker_Modules[0].nickname;
 508         if(!btpp_name) btpp_name = BlobTrackPostProc_Modules[0].nickname;
 509         if(!bta_name) bta_name = BlobTrackAnalysis_Modules[0].nickname;
 510         if(!scale_name) scale_name = "1";
 511     }
 512
 513     if(scale_name)
 514         scale = (float)atof(scale_name);
 515
 516     for(pFGModule=FGDetector_Modules; pFGModule->nickname; ++pFGModule)
 517         if( fg_name && MY_STRICMP(fg_name,pFGModule->nickname)==0 ) break;
 518
 519     for(pBDModule=BlobDetector_Modules; pBDModule->nickname; ++pBDModule)
 520         if( bd_name && MY_STRICMP(bd_name,pBDModule->nickname)==0 ) break;
 521
 522     for(pBTModule=BlobTracker_Modules; pBTModule->nickname; ++pBTModule)
 523         if( bt_name && MY_STRICMP(bt_name,pBTModule->nickname)==0 ) break;
 524
 525     for(pBTPostProcModule=BlobTrackPostProc_Modules; pBTPostProcModule->nickname; ++pBTPostProcModule)
 526         if( btpp_name && MY_STRICMP(btpp_name,pBTPostProcModule->nickname)==0 ) break;
 527
 528     for(pBTAnalysisModule=BlobTrackAnalysis_Modules; pBTAnalysisModule->nickname; ++pBTAnalysisModule)
 529         if( bta_name && MY_STRICMP(bta_name,pBTAnalysisModule->nickname)==0 ) break;
 530
 531     /* Create source video: */
 532     if(avi_name)
 533         pCap = cvCaptureFromFile(avi_name);
 534
 535     if(pCap==NULL)
 536     {
 537         printf("Can't open %s file\n",avi_name);
 538         return -1;
 539     }
 540
 541
 542     {   /* Display parameters: */
 543         int i;
 544         FILE* log = log_name?fopen(log_name,"at"):NULL;
 545         if(log)
 546         {   /* Print to log file: */
 547             fprintf(log,"\n=== Blob Tracking pipline in processing mode===\n");
 548             if(avi_name)
 549             {
 550                 fprintf(log,"AVIFile: %s\n",avi_name);
 551             }
 552             fprintf(log,"FGDetector:   %s\n", pFGModule->nickname);
 553             fprintf(log,"BlobDetector: %s\n", pBDModule->nickname);
 554             fprintf(log,"BlobTracker:  %s\n", pBTModule->nickname);
 555             fprintf(log,"BlobTrackPostProc:  %s\n", pBTPostProcModule->nickname);
 556             fprintf(log,"BlobCorrection:  %s\n", bt_corr);
 557
 558             fprintf(log,"Blob Trajectory Generator:  %s (%s)\n",
 559                 pBTGenModule?pBTGenModule->nickname:"None",
 560                 track_name?track_name:"none");
 561
 562             fprintf(log,"BlobTrackAnalysis:  %s\n", pBTAnalysisModule->nickname);
 563             fclose(log);
 564         }
 565
 566         printf("\n=== Blob Tracking pipline in %s mode===\n","processing");
 567         if(yml_name)
 568         {
 569             printf("ConfigFile: %s\n",yml_name);
 570             printf("BG: %s\n",yml_video_names[0]);
 571             printf("FG: ");
 572             for(i=1;i<(yml_video_num);++i){printf("%s",yml_video_names[i]);if((i+1)<yml_video_num)printf("|");};
 573             printf("\n");
 574         }
 575         if(avi_name)
 576         {
 577             printf("AVIFile: %s\n",avi_name);
 578         }
 579         printf("FGDetector:   %s\n", pFGModule->nickname);
 580         printf("BlobDetector: %s\n", pBDModule->nickname);
 581         printf("BlobTracker:  %s\n", pBTModule->nickname);
 582         printf("BlobTrackPostProc:  %s\n", pBTPostProcModule->nickname);
 583         printf("BlobCorrection:  %s\n", bt_corr);
 584
 585         printf("Blob Trajectory Generator:  %s (%s)\n",
 586             pBTGenModule?pBTGenModule->nickname:"None",
 587             track_name?track_name:"none");
 588
 589         printf("BlobTrackAnalysis:  %s\n", pBTAnalysisModule->nickname);
 590
 591     }   /* Display parameters. */
 592
 593     {   /* Create autotracker module and its components: */
 594         param.FGTrainFrames = FGTrainFrames?atoi(FGTrainFrames):0;
 595
 596         /* Create FG Detection module: */
 597         param.pFG = pFGModule->create();
 598         if(!param.pFG)
 599             puts("Can not create FGDetector module");
 600         param.pFG->SetNickName(pFGModule->nickname);
 601         set_params(argc, argv, param.pFG, "fg", pFGModule->nickname);
 602
 603         /* Create Blob Entrance Detection module: */
 604         param.pBD = pBDModule->create();
 605         if(!param.pBD)
 606             puts("Can not create BlobDetector module");
 607         param.pBD->SetNickName(pBDModule->nickname);
 608         set_params(argc, argv, param.pBD, "bd", pBDModule->nickname);
 609
 610         /* Create blob tracker module: */
 611         param.pBT = pBTModule->create();
 612         if(!param.pBT)
 613             puts("Can not create BlobTracker module");
 614         param.pBT->SetNickName(pBTModule->nickname);
 615         set_params(argc, argv, param.pBT, "bt", pBTModule->nickname);
 616
 617         /* Create blob trajectory generation module: */
 618         param.pBTGen = NULL;
 619         if(pBTGenModule && track_name && pBTGenModule->create)
 620         {
 621             param.pBTGen = pBTGenModule->create();
 622             param.pBTGen->SetFileName(track_name);
 623         }
 624         if(param.pBTGen)
 625         {
 626             param.pBTGen->SetNickName(pBTGenModule->nickname);
 627             set_params(argc, argv, param.pBTGen, "btgen", pBTGenModule->nickname);
 628         }
 629
 630         /* Create blob trajectory post processing module: */
 631         param.pBTPP = NULL;
 632         if(pBTPostProcModule && pBTPostProcModule->create)
 633         {
 634             param.pBTPP = pBTPostProcModule->create();
 635         }
 636         if(param.pBTPP)
 637         {
 638             param.pBTPP->SetNickName(pBTPostProcModule->nickname);
 639             set_params(argc, argv, param.pBTPP, "btpp", pBTPostProcModule->nickname);
 640         }
 641
 642         param.UsePPData = (bt_corr && MY_STRICMP(bt_corr,"PostProcRes")==0);
 643
 644         /* Create blob trajectory analysis module: */
 645         param.pBTA = NULL;
 646         if(pBTAnalysisModule && pBTAnalysisModule->create)
 647         {
 648             param.pBTA = pBTAnalysisModule->create();
 649             param.pBTA->SetFileName(bta_data_name);
 650         }
 651         if(param.pBTA)
 652         {
 653             param.pBTA->SetNickName(pBTAnalysisModule->nickname);
 654             set_params(argc, argv, param.pBTA, "bta", pBTAnalysisModule->nickname);
 655         }
 656
 657         /* Create whole pipline: */
 658         pTracker = cvCreateBlobTrackerAuto1(&param);
 659         if(!pTracker)
 660             puts("Can not create BlobTrackerAuto");
 661     }
 662
 663     {   /* Load states of each module from state file: */
 664         CvFileStorage* fs = NULL;
 665         if(loadstate_name)
 666             fs=cvOpenFileStorage(loadstate_name,NULL,CV_STORAGE_READ);
 667         if(fs)
 668         {
 669             printf("Load states for modules...\n");
 670             if(param.pBT)
 671             {
 672                 CvFileNode* fn = cvGetFileNodeByName(fs,NULL,"BlobTracker");
 673                 param.pBT->LoadState(fs,fn);
 674             }
 675
 676             if(param.pBTA)
 677             {
 678                 CvFileNode* fn = cvGetFileNodeByName(fs,NULL,"BlobTrackAnalyser");
 679                 param.pBTA->LoadState(fs,fn);
 680             }
 681
 682             if(pTracker)
 683             {
 684                 CvFileNode* fn = cvGetFileNodeByName(fs,NULL,"BlobTrackerAuto");
 685                 pTracker->LoadState(fs,fn);
 686             }
 687
 688             cvReleaseFileStorage(&fs);
 689             printf("... Modules states loaded\n");
 690         }
 691     }   /* Load states of each module. */
 692
 693     {   /* Print module parameters: */
 694         struct DefMMM
 695         {
 696             CvVSModule* pM;
 697             const char* name;
 698         } Modules[] = {
 699             {(CvVSModule*)param.pFG,"FGdetector"},
 700             {(CvVSModule*)param.pBD,"BlobDetector"},
 701             {(CvVSModule*)param.pBT,"BlobTracker"},
 702             {(CvVSModule*)param.pBTGen,"TrackGen"},
 703             {(CvVSModule*)param.pBTPP,"PostProcessing"},
 704             {(CvVSModule*)param.pBTA,"TrackAnalysis"},
 705             {NULL,NULL}
 706         };
 707         int     i;
 708         for(i=0; Modules[i].name; ++i)
 709         {
 710             if(Modules[i].pM)
 711                 print_params(Modules[i].pM,Modules[i].name,log_name);
 712         }
 713     }   /* Print module parameters. */
 714
 715     /* Run pipeline: */
 716     RunBlobTrackingAuto( pCap, pTracker, fgavi_name, btavi_name );
 717
 718     {   /* Save state and release modules: */
 719         CvFileStorage* fs = NULL;
 720         if(savestate_name)
 721         {
 722             fs=cvOpenFileStorage(savestate_name,NULL,CV_STORAGE_WRITE);
 723         }
 724         if(fs)
 725         {
 726             cvStartWriteStruct(fs,"BlobTracker",CV_NODE_MAP);
 727             if(param.pBT)param.pBT->SaveState(fs);
 728             cvEndWriteStruct(fs);
 729             cvStartWriteStruct(fs,"BlobTrackerAuto",CV_NODE_MAP);
 730             if(pTracker)pTracker->SaveState(fs);
 731             cvEndWriteStruct(fs);
 732             cvStartWriteStruct(fs,"BlobTrackAnalyser",CV_NODE_MAP);
 733             if(param.pBTA)param.pBTA->SaveState(fs);
 734             cvEndWriteStruct(fs);
 735             cvReleaseFileStorage(&fs);
 736         }
 737         if(param.pBT)cvReleaseBlobTracker(&param.pBT);
 738         if(param.pBD)cvReleaseBlobDetector(&param.pBD);
 739         if(param.pBTGen)cvReleaseBlobTrackGen(&param.pBTGen);
 740         if(param.pBTA)cvReleaseBlobTrackAnalysis(&param.pBTA);
 741         if(param.pFG)cvReleaseFGDetector(&param.pFG);
 742         if(pTracker)cvReleaseBlobTrackerAuto(&pTracker);
 743
 744     }   /* Save state and release modules. */
 745
 746     if(pCap)
 747         cvReleaseCapture(&pCap);
 748
 749     return 0;
 750
 751 }   /* main() */
 752
 753
 754