遗留物检测算法及实现

算法一：

《An abandoned object detection system based on dual backgroundsegmentation》 IEEE 2009

搞了两个背景缓冲区：

Current_background：初始为第一帧，其后对每个像素，若下一帧像素大于该背景像素，则该出背景像素加1，否则该处背景像素减1。【挺神奇的，好处是This way, even if the foreground ischanging at a fast pace, it will not affect the background but if theforeground is stationary, it gradually merges into the background.但是效果还是不及混合高斯，因为适应期太长太频繁了】

 Buffer_background：论文上说每隔20秒更新一次，直接拷贝Current_background，遗留物检测直接通过Current_background和Buffer_background相减即可。【他这边认为一个遗留物丢弃满20秒，如果还在，则认为该遗留物为背景了】。随后，搞了一堆跟踪该区域的东西，我不太感兴趣。

 本文对上述的改进的目标是物体如果被遗弃了，那么它就应该一直被检测到。我额外搞了一个遗弃背景模版abandon_background，用于记录遗弃物之前的背景图像。

A.若物体离开，则abandon相应区域恢复到当前current的值，buffer更新为当前整个current。B.若物体未离开，则用abandon对buffer局部更新

整体算法：

1.      第一帧，用来初始化Current_background和Buffer_background

2.      通过两个背景区域计算遗留物

3.      每一帧更新Current_background

4.      若时间间隔满足，更新Buffer_background和遗弃物背景abandon_background，更新计数器

   a.      若遗弃物背景首次更新，根据current和buffer之差，在相应的地方赋current的值，其余为0

   b.      进行物体离开判断，即：若abandon与current对应区域背景像素不同，则物体还未离开，否则离开

   c.      若物体离开，将current更新abandon的相应区域，buffer复制完整的current

   d.      若物体未离开，将abandon更新buffer的相应区域，abandon保持不变。

5.      读取下一帧，返回2

代码：

调用的函数：

#include "Model.h"
#define Th 50
#define Ta 90

int first_update = 0;//首次更新标志

void calc_fore(IplImage *current,IplImage *back,IplImage *fore)
{
    int i,j;

    for (i=0;i<current->height;i++)
    {
        for (j=0;j<current->width;j++)
        {
            if (abs((u_char)current->imageData[i*current->widthStep+j] - (u_char)back->imageData[i*current->widthStep+j]) <=Ta )
            {
                fore->imageData[i*current->widthStep+j] = 0;//background
            }else
            {
                fore->imageData[i*current->widthStep+j] = 255;//foreground
            }
        }
    }
}

void update_currentback(IplImage *current,IplImage *curr_back)
{
    int i,j;
    int p,q;

    for (i=0;i<current->height;i++)
    {
        for (j=0;j<current->width;j++)
        {
            p = (u_char)current->imageData[i * current->widthStep + j];
            q = (u_char)curr_back->imageData[i * current->widthStep + j];
            //printf("%d,%d
",p,q);

            if (p >= q)
            {
                if (q == 255)
                {
                    q = 254;
                }
                curr_back->imageData[i * current->widthStep + j] = q + 1;
            }else
            {
                if (q == 0)
                {
                    q = 1;
                }
                curr_back->imageData[i * current->widthStep + j] = q - 1;
            }
        }
    }
}

void update_bufferedback(IplImage *curr_back,IplImage *buf_back,IplImage *abandon)
{
    int i,j,height,width;
    int leave_flag = 0;

    height = curr_back->height;
    width = curr_back->widthStep;

    if (first_update == 0)
    {
        for ( i = 0;i < height; i++)
        {
            for (j = 0;j < width; j++)
            {
                if (abs((u_char)curr_back->imageData[i*width+j] - (u_char)buf_back->imageData[i*width+j]) <=Th )
                {
                    abandon->imageData[i*width+j] = 0;//background
                }else
                {
                    abandon->imageData[i*width+j] = curr_back->imageData[i*width+j];//foreground
                    first_update = 1;
                }
            }
        }
        return;
    }

    //物体离开判断
    for ( i = 0;i < height; i++)
    {
        for (j = 0;j < width; j++)
        {
            if (abandon->imageData[i*width+j] != 0)
            {
                if (abandon->imageData[i*width+j] != curr_back->imageData[i*width+j])
                {
                    leave_flag = 1;                 //物体掩膜处之前背景与当前的不一致，1：物体未离开，0：物体离开
                }
            }
        }
    }

    if(leave_flag == 0)     //物体离开
    {
        cvCopy(curr_back,buf_back);
        for ( i = 0;i < height; i++)
        {
            for (j = 0;j < width; j++)
            {
                if (abandon->imageData[i*width+j] != 0)
                {
                    abandon->imageData[i*width+j] = curr_back->imageData[i*width+j];
                }
            }
        }
    }else
    {
        for ( i = 0;i < height; i++)
        {
            for (j = 0;j < width; j++)
            {
                if (abandon->imageData[i*width+j] != 0)
                {
                    buf_back->imageData[i*width+j] = abandon->imageData[i*width+j];
                }
            }
        }
    }


}

主函数：

// abandon_left.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Model.h"

int _tmain(int argc, _TCHAR* argv[])
{
    CvCapture *capture=cvCreateFileCapture("test.avi");
    IplImage *current_back,*buff_back,*abandon,*frame,*current_img,*fore;
    int count,intern;

    frame = cvQueryFrame(capture);
    fore = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    current_back = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    current_img = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    buff_back = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    abandon = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);

    count=0;
    intern = count + 20;

    while (1)
    {
        cvCvtColor(frame,current_img,CV_RGB2GRAY);

        if (count == 0)
        {
            //初始化背景模版
            cvCopy(current_img,current_back);
            cvCopy(current_img,buff_back);
        }

        if (count > 0)
        {
            //计算前景掩膜
            calc_fore(current_back,buff_back,fore);

            //更新跟踪背景
            update_currentback(current_img,current_back);

            if (count == intern)
            {
                update_bufferedback(current_back,buff_back,abandon);
                intern = count + 20;
            }
            cvShowImage("current",current_img);
            cvShowImage("current_back",current_back);
            cvShowImage("buff_back",buff_back);
            cvShowImage("abandon detection",fore);
        }

        count++;
        frame =cvQueryFrame(capture);

        if (cvWaitKey(23)>=0)
        {
            break;
        }
    }
    cvNamedWindow("current",0);
    cvNamedWindow("buff_back",0);
    cvNamedWindow("current_back",0);
    cvNamedWindow("abandon detection",0);
    cvReleaseCapture(&capture);
    return 0;
}

效果图：

说明：左下角有个女的运动规律也符合静止目标检测规律，所以也被检测出来了。后期可以通过外接矩形长宽比等其他手段过滤掉。

视频+代码工程的下载连接：http://download.csdn.net/detail/jinshengtao/7157943

算法二：

《一种基于双背景模型的遗留物检测方法》

搞了个脏背景和纯背景，定义：

当视频场景中不出现运动目标，或者背景不受场景中所出现的运动目标影响时，这样的背景称为纯背景。否则，称为脏背景

它们的更新规则：

一般背景的更新按照帧间差分法：

脏背景使用全局更新，直接赋值一般背景：

纯背景根据前景掩膜，进行局部更新，即若前景掩膜被标记为运动的部分，则相应的纯背景区域用上一帧的纯背景更新；若前景掩膜被标记为非运动的部分，则相应的纯背景区域用当前帧的一般背景更新。

静止目标前景检测算法可以通过以下公式看明白：

具体算法流程不给咯，论文没提，自己摸索的，反正试验效果失败了。

代码：

// left_bag.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "cv.h"
#include "highgui.h"
#define u_char unsigned char
#define alfa 0.03
#define Th 60
#define Ta 60
#define Tb 40

void calc_fore(IplImage *current,IplImage *back,IplImage *fore)
{
    int i,j;

    for (i=0;i<current->height;i++)
    {
        for (j=0;j<current->width;j++)
        {
            if (abs((u_char)current->imageData[i*current->widthStep+j] - (u_char)back->imageData[i*current->widthStep+j]) <=Th )
            {
                fore->imageData[i*current->widthStep+j] = 0;//background
            }else
            {
                fore->imageData[i*current->widthStep+j] = 255;//foreground
            }
        }
    }
}

void update_back(IplImage *current,IplImage *back,IplImage *B_p,IplImage *B_d,IplImage *fore,IplImage *B_p_pre)
{
    int i,j;

    //更新B_n
    for (i=0;i<current->height;i++)
    {
        for (j=0;j<current->width;j++)
        {
            back->imageData[i*current->widthStep+j] = (1-alfa)*current->imageData[i*current->widthStep+j] + alfa * back->imageData[i*current->widthStep+j];
        }
    }

    //更新B_d
    cvCopy(back,B_d);

    //更新B_p
    for (i = 0;i < fore->height;i++)
    {
        for (j = 0;j < fore->width;j++)
        {
            if ((unsigned char)fore->imageData[i*fore->widthStep + j ] == 255)
            {
                B_p->imageData[i*fore->widthStep + j] = B_p_pre->imageData[i*fore->widthStep + j];
            }else
            {
                B_p->imageData[i*fore->widthStep + j] = back->imageData[i*fore->widthStep + j];
            }
        }
    }
}

void calc_StaticTarget(IplImage *current,IplImage *B_d,IplImage *B_p,IplImage *M_s,IplImage *M_m,IplImage *M_f)
{
    int i,j;

    for (i = 0;i < current->height;i++)
    {
        for (j = 0;j < current->width;j++)
        {
            if (abs((u_char)current->imageData[i*current->widthStep+j] - (u_char)B_d->imageData[i*current->widthStep+j]) <= Th )
            {
                M_s->imageData[i*current->widthStep+j] = 255;
            }else
            {
                M_s->imageData[i*current->widthStep+j] = 0;
            }

            if (abs((u_char)B_p->imageData[i*current->widthStep+j] - (u_char)B_d->imageData[i*current->widthStep+j]) > Tb)
            {
                M_m->imageData[i*current->widthStep+j] = 255;
            }else
            {
                M_m->imageData[i*current->widthStep+j] = 0;
            }

            if (((unsigned char)M_m->imageData[i*current->widthStep+j] == 255) &&((unsigned char)M_s->imageData[i*current->widthStep+j] == 255))
            {
                M_f->imageData[i*current->widthStep+j] = 255;
            }else
            {
                M_f->imageData[i*current->widthStep+j] = 0;
            }
        }
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    CvCapture *capture=cvCreateFileCapture("test.avi");
    IplImage *frame,*current_img,*B_n,*B_p,*B_d,*B_p_pre;
    IplImage *M,*M1,*M_s,*M_m,*M_f;
    int count,i,j;

    frame = cvQueryFrame(capture);
    current_img = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    B_n = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    B_p = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    B_d = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    B_p_pre = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);

    M = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    M1 = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    M_s = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    M_m = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
    M_f = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);

    count=0;
    while (1)
    {
        cvCvtColor(frame,current_img,CV_RGB2GRAY);

        if (count == 0)
        {
            //初始化各种背景模版
            cvCopy(current_img,B_n);
            cvCopy(current_img,B_p);
            cvCopy(current_img,B_d);
            cvCopy(current_img,B_p_pre);
        }

        if (count > 1)
        {
            //计算前景掩膜
            calc_fore(current_img,B_n,M1);

            //膨胀腐蚀操作
            cvDilate(M1, M, 0, 1);
            cvErode(M, M1, 0, 2);
            cvDilate(M1, M, 0,1);

            //静止目标检测
            calc_StaticTarget(current_img,B_d,B_p,M_s,M_m,M_f);

            //更新跟踪背景
            update_back(current_img,B_n,B_p,B_d,M,B_p_pre);

            cvShowImage("pure ground",B_p);
            cvShowImage("dirty ground",B_d);
            cvShowImage("static target",M_f);
            cvShowImage("fore ground",M);
            cvCopy(B_p,B_p_pre);
        }

        count++;
        frame =cvQueryFrame(capture);


        if (cvWaitKey(23)>=0)
        {
            break;
        }
    }
    cvNamedWindow("pure ground",0);
    cvNamedWindow("dirty ground",0);
    cvNamedWindow("static target",0);
    cvNamedWindow("fore ground",0);
    cvReleaseCapture(&capture);
    return 0;
}

算法三【MATLAB toolbox中的一个demo】

理论部分没看，在控制台直接输入：edit videoabandonedobj 会有相应的代码跳出来。

在help中搜索Abandoned Object Detection，会有理论部分介绍

视频素材下载地址：http://www.mathworks.cn/products/viprocessing/vipdemos.html

代码：【2010b 版本可跑】

clc;
clear;

status = videogetdemodata('viptrain.avi');
if ~status
    displayEndOfDemoMessage(mfilename);
    return;
end

roi = [80 100 240 360];
% Maximum number of objects to track
maxNumObj = 200;
% Number of frames that an object must remain stationary before an alarm is
% raised
alarmCount = 45;
% Maximum number of frames that an abandoned object can be hidden before it
% is no longer tracked
maxConsecutiveMiss = 4;
% Maximum allowable change in object area in percent
areaChangeFraction = 15;
% Maximum allowable change in object centroid in percent
centroidChangeFraction = 20;
% Minimum ratio between the number of frames in which an object is detected
% and the total number of frames, for that object to be tracked.
minPersistenceRatio = 0.7;
% Offsets for drawing bounding boxes in original input video
PtsOffset = int32(repmat([roi(1); roi(2); 0 ; 0],[1 maxNumObj]));

hVideoSrc = video.MultimediaFileReader;
hVideoSrc.Filename = 'viptrain.avi';
hVideoSrc.VideoOutputDataType = 'single';

hColorConv = video.ColorSpaceConverter;
hColorConv.Conversion = 'RGB to YCbCr';

hAutothreshold = video.Autothresholder;
hAutothreshold.ThresholdScaleFactor = 1.3;

hClosing = video.MorphologicalClose;
hClosing.Neighborhood = strel('square',5);

hBlob = video.BlobAnalysis;
hBlob.MaximumCount = maxNumObj;
hBlob.NumBlobsOutputPort = true;
hBlob.MinimumBlobAreaSource = 'Property';
hBlob.MinimumBlobArea = 100;
hBlob.MaximumBlobAreaSource = 'Property';
hBlob.MaximumBlobArea = 2500;
hBlob.ExcludeBorderBlobs = true;

hDrawRectangles1 = video.ShapeInserter;
hDrawRectangles1.Fill = true;
hDrawRectangles1.FillColor = 'Custom';
hDrawRectangles1.CustomFillColor = [1 0 0];
hDrawRectangles1.Opacity = 0.5;

hDisplayCount = video.TextInserter;
hDisplayCount.Text = '%4d';
hDisplayCount.Color = [1 1 1];

hAbandonedObjects = video.VideoPlayer;
hAbandonedObjects.Name = 'Abandoned Objects';
hAbandonedObjects.Position = [10 300 roi(4)+25 roi(3)+25];

hDrawRectangles2 = video.ShapeInserter;
hDrawRectangles2.BorderColor = 'Custom';
hDrawRectangles2.CustomBorderColor = [0 1 0];

hDrawBBox = video.ShapeInserter;
hDrawBBox.BorderColor = 'Custom';
hDrawBBox.CustomBorderColor = [1 1 0];

hAllObjects = video.VideoPlayer;
hAllObjects.Position = [45+roi(4) 300 roi(4)+25 roi(3)+25];
hAllObjects.Name = 'All Objects';

hDrawRectangles3 = video.ShapeInserter;
hDrawRectangles3.BorderColor = 'Custom';
hDrawRectangles3.CustomBorderColor = [0 1 0];

hThresholdDisplay = video.VideoPlayer;
hThresholdDisplay.Position = ...
            [80+2*roi(4) 300 roi(4)-roi(2)+25 roi(3)-roi(1)+25];
hThresholdDisplay.Name = 'Threshold';

firsttime = true;
while ~isDone(hVideoSrc)
    Im = step(hVideoSrc);

    % Select the region of interest from the original video
    OutIm = Im(roi(1):end, roi(2):end, :);

    YCbCr = step(hColorConv, OutIm);
    CbCr  = complex(YCbCr(:,:,2), YCbCr(:,:,3));

    % Store the first video frame as the background
    if firsttime
        firsttime = false;
        BkgY      = YCbCr(:,:,1);
        BkgCbCr   = CbCr;
    end
    SegY    = step(hAutothreshold, abs(YCbCr(:,:,1)-BkgY));
    SegCbCr = abs(CbCr-BkgCbCr) > 0.05;

    % Fill in small gaps in the detected objects
    Segmented = step(hClosing, SegY | SegCbCr);

    % Perform blob analysis
    [Area, Centroid, BBox, Count] = step(hBlob, Segmented);

    % Call the helper function that tracks the identified objects and
    % returns the bounding boxes and the number of the abandoned objects.
    [OutCount, OutBBox] = videoobjtracker(Area, Centroid, BBox, Count,...
       areaChangeFraction, centroidChangeFraction, maxConsecutiveMiss, ...
       minPersistenceRatio, alarmCount);

    % Display the abandoned object detection results
    Imr = step(hDrawRectangles1, Im, OutBBox+PtsOffset);
    Imr(1:15,1:30,:) = 0;
    Imr = step(hDisplayCount, Imr, OutCount);
    step(hAbandonedObjects, Imr);

    % Display all the detected objects
    Imr = step(hDrawRectangles2, Im, BBox+PtsOffset);
    Imr(1:15,1:30,:) = 0;
    Imr = step(hDisplayCount, Imr, OutCount);
    Imr = step(hDrawBBox, Imr, roi);
    step(hAllObjects, Imr);

    % Display the segmented video
    SegIm = step(hDrawRectangles3, repmat(Segmented,[1 1 3]), BBox);
    step(hThresholdDisplay, SegIm);
end

release(hVideoSrc);