运动目标检测&单高斯背景建模

1.运动目标背景建模

背景建模也称为背景估计，其主要目的是根据当前的背景估计，把对序列图像的运动目标检测问题转化为一个二分类问题，将所有像素划分为背景和运动前景两类，进而对分类结果进行后处理，得到最终检测结果。比较简单的获取背景图像的方法是当场景中无任何运动目标出现时捕获背景图像，但这种方法不能实现自适应，通常仅适应于对场景的短时间监控，不能满足智能监控系统对背景建模的要求。
背景减除法的关键是背景模型，它是背景减除法分割运动前景的基础。背景模型主要有单模态和多模态两种，前者在每个背景像素上的颜色分布比较集中，可以用单分布概率模型来描述，后者的分布则比较分散，需要多分布概率模型来共同描述。在许多应用场景，如水面的波纹、摇摆的树枝、飘扬的旗帜、监视器屏幕等，像素值都呈现出多模态特性。最常用的描述场景背景像素颜色分布的概率密度函数是高斯分布。

2.单高斯背景建模

高斯背景模型是一种运动目标检测过程中提取并更新背景和前景的一种方法。
单分布高斯背景模型认为，对一个背景图像，特定像素亮度的分布满足高斯分布，即对背景图像B，每一个点(x,y)的亮度满足B(x,y)~N(u,d)：

即每一个点（x,y)都包含了两个属性，均值u和方差d:

计算一段时间内的视频序列图像中每一个点的均值u和方差d，作为背景模型。对于一幅包含前景的任意图像G，对于图像上的每一个点（x,y）计算，若：

（T为一个常数阈值），则认为该点是背景点，否则为前景点。接下来就背景的更新，每一帧图像都参与背景的更新：

 

其中，p为一个常数，用来反映背景更新率，p越大，背景更新的越慢。一般情况下，背景更新后d的变化很小，所以在更新背景以后一般不再更新d。

3.MATLAB仿真及输出结果

     
     

       
       

        
        

       
       
       
       

        
        

         
         %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %Author：Ziheng H. Shen @Tsinghua Univ.
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %Date:
         
         20170308  @Digital Image Process Practice
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         clear all  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %% 读入视频，并记录帧率
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         fileName = 
         
         ‘768x576.avi’;   
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         Video = VideoReader(fileName);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         numFrames = Video.NumberOfFrames;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         frame = read(Video,
         
         1);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %% 用第一帧图像数据初始化背景模型
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         alpha   = 
         
         0.03;     %背景建模alpha值  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         stdInit = 
         
         20;       %初始化标准差  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         varInit = stdInit * stdInit ;    %初始化方差  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         lamda   = 
         
         2.5*
         
         1.2 ; %背景更新参数   
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         [h,w] = size(frame);%提取第一帧图像的高度和宽度  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         w = w/
         
         3;  %彩色图像RGB，所以需要除以
         
         3  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         for i=
         
         1:h  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
    
         
         for j=
         
         1:w  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 pixel_R = frame(i,j,
         
         1); pixel_G = frame(i,j,
         
         2);  pixel_B = frame(i,j,
         
         3);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 %期望图像为原图,背景
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 pixel_uR = pixel_R;  pixel_ug = pixel_G;  pixel_ub = pixel_B;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 %前景图像初始化为
         
         0  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 pixel_dr = 
         
         0;  pixel_dg = 
         
         0;  pixel_db = 
         
         0;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 %标准差 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 pixel_stdr = stdInit;  pixel_stdg = stdInit;  pixel_stdb = stdInit; 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 %方差
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 pixel_varr = varInit;  pixel_varg = varInit;  pixel_varb = varInit;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
          
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 frame_u(i,j,
         
         1:
         
         3)   = [pixel_uR pixel_ug pixel_ub];  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 frame_d(i,j,
         
         1:
         
         3)   = [pixel_dr pixel_dg pixel_db];  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 fram_std(i,j,
         
         1:
         
         3)  = [pixel_stdr pixel_stdg pixel_stdb];  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                 frame_var(i,j,
         
         1:
         
         3) = [pixel_varr pixel_varg pixel_varb];       
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
             end  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         end   
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         %% 单高斯背景更新  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
 
         
         for k = 
         
         1 : 
         
         5%numFrames % 读取帧数据  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              frame = read(Video,k);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
     
         
         for i=
         
         1:h   
        
        
       
       

       
       

        
        

       
       
       
       

        
        
         
         
         for j=
         
         1:w  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       pixel_R = frame(i,j,
         
         1);   pixel_G = frame(i,j,
         
         2);  pixel_B = frame(i,j,
         
         3);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       %期望图像(背景),初始化为第一帧图  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       pixel_uR = frame_u(i,j,
         
         1);  pixel_ug = frame_u(i,j,
         
         2);  pixel_ub = frame_u(i,j,
         
         3);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       %前景图像，初始为
         
         0 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       pixel_dr =  frame_d(i,j,
         
         1);  pixel_dg =  frame_d(i,j,
         
         2);  pixel_db =  frame_d(i,j,
         
         3); 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       %标准差  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       pixel_stdr =  fram_std(i,j,
         
         1);  pixel_stdg =  fram_std(i,j,
         
         2);  pixel_stdb =  fram_std(i,j,
         
         3);  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       %方差   
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       pixel_varr = frame_var(i,j,
         
         1);  pixel_varg = frame_var(i,j,
         
         2);  pixel_varb = frame_var(i,j,
         
         3); 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                       %|I-u|<lamda*
         
         std时认为是背景，进行背景更新  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
              
         
         if(  (
         
         abs(pixel_R-pixel_uR)<lamda*pixel_stdr) &&…
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                            (
         
         abs(pixel_G-pixel_ug)<lamda*pixel_stdg) &&…
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                            (
         
         abs(pixel_B-pixel_ub)<lamda*pixel_stdb)      )  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           %更新期望，u=(
         
         1-alpha)*u+alpha*
         
         1  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_uR = (
         
         1-alpha)* pixel_uR + alpha * pixel_R;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_ug = (
         
         1-alpha)* pixel_ug + alpha * pixel_G;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_ub = (
         
         1-alpha)* pixel_ub + alpha * pixel_B;     
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           %更新方差var=(
         
         1-alpha)*var+alpha*(I-u)^
         
         2  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_varr = (
         
         1-alpha)*pixel_varr + alpha*(pixel_R-pixel_uR)^
         
         2;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_varg = (
         
         1-alpha)*pixel_varg + alpha*(pixel_G-pixel_ug)^
         
         2;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_varb = (
         
         1-alpha)*pixel_varb + alpha*(pixel_B-pixel_ub)^
         
         2;    
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           %更新标准差  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_stdr = 
         
         sqrt(
         
         double(pixel_varr));  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_stdg = 
         
         sqrt(
         
         double(pixel_varg));  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           pixel_stdb = 
         
         sqrt(
         
         double(pixel_varb));  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           %图像内容更新  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           frame_u(i,j,
         
         1:
         
         3) = [pixel_uR pixel_ug pixel_ub];   
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           fram_std(i,j,
         
         1:
         
         3) = [pixel_stdr pixel_stdg pixel_stdb];  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                           frame_var(i,j,
         
         1:
         
         3) = [pixel_varr pixel_varg pixel_varb];         
        
        
       
       

       
       

        
        

       
       
       
       

        
        
              
         
         else  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                         pixel_dr =  pixel_R -  pixel_uR;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                         pixel_dg =  pixel_G -  pixel_ug;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                         pixel_db =  pixel_B -  pixel_ub;  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                         frame_d(i,j,
         
         1:
         
         3) = [pixel_dr pixel_dg pixel_db];  
        
        
       
       

       
       

        
        

       
       
       
       

        
        
              
         
         end 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
                  end  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              end  
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              figure(2*k-2)  %查看每一帧循环下来的结果 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              imshow(frame_u); %背景
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              figure(
         
         3*k
         
         -1)
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              imshow(frame_d); %前景
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              figure(
         
         3*k)  %先腐蚀后膨胀
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              disk = strel(
         
         ‘disk’,
         
         1); 
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              frame_d = imdilate(imerode(frame_d,disk),disk),disk;
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
              imshow(frame_d); %前景
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
          end    
        
        
       
       

       
       

        
        

       
       
       
       

        
        

       
       
     
     

输出结果（背景->前景->目标检测）

   

需要说明的是，单高斯模型受初始化参数和第一帧图像影响很大。

转载自：https://blog.csdn.net/shenziheng1/article/details/60881160