git.maemo.org Git - opencv/blob - samples/c/blobtrack.cpp

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