开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenCV > 查看源码
blobtrack.cpp
资源名称：Opencv-source-code.rar　[点击查看]
上传用户：banwdc
上传日期：2016-06-25
资源大小：2871k
文件大小：26k
源码类别：

OpenCV

开发平台：

Visual C++

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