static GstFlowReturn
gst_segmentation_transform_ip (GstVideoFilter * btrans, GstVideoFrame * frame)
{
GstSegmentation *filter = GST_SEGMENTATION (btrans);
int j;
/* get image data from the input, which is RGBA */
filter->cvRGBA->imageData = (char *) GST_VIDEO_FRAME_COMP_DATA (frame, 0);
filter->cvRGBA->widthStep = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
filter->framecount++;
/* Image preprocessing: color space conversion etc */
cvCvtColor (filter->cvRGBA, filter->cvRGB, CV_RGBA2RGB);
cvCvtColor (filter->cvRGB, filter->cvYUV, CV_RGB2YCrCb);
/* Create and update a fg/bg model using a codebook approach following the
* opencv O'Reilly book [1] implementation of the algo described in [2].
*
* [1] Learning OpenCV: Computer Vision with the OpenCV Library by Gary
* Bradski and Adrian Kaehler, Published by O'Reilly Media, October 3, 2008
* [2] "Real-time Foreground-Background Segmentation using Codebook Model",
* Real-time Imaging, Volume 11, Issue 3, Pages 167-256, June 2005. */
if (METHOD_BOOK == filter->method) {
unsigned cbBounds[3] = { 10, 5, 5 };
int minMod[3] = { 20, 20, 20 }, maxMod[3] = {
20, 20, 20};
if (filter->framecount < 30) {
/* Learning background phase: update_codebook on every frame */
for (j = 0; j < filter->width * filter->height; j++) {
update_codebook ((unsigned char *) filter->cvYUV->imageData + j * 3,
(codeBook *) & (filter->TcodeBook[j]), cbBounds, 3);
}
} else {
/* this updating is responsible for FG becoming BG again */
if (filter->framecount % filter->learning_interval == 0) {
for (j = 0; j < filter->width * filter->height; j++) {
update_codebook ((uchar *) filter->cvYUV->imageData + j * 3,
(codeBook *) & (filter->TcodeBook[j]), cbBounds, 3);
}
}
if (filter->framecount % 60 == 0) {
for (j = 0; j < filter->width * filter->height; j++)
clear_stale_entries ((codeBook *) & (filter->TcodeBook[j]));
}
for (j = 0; j < filter->width * filter->height; j++) {
if (background_diff
((uchar *) filter->cvYUV->imageData + j * 3,
(codeBook *) & (filter->TcodeBook[j]), 3, minMod, maxMod)) {
filter->cvFG->imageData[j] = 255;
} else {
filter->cvFG->imageData[j] = 0;
}
}
}
/* 3rd param is the smallest area to show: (w+h)/param , in pixels */
find_connected_components (filter->cvFG, 1, 10000,
filter->mem_storage, filter->contours);
}
/* Create the foreground and background masks using BackgroundSubtractorMOG [1],
* Gaussian Mixture-based Background/Foreground segmentation algorithm. OpenCV
* MOG implements the algorithm described in [2].
*
* [1] http://opencv.itseez.com/modules/video/doc/motion_analysis_and_object_tracking.html#backgroundsubtractormog
* [2] P. KadewTraKuPong and R. Bowden, "An improved adaptive background
* mixture model for real-time tracking with shadow detection", Proc. 2nd
* European Workshop on Advanced Video-Based Surveillance Systems, 2001
*/
else if (METHOD_MOG == filter->method) {
run_mog_iteration (filter);
}
/* Create the foreground and background masks using BackgroundSubtractorMOG2
* [1], Gaussian Mixture-based Background/Foreground segmentation algorithm.
* OpenCV MOG2 implements the algorithm described in [2] and [3].
*
* [1] http://opencv.itseez.com/modules/video/doc/motion_analysis_and_object_tracking.html#backgroundsubtractormog2
* [2] Z.Zivkovic, "Improved adaptive Gausian mixture model for background
* subtraction", International Conference Pattern Recognition, UK, Aug 2004.
* [3] Z.Zivkovic, F. van der Heijden, "Efficient Adaptive Density Estimation
* per Image Pixel for the Task of Background Subtraction", Pattern
* Recognition Letters, vol. 27, no. 7, pages 773-780, 2006. */
else if (METHOD_MOG2 == filter->method) {
run_mog2_iteration (filter);
}
/* if we want to test_mode, just overwrite the output */
if (filter->test_mode) {
cvCvtColor (filter->cvFG, filter->cvRGB, CV_GRAY2RGB);
cvSplit (filter->cvRGB, filter->ch1, filter->ch2, filter->ch3, NULL);
} else
cvSplit (filter->cvRGBA, filter->ch1, filter->ch2, filter->ch3, NULL);
/* copy anyhow the fg/bg to the alpha channel in the output image */
cvMerge (filter->ch1, filter->ch2, filter->ch3, filter->cvFG, filter->cvRGBA);
return GST_FLOW_OK;
}
int main(int argc, char** argv)
{
IplImage* temp1 = NULL;
IplImage* temp2 = NULL;
IplImage* result = NULL;
IplImage* result1 = NULL;
IplImage* result2 = NULL;
CvBGStatModel* bg_model=0;
CvBGStatModel* bg_model1=0;
IplImage* rawImage = 0;
IplImage* yuvImage = 0;
IplImage* rawImage1 = 0;
IplImage* pFrImg = 0;
IplImage* pFrImg1= 0;
IplImage* pFrImg2= 0;
IplImage* ImaskCodeBookCC = 0;
CvCapture* capture = 0;
int c,n;
maxMod[0] = 25;
minMod[0] = 35;
maxMod[1] = 8;
minMod[1] = 8;
maxMod[2] = 8;
minMod[2] = 8;
argc=2;
argv[1]="intelligentroom_raw.avi";
if( argc > 2 )
{
fprintf(stderr, "Usage: bkgrd [video_file_name]\n");
return -1;
}
if (argc ==1)
if( !(capture = cvCaptureFromCAM(-1)))
{
fprintf(stderr, "Can not open camera.\n");
return -2;
}
if(argc == 2)
if( !(capture = cvCaptureFromFile(argv[1])))
{
fprintf(stderr, "Can not open video file %s\n", argv[1]);
return -2;
}
bool pause = false;
bool singlestep = false;
if( capture )
{
cvNamedWindow( "原视频序列图像", 1 );
cvNamedWindow("不实时更新的Codebook算法[本文]",1);
cvNamedWindow("实时更新的Codebook算法[本文]",1);
cvNamedWindow("基于MOG的方法[Chris Stauffer'2001]",1);
cvNamedWindow("三帧差分", 1);
cvNamedWindow("基于Bayes decision的方法[Liyuan Li'2003]", 1);
cvMoveWindow("原视频序列图像", 0, 0);
cvMoveWindow("不实时更新的Codebook算法[本文]", 360, 0);
cvMoveWindow("实时更新的Codebook算法[本文]", 720, 350);
cvMoveWindow("基于MOG的方法[Chris Stauffer'2001]", 0, 350);
cvMoveWindow("三帧差分", 720, 0);
cvMoveWindow("基于Bayes decision的方法[Liyuan Li'2003]",360, 350);
int nFrmNum = -1;
for(;;)
{
if(!pause)
{
rawImage = cvQueryFrame( capture );
++nFrmNum;
printf("第%d帧\n",nFrmNum);
if(!rawImage)
break;
}
if(singlestep)
{
pause = true;
}
if(0 == nFrmNum)
{
printf(". . . wait for it . . .\n");
temp1 = cvCreateImage(cvGetSize(rawImage), IPL_DEPTH_8U, 3);
temp2 = cvCreateImage(cvGetSize(rawImage), IPL_DEPTH_8U, 3);
result1 = cvCreateImage(cvGetSize(rawImage), IPL_DEPTH_8U, 1);
result2 = cvCreateImage(cvGetSize(rawImage), IPL_DEPTH_8U, 1);
result = cvCreateImage(cvGetSize(rawImage), IPL_DEPTH_8U, 1);
bg_model = cvCreateGaussianBGModel(rawImage);
bg_model1 = cvCreateFGDStatModel(rawImage);
rawImage1 = cvCreateImage( cvGetSize(rawImage), IPL_DEPTH_8U, 3 );
yuvImage = cvCloneImage(rawImage);
pFrImg = cvCreateImage( cvGetSize(rawImage), IPL_DEPTH_8U, 1 );
pFrImg1 = cvCreateImage( cvGetSize(rawImage), IPL_DEPTH_8U, 1 );
pFrImg2 = cvCreateImage( cvGetSize(rawImage), IPL_DEPTH_8U, 1 );
ImaskCodeBookCC = cvCreateImage( cvGetSize(rawImage), IPL_DEPTH_8U, 1 );
imageLen = rawImage->width*rawImage->height;
cA = new codeBook [imageLen];
cC = new codeBook [imageLen];
cD = new codeBook [imageLen];
for(int f = 0; f<imageLen; f++)
{
cA[f].numEntries = 0; cA[f].t = 0;
cC[f].numEntries = 0; cC[f].t = 0;
cD[f].numEntries = 0; cD[f].t = 0;
}
for(int nc=0; nc<nChannels;nc++)
{
cbBounds[nc] = 10;
}
ch[0] = true;
ch[1] = true;
ch[2] = true;
}
if( rawImage )
{
if(!pause)
{
cvSmooth(rawImage, rawImage1, CV_GAUSSIAN,3,3);
cvChangeDetection(temp1, temp2, result1);
cvChangeDetection(rawImage1, temp1, result2);
cvAnd(result1, result2, result, NULL);
cvCopy(temp1,temp2, NULL);
cvCopy(rawImage,temp1, NULL);
cvUpdateBGStatModel( rawImage, bg_model );
cvUpdateBGStatModel( rawImage, bg_model1 );
}
cvCvtColor( rawImage1, yuvImage, CV_BGR2YCrCb );
if( !pause && nFrmNum >= 1 && nFrmNum < T )
{
pColor = (uchar *)((yuvImage)->imageData);
for(int c=0; c<imageLen; c++)
{
update_codebook_model(pColor, cA[c],cbBounds,nChannels);
trainig_codebook(pColor, cC[c],cbBounds,nChannels);
pColor += 3;
}
}
if( nFrmNum == T)
{
for(c=0; c<imageLen; c++)
{
clear_stale_entries(cA[c]);
training_clear_stale_entries(cC[c]);
}
}
if(nFrmNum > T)
{
pColor = (uchar *)((yuvImage)->imageData);
uchar maskPixelCodeBook;
uchar maskPixelCodeBook1;
uchar maskPixelCodeBook2;
uchar *pMask = (uchar *)((pFrImg)->imageData);
uchar *pMask1 = (uchar *)((pFrImg1)->imageData);
uchar *pMask2 = (uchar *)((pFrImg2)->imageData);
for(int c=0; c<imageLen; c++)
{
//本文中不带自动背景更新的算法输出
maskPixelCodeBook1=background_Diff(pColor, cA[c],nChannels,minMod,maxMod);
*pMask1++ = maskPixelCodeBook1;
//本文中带自动背景更新的算法输出
if ( !pause && det_update_codebook_cC(pColor, cC[c],cbBounds,nChannels))
{
det_update_codebook_cD(pColor, cD[c],cbBounds,nChannels, nFrmNum);
realtime_clear_stale_entries_cD(cD[c], nFrmNum);
cD_to_cC(cD[c], cC[c], (nFrmNum - T)/5);
}
else
{
realtime_clear_stale_entries_cC(cC[c], nFrmNum);
}
maskPixelCodeBook2=background_Diff(pColor, cC[c],nChannels,minMod,maxMod);
*pMask2++ = maskPixelCodeBook2;
pColor += 3;
}
cvCopy(pFrImg2,ImaskCodeBookCC);
if(!pause)
{
count_Segmentation(cC,yuvImage,nChannels,minMod,maxMod);
forgratio = (float) (fgcount)/ imageLen;
}
}
bg_model1->foreground->origin=1;
bg_model->foreground->origin=1;
pFrImg->origin=1;
pFrImg1->origin=1;
pFrImg2->origin=1;
ImaskCodeBookCC->origin=1;
result->origin=1;
//connected_Components(pFrImg1,1,40);
//connected_Components(pFrImg2,1,40);
cvShowImage("基于MOG的方法[Chris Stauffer'2001]", bg_model->foreground);
cvShowImage( "原视频序列图像", rawImage );
cvShowImage("三帧差分", result);
cvShowImage( "不实时更新的Codebook算法[本文]",pFrImg1);
cvShowImage("实时更新的Codebook算法[本文]",pFrImg2);
cvShowImage("基于Bayes decision的方法[Liyuan Li'2003]", bg_model1->foreground);
c = cvWaitKey(1)&0xFF;
//End processing on ESC, q or Q
if(c == 27 || c == 'q' || c == 'Q')
break;
//Else check for user input
switch(c)
{
case 'h':
help();
break;
case 'p':
pause ^= 1;
break;
case 's':
singlestep = 1;
pause = false;
break;
case 'r':
pause = false;
singlestep = false;
break;
//CODEBOOK PARAMS
case 'y':
case '0':
ch[0] = 1;
ch[1] = 0;
ch[2] = 0;
printf("CodeBook YUV Channels active: ");
for(n=0; n<nChannels; n++)
printf("%d, ",ch[n]);
printf("\n");
break;
case 'u':
case '1':
ch[0] = 0;
ch[1] = 1;
ch[2] = 0;
printf("CodeBook YUV Channels active: ");
for(n=0; n<nChannels; n++)
printf("%d, ",ch[n]);
printf("\n");
break;
case 'v':
case '2':
ch[0] = 0;
ch[1] = 0;
ch[2] = 1;
printf("CodeBook YUV Channels active: ");
for(n=0; n<nChannels; n++)
printf("%d, ",ch[n]);
printf("\n");
break;
case 'a': //All
case '3':
ch[0] = 1;
ch[1] = 1;
ch[2] = 1;
printf("CodeBook YUV Channels active: ");
for(n=0; n<nChannels; n++)
printf("%d, ",ch[n]);
printf("\n");
break;
case 'b': //both u and v together
ch[0] = 0;
ch[1] = 1;
ch[2] = 1;
printf("CodeBook YUV Channels active: ");
for(n=0; n<nChannels; n++)
printf("%d, ",ch[n]);
printf("\n");
break;
case 'z':
printf(" Fadd加1 ");
Fadd += 1;
printf("Fadd=%.4d\n",Fadd);
break;
case 'x':
printf(" Fadd减1 ");
Fadd -= 1;
printf("Fadd=%.4d\n",Fadd);
break;
case 'n':
printf(" Tavgstale加1 ");
Tavgstale += 1;
printf("Tavgstale=%.4d\n",Tavgstale);
break;
case 'm':
printf(" Tavgstale减1 ");
Tavgstale -= 1;
printf("Tavgstale=%.4d\n",Tavgstale);
break;
case 'i': //modify max classification bounds (max bound goes higher)
for(n=0; n<nChannels; n++)
{
if(ch[n])
maxMod[n] += 1;
printf("%.4d,",maxMod[n]);
}
printf(" CodeBook High Side\n");
break;
case 'o': //modify max classification bounds (max bound goes lower)
for(n=0; n<nChannels; n++)
{
if(ch[n])
maxMod[n] -= 1;
printf("%.4d,",maxMod[n]);
}
printf(" CodeBook High Side\n");
break;
case 'k': //modify min classification bounds (min bound goes lower)
for(n=0; n<nChannels; n++)
{
if(ch[n])
minMod[n] += 1;
printf("%.4d,",minMod[n]);
}
printf(" CodeBook Low Side\n");
break;
case 'l': //modify min classification bounds (min bound goes higher)
for(n=0; n<nChannels; n++)
{
if(ch[n])
minMod[n] -= 1;
printf("%.4d,",minMod[n]);
}
printf(" CodeBook Low Side\n");
break;
}
}
}
cvReleaseCapture( &capture );
cvReleaseBGStatModel((CvBGStatModel**)&bg_model);
cvReleaseBGStatModel((CvBGStatModel**)&bg_model1);
cvDestroyWindow( "原视频序列图像" );
cvDestroyWindow( "不实时更新的Codebook算法[本文]");
cvDestroyWindow( "实时更新的Codebook算法[本文]");
cvDestroyWindow( "基于MOG的方法[Chris Stauffer'2001]");
cvDestroyWindow( "三帧差分" );
cvDestroyWindow( "基于Bayes decision的方法[Liyuan Li'2003]");
cvReleaseImage(&temp1);
cvReleaseImage(&temp2);
cvReleaseImage(&result);
cvReleaseImage(&result1);
cvReleaseImage(&result2);
cvReleaseImage(&pFrImg);
cvReleaseImage(&pFrImg1);
cvReleaseImage(&pFrImg2);
if(yuvImage) cvReleaseImage(&yuvImage);
if(rawImage) cvReleaseImage(&rawImage);
if(rawImage1) cvReleaseImage(&rawImage1);
if(ImaskCodeBookCC) cvReleaseImage(&ImaskCodeBookCC);
delete [] cA;
delete [] cC;
delete [] cD;
}
else
{
printf("\n\nDarn, Something wrong with the parameters\n\n"); help();
}
return 0;
}
