#include "highgui.h"
#include <stdio.h>
-/* select the correct function for doing case insensitive string comparaison */
+/* Select appropriate case insensitive string comparison function: */
#ifdef WIN32
#define MY_STRNICMP strnicmp
#define MY_STRICMP stricmp
#define MY_STRICMP strcasecmp
#endif
-/* list of FG DETECTION modules */
-static CvFGDetector* cvCreateFGDetector0(){return cvCreateFGDetectorBase(CV_BG_MODEL_FGD, NULL);}
-static CvFGDetector* cvCreateFGDetector0Simple(){return cvCreateFGDetectorBase(CV_BG_MODEL_FGD_SIMPLE, NULL);}
-static CvFGDetector* cvCreateFGDetector1(){return cvCreateFGDetectorBase(CV_BG_MODEL_MOG, NULL);}
+/* List of foreground (FG) DETECTION modules: */
+static CvFGDetector* cvCreateFGDetector0 () { return cvCreateFGDetectorBase(CV_BG_MODEL_FGD, NULL); }
+static CvFGDetector* cvCreateFGDetector0Simple() { return cvCreateFGDetectorBase(CV_BG_MODEL_FGD_SIMPLE, NULL); }
+static CvFGDetector* cvCreateFGDetector1 () { return cvCreateFGDetectorBase(CV_BG_MODEL_MOG, NULL); }
+
typedef struct DefModule_FGDetector
{
CvFGDetector* (*create)();
char* nickname;
char* description;
} DefModule_FGDetector;
+
DefModule_FGDetector FGDetector_Modules[] =
{
{cvCreateFGDetector0,"FG_0","Foreground Object Detection from Videos Containing Complex Background. ACM MM2003."},
- {cvCreateFGDetector0Simple,"FG_0S","Simplyfied version of FG_0"},
+ {cvCreateFGDetector0Simple,"FG_0S","Simplified version of FG_0"},
{cvCreateFGDetector1,"FG_1","Adaptive background mixture models for real-time tracking. CVPR1999"},
{NULL,NULL,NULL}
};
-/* list of BLOB DETECTION modules */
+/* List of BLOB DETECTION modules: */
typedef struct DefModule_BlobDetector
{
CvBlobDetector* (*create)();
char* nickname;
char* description;
} DefModule_BlobDetector;
+
DefModule_BlobDetector BlobDetector_Modules[] =
{
{cvCreateBlobDetectorCC,"BD_CC","Detect new blob by tracking CC of FG mask"},
{NULL,NULL,NULL}
};
-/* list of BLOB TRACKING modules */
+/* List of BLOB TRACKING modules: */
typedef struct DefModule_BlobTracker
{
CvBlobTracker* (*create)();
char* nickname;
char* description;
} DefModule_BlobTracker;
+
DefModule_BlobTracker BlobTracker_Modules[] =
{
{cvCreateBlobTrackerCCMSPF,"CCMSPF","connected component tracking and MSPF resolver for collision"},
{NULL,NULL,NULL}
};
-/* list of BLOB TRAJECTORY GENERATION modules */
+/* List of BLOB TRAJECTORY GENERATION modules: */
typedef struct DefModule_BlobTrackGen
{
CvBlobTrackGen* (*create)();
char* nickname;
char* description;
} DefModule_BlobTrackGen;
+
DefModule_BlobTrackGen BlobTrackGen_Modules[] =
{
{cvCreateModuleBlobTrackGenYML,"YML","Generate track record in YML format as synthetic video data"},
{NULL,NULL,NULL}
};
-/* list of BLOB TRAJECTORY POST PROCESSING modules */
+/* List of BLOB TRAJECTORY POST PROCESSING modules: */
typedef struct DefModule_BlobTrackPostProc
{
CvBlobTrackPostProc* (*create)();
char* nickname;
char* description;
} DefModule_BlobTrackPostProc;
+
DefModule_BlobTrackPostProc BlobTrackPostProc_Modules[] =
{
{cvCreateModuleBlobTrackPostProcKalman,"Kalman","Kalman filtering of blob position and size"},
{NULL,NULL,NULL}
};
-/* list of BLOB TRAJECTORY ANALYSIS modules */
+/* List of BLOB TRAJECTORY ANALYSIS modules: */
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisDetector();
typedef struct DefModule_BlobTrackAnalysis
char* nickname;
char* description;
} DefModule_BlobTrackAnalysis;
+
DefModule_BlobTrackAnalysis BlobTrackAnalysis_Modules[] =
{
- {cvCreateModuleBlobTrackAnalysisHistPVS,"HistPVS","Histogramm of 5D feture vector analysis (x,y,vx,vy,state)"},
+ {cvCreateModuleBlobTrackAnalysisHistPVS,"HistPVS","Histogram of 5D feature vector analysis (x,y,vx,vy,state)"},
{NULL,"None","No trajectory analiser"},
- {cvCreateModuleBlobTrackAnalysisHistP,"HistP","Histogramm of 2D feture vector analysis (x,y)"},
- {cvCreateModuleBlobTrackAnalysisHistPV,"HistPV","Histogramm of 4D feture vector analysis (x,y,vx,vy)"},
- {cvCreateModuleBlobTrackAnalysisHistSS,"HistSS","Histogramm of 4D feture vector analysis (startpos,endpos)"},
+ {cvCreateModuleBlobTrackAnalysisHistP,"HistP","Histogram of 2D feature vector analysis (x,y)"},
+ {cvCreateModuleBlobTrackAnalysisHistPV,"HistPV","Histogram of 4D feature vector analysis (x,y,vx,vy)"},
+ {cvCreateModuleBlobTrackAnalysisHistSS,"HistSS","Histogram of 4D feature vector analysis (startpos,endpos)"},
{cvCreateModuleBlobTrackAnalysisTrackDist,"TrackDist","Compare tracks directly"},
{cvCreateModuleBlobTrackAnalysisIOR,"IOR","Integrator (by OR operation) of several analysers "},
{NULL,NULL,NULL}
};
-/* list of Blob Trajectory ANALYSIS modules */
+
+/* List of Blob Trajectory ANALYSIS modules: */
/*================= END MODULES DECRIPTION ===================================*/
-/* run pipeline on all frames */
+/* Run pipeline on all frames: */
static int RunBlobTrackingAuto( CvCapture* pCap, CvBlobTrackerAuto* pTracker,char* fgavi_name = NULL, char* btavi_name = NULL )
{
int OneFrameProcess = 0;
//cvNamedWindow( "FG", 0 );
- /* main cicle */
+ /* Main loop: */
for( FrameNum=0; pCap && (key=cvWaitKey(OneFrameProcess?0:1))!=27;
FrameNum++)
- {/* main cicle */
- IplImage* pImg = NULL;
+ { /* Main loop: */
+ IplImage* pImg = NULL;
IplImage* pMask = NULL;
if(key!=-1)
if(pImg == NULL) break;
- /* Process */
+ /* Process: */
pTracker->Process(pImg, pMask);
if(fgavi_name)
if(pTracker->GetFGMask())
- {/* debug FG */
+ { /* Debug FG: */
IplImage* pFG = pTracker->GetFGMask();
CvSize S = cvSize(pFG->width,pFG->height);
static IplImage* pI = NULL;
cvCvtColor( pFG, pI, CV_GRAY2BGR );
if(fgavi_name)
- {/* save fg to avi file */
+ { /* Save fg to avi file: */
if(pFGAvi==NULL)
{
pFGAvi=cvCreateVideoWriter(
}
if(pTracker->GetBlobNum()>0)
- {/* draw detected blobs */
+ { /* Draw detected blobs: */
int i;
for(i=pTracker->GetBlobNum();i>0;i--)
{
s,
0, 0, 360,
CV_RGB(c,255-c,0), cvRound(1+(3*c)/255) );
- }/* next blob */;
+ } /* Next blob: */;
}
cvNamedWindow( "FG",0);
cvShowImage( "FG",pI);
- }/* debug FG*/
+ } /* Debug FG. */
- /* draw debug info */
+ /* Draw debug info: */
if(pImg)
- {/* draw all inforamtion about tets sequence */
+ { /* Draw all information about test sequence: */
char str[1024];
- int line_type = CV_AA; // change it to 8 to see non-antialiased graphics
+ int line_type = CV_AA; // Change it to 8 to see non-antialiased graphics.
CvFont font;
int i;
IplImage* pI = cvCloneImage(pImg);
cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, 0.7, 0.7, 0, 1, line_type );
- for(i=pTracker->GetBlobNum();i>0;i--)
+ for(i=pTracker->GetBlobNum(); i>0; i--)
{
CvSize TextSize;
CvBlob* pB = pTracker->GetBlob(i-1);
s,
0, 0, 360,
CV_RGB(c,255-c,0), cvRound(1+(3*0)/255), CV_AA, 8 );
+
p.x >>= 8;
p.y >>= 8;
s.width >>= 8;
cvPutText( pI, str, p, &font, CV_RGB(0,255,255));
{
char* pS = pTracker->GetStateDesc(CV_BLOB_ID(pB));
+
if(pS)
{
char* pStr = strdup(pS);
char* pStrFree = pStr;
- for(;pStr && strlen(pStr)>0;)
+
+ while (pStr && strlen(pStr) > 0)
{
char* str_next = strchr(pStr,'\n');
+
if(str_next)
{
str_next[0] = 0;
str_next++;
}
+
p.y += TextSize.height+1;
cvPutText( pI, pStr, p, &font, CV_RGB(0,255,255));
pStr = str_next;
}
}
- }/* next blob */;
+ } /* Next blob. */;
cvNamedWindow( "Tracking", 0);
cvShowImage( "Tracking",pI );
if(btavi_name && pI)
- {/* save to avi file */
+ { /* Save to avi file: */
CvSize S = cvSize(pI->width,pI->height);
if(pBTAvi==NULL)
{
}
cvReleaseImage(&pI);
- }/* draw all inforamtion about tets sequence */
- }/* main cicle */
+ } /* Draw all information about test sequence. */
+ } /* Main loop. */
if(pFGAvi)cvReleaseVideoWriter( &pFGAvi );
if(pBTAvi)cvReleaseVideoWriter( &pBTAvi );
return 0;
-}/* RunBlobTrackingAuto */
+} /* RunBlobTrackingAuto */
-/* read parameters from command line and transfer to specified module */
+/* Read parameters from command line
+ * and transfer to specified module:
+ */
static void set_params(int argc, char* argv[], CvVSModule* pM, char* prefix, char* module)
{
int prefix_len = strlen(prefix);
int i;
- for(i=0;i<argc;++i)
+ for(i=0; i<argc; ++i)
{
int j;
char* ptr_eq = NULL;
ptr_eq = strchr(cmd,'=');
if(ptr_eq)cmd_param_len = ptr_eq-cmd;
- for(j=0;;++j)
+
+ for(j=0; ; ++j)
{
int param_len;
char* param = pM->GetParamName(j);
printf("%s:%s param set to %g\n",module,param,pM->GetParam(param));
}
}
+
pM->ParamUpdate();
-}/* set_params */
-/* print all parameters value for given module */
+} /* set_params */
+
+/* Print all parameter values for given module: */
static void print_params(CvVSModule* pM, char* module, char* log_name)
{
FILE* log = log_name?fopen(log_name,"at"):NULL;
printf("%s(%s) module parameters:\n",module,pM->GetNickName());
if(log)
fprintf(log,"%s(%s) module parameters:\n",module,pM->GetNickName());
- for(i=0;;++i)
+
+ for (i=0; ; ++i)
{
char* param = pM->GetParamName(i);
char* str = param?pM->GetParamStr(param):NULL;
fprintf(log," %s: %g\n",param,pM->GetParam(param));
}
}
- if(log)fclose(log);
-}/* print_params */
+
+ if(log) fclose(log);
+
+} /* print_params */
int main(int argc, char* argv[])
-{/* main function */
+{ /* Main function: */
CvCapture* pCap = NULL;
CvBlobTrackerAutoParam1 param = {0};
CvBlobTrackerAuto* pTracker = NULL;
cvInitSystem(argc, argv);
if(argc < 2)
- {/* print help */
+ { /* Print help: */
int i;
printf("blobtrack [fg=<fg_name>] [bd=<bd_name>]\n"
" [bt=<bt_name>] [btpp=<btpp_name>]\n"
" [FGTrainFrames=<FGTrainFrames>]\n"
" [btavi=<avi output>] [fgavi=<avi output on FG>]\n"
" <avi_file>\n");
+
printf(" <bt_corr_way> is way of blob position corrrection for \"Blob Tracking\" module\n"
" <bt_corr_way>=none,PostProcRes\n"
" <FGTrainFrames> is number of frames for FG training\n"
puts("\nModules:");
#define PR(_name,_m,_mt)\
printf("<%s> is \"%s\" module name and can be:\n",_name,_mt);\
- for(i=0;_m[i].nickname;++i)\
+ for(i=0; _m[i].nickname; ++i)\
{\
printf(" %d. %s",i+1,_m[i].nickname);\
if(_m[i].description)printf(" - %s",_m[i].description);\
PR("bta_name",BlobTrackAnalysis_Modules, "Blob Trajectory Analysis");
#undef PR
return 0;
- }/* print help */
+ } /* Print help. */
- {/* parse srguments */
+ { /* Parse arguments: */
int i;
- for(i=1;i<argc;++i)
+ for(i=1; i<argc; ++i)
{
int bParsed = 0;
size_t len = strlen(argv[i]);
avi_name = argv[i];
break;
}
- }/* next argument */
+ } /* Next argument. */
}
- }/* parse srguments */
+ } /* Parse arguments. */
if(track_name)
- {/* set Trajectory Generator module */
+ { /* Set Trajectory Generator module: */
int i;
if(!btgen_name)btgen_name=BlobTrackGen_Modules[0].nickname;
- for(i=0;BlobTrackGen_Modules[i].nickname;++i)
+
+ for(i=0; BlobTrackGen_Modules[i].nickname; ++i)
{
if(MY_STRICMP(BlobTrackGen_Modules[i].nickname,btgen_name)==0)
pBTGenModule = BlobTrackGen_Modules + i;
}
- }/* set Trajectory Generato modulke */
+ } /* Set Trajectory Generato module. */
- /* init postprocessing module if tracker correction by postporcessing is reqierd */
+ /* Initialize postprocessing module if tracker
+ * correction by postprocessing is required.
+ */
if(bt_corr && MY_STRICMP(bt_corr,"PostProcRes")!=0 && !btpp_name)
{
btpp_name = bt_corr;
if(MY_STRICMP(btpp_name,"none")!=0)bt_corr = "PostProcRes";
}
- {/* set default parameters for one processing */
+ { /* Set default parameters for one processing: */
if(!bt_corr) bt_corr = "none";
if(!fg_name) fg_name = FGDetector_Modules[0].nickname;
if(!bd_name) bd_name = BlobDetector_Modules[0].nickname;
if(scale_name)
scale = (float)atof(scale_name);
- for(pFGModule=FGDetector_Modules;pFGModule->nickname;++pFGModule)
+
+ for(pFGModule=FGDetector_Modules; pFGModule->nickname; ++pFGModule)
if( fg_name && MY_STRICMP(fg_name,pFGModule->nickname)==0 ) break;
- for(pBDModule=BlobDetector_Modules;pBDModule->nickname;++pBDModule)
+
+ for(pBDModule=BlobDetector_Modules; pBDModule->nickname; ++pBDModule)
if( bd_name && MY_STRICMP(bd_name,pBDModule->nickname)==0 ) break;
- for(pBTModule=BlobTracker_Modules;pBTModule->nickname;++pBTModule)
+
+ for(pBTModule=BlobTracker_Modules; pBTModule->nickname; ++pBTModule)
if( bt_name && MY_STRICMP(bt_name,pBTModule->nickname)==0 ) break;
- for(pBTPostProcModule=BlobTrackPostProc_Modules;pBTPostProcModule->nickname;++pBTPostProcModule)
+
+ for(pBTPostProcModule=BlobTrackPostProc_Modules; pBTPostProcModule->nickname; ++pBTPostProcModule)
if( btpp_name && MY_STRICMP(btpp_name,pBTPostProcModule->nickname)==0 ) break;
- for(pBTAnalysisModule=BlobTrackAnalysis_Modules;pBTAnalysisModule->nickname;++pBTAnalysisModule)
+
+ for(pBTAnalysisModule=BlobTrackAnalysis_Modules; pBTAnalysisModule->nickname; ++pBTAnalysisModule)
if( bta_name && MY_STRICMP(bta_name,pBTAnalysisModule->nickname)==0 ) break;
- /* create source video */
+ /* Create source video: */
if(avi_name)
pCap = cvCaptureFromFile(avi_name);
}
- {/* display parameters */
+ { /* Display parameters: */
int i;
FILE* log = log_name?fopen(log_name,"at"):NULL;
if(log)
- {/* print to log file */
+ { /* Print to log file: */
fprintf(log,"\n=== Blob Tracking pipline in processing mode===\n");
if(avi_name)
{
fprintf(log,"BlobTracker: %s\n", pBTModule->nickname);
fprintf(log,"BlobTrackPostProc: %s\n", pBTPostProcModule->nickname);
fprintf(log,"BlobCorrection: %s\n", bt_corr);
+
fprintf(log,"Blob Trajectory Generator: %s (%s)\n",
pBTGenModule?pBTGenModule->nickname:"None",
track_name?track_name:"none");
+
fprintf(log,"BlobTrackAnalysis: %s\n", pBTAnalysisModule->nickname);
fclose(log);
}
printf("BlobTracker: %s\n", pBTModule->nickname);
printf("BlobTrackPostProc: %s\n", pBTPostProcModule->nickname);
printf("BlobCorrection: %s\n", bt_corr);
+
printf("Blob Trajectory Generator: %s (%s)\n",
pBTGenModule?pBTGenModule->nickname:"None",
track_name?track_name:"none");
+
printf("BlobTrackAnalysis: %s\n", pBTAnalysisModule->nickname);
- }/* display parameters */
+ } /* Display parameters. */
- { /* create autotracker module and its components*/
+ { /* Create autotracker module and its components: */
param.FGTrainFrames = FGTrainFrames?atoi(FGTrainFrames):0;
- /* Create FG Detection module */
+ /* Create FG Detection module: */
param.pFG = pFGModule->create();
if(!param.pFG)
puts("Can not create FGDetector module");
param.pFG->SetNickName(pFGModule->nickname);
set_params(argc, argv, param.pFG, "fg", pFGModule->nickname);
- /* Create Blob Entrance Detection module */
+ /* Create Blob Entrance Detection module: */
param.pBD = pBDModule->create();
if(!param.pBD)
puts("Can not create BlobDetector module");
param.pBD->SetNickName(pBDModule->nickname);
set_params(argc, argv, param.pBD, "bd", pBDModule->nickname);
- /* Create blob tracker module */
+ /* Create blob tracker module: */
param.pBT = pBTModule->create();
if(!param.pBT)
puts("Can not create BlobTracker module");
param.pBT->SetNickName(pBTModule->nickname);
set_params(argc, argv, param.pBT, "bt", pBTModule->nickname);
- /* create blob trajectory generation module */
+ /* Create blob trajectory generation module: */
param.pBTGen = NULL;
if(pBTGenModule && track_name && pBTGenModule->create)
{
set_params(argc, argv, param.pBTGen, "btgen", pBTGenModule->nickname);
}
- /* create blob trajectory post processing module */
+ /* Create blob trajectory post processing module: */
param.pBTPP = NULL;
if(pBTPostProcModule && pBTPostProcModule->create)
{
param.UsePPData = (bt_corr && MY_STRICMP(bt_corr,"PostProcRes")==0);
- /* create blob trajectory analysis module */
+ /* Create blob trajectory analysis module: */
param.pBTA = NULL;
if(pBTAnalysisModule && pBTAnalysisModule->create)
{
set_params(argc, argv, param.pBTA, "bta", pBTAnalysisModule->nickname);
}
- /* create whole pipline */
+ /* Create whole pipline: */
pTracker = cvCreateBlobTrackerAuto1(¶m);
if(!pTracker)
puts("Can not create BlobTrackerAuto");
}
- { /* load states of each module from state file */
+ { /* Load states of each module from state file: */
CvFileStorage* fs = NULL;
if(loadstate_name)
fs=cvOpenFileStorage(loadstate_name,NULL,CV_STORAGE_READ);
cvReleaseFileStorage(&fs);
printf("... Modules states loaded\n");
}
- }/* load states of each module */
+ } /* Load states of each module. */
- {/* print modules parameters */
+ { /* Print module parameters: */
struct DefMMM
{
CvVSModule* pM;
{NULL,NULL}
};
int i;
- for(i=0;Modules[i].name;++i)
+ for(i=0; Modules[i].name; ++i)
{
if(Modules[i].pM)
print_params(Modules[i].pM,Modules[i].name,log_name);
}
- }/* print modules parameters */
+ } /* Print module parameters. */
- /* run pipeline */
+ /* Run pipeline: */
RunBlobTrackingAuto( pCap, pTracker, fgavi_name, btavi_name );
- {/* save state and release modules */
+ { /* Save state and release modules: */
CvFileStorage* fs = NULL;
if(savestate_name)
{
if(param.pBTA)cvReleaseBlobTrackAnalysis(¶m.pBTA);
if(param.pFG)cvReleaseFGDetector(¶m.pFG);
if(pTracker)cvReleaseBlobTrackerAuto(&pTracker);
- }/* save state and release modules*/
+
+ } /* Save state and release modules. */
if(pCap)
cvReleaseCapture(&pCap);
return 0;
-}/* main */
+
+} /* main() */
projects / opencv / blobdiff