智能视频分析中的光照强度突然变化的处理方法

在智能视频分析系统的研究过程中,尤其是对于一些工程应用来说,光照的突然变化是一个很棘手的问题。尽管,不少学者对光照的突然变化进行了大量的研究,而且也提出了相关的光照不变的算法(illumination invariant),对解决这类问题提供了一定的思路。一般都是通过计算光照不变特征来实现,文章包括:

      1)An Illumination Invariant Change Detection Algorithm.

      2)Bayesian Illumination-Invariant Motion Detection.

      3)robust and illumination invariant change detection based on linear dependence for surveillance application.

      4)reflectance ratio-a photometric invariant for object recognition_ICCV93.

      5)computing reflectance ratios from an image_PR93.

      6)Color Invariant Edge Detection

      7)Learning Photometric Invariance for Object Detection-IJCV2010

      8)making background subtraction robust to sudden illumination changes

      9)Object Detection Using Local Difference Patterns.

       尽管,以上论文中的方法都声称对光照变化具有不变形,但是在实际中,有很多是靠不住的,可能说对缓慢光照的变化具有一定的鲁棒性更准确。有些算法的复杂度也是可待商榷的(如making background subtraction robust to sudden illumination changes)。

       根据实际情况,本文提出两种解决光照突然变化的方法,一是多模式的背景模型,而是背景重建,我想这也应该是工程中应用较多的途径和思路吧。

       多模式背景模型就是对一个场景建立多种环境下的背景模型,算法检测环境的变化,自动选择背景模型。如对于光照条件正常的情况建议一个背景模型,进行保存;而对于背景较暗的情况建立一个背景模型,也进行保存;如果有多种情况,就建立多个背景模型。(而对于缓慢的光照变化现在应该有很多算法能够处理)。

      而对另外的背景重建的思路,现在已经有相当普遍的算法能够就一帧建立起背景模型(如SOBS、VIBE等)。在检测到有突然光照变化的情况下,就进行背景模型的重建,接着对运动进行检测。然而,这种情况下,比较棘手的问题是如何判断光照的变化,很多论文上说的采用前景像素占整个图像大小的比例作为依据,然后改中方法在实际中也常常带有误判,误判率较高。本文介绍一种思路,而且经过试验也很不错,相比比率方法有了不少提高。

        思路如下:将整个图片进行分块,统计每一块的前景像素个数,当某块的前景像素大于某一个阈值时,则计数器+1,依次遍历整个图像,统计得到计数器的值,计算机计算器与整个图像块数的比值,比值大于某一阈值,则判断为光照突变。

         核心代码如下:

        1)图像分块

 

  1. // winSize default 32  
  2. void buildGrid( const Mat& input, vector<Rect>& grid, int winSize=32  )  
  3. {     
  4.     grid.clear();  
  5.     int height = input.rows;  
  6.     int width = input.cols;  
  7.     Rect rc;  
  8.     for ( int i=0; i<height; i=i+winSize)  
  9.     {  
  10.         for ( int j=0; j<width; j=j+winSize )  
  11.         {  
  12.             rc.y = i;  
  13.             rc.x = j;     
  14.             if (rc.x + winSize>width-1)  
  15.                 rc.width = width-rc.x-1;  
  16.             else  
  17.                 rc.width = winSize;  
  18.             if (rc.y+winSize>height)  
  19.                 rc.height = height-rc.y-1;  
  20.             else  
  21.                 rc.height = winSize;  
  22.             grid.push_back(rc);               
  23.         }  
  24.     }         
  25. }  


      2)计算比值

 

 

  1. // winSize default 32, ratio default 1.0/winSize  
  2. bool isSuddenChange( const  vector<Rect>& grid, Mat& foreground, int winSize=32, double ratio=1.0/32.0)  
  3. {  
  4.     int count = 0;  
  5.     int gridSize = grid.size();  
  6.   
  7.     for ( int i=0; i<gridSize; ++i )  
  8.     {  
  9.         int nonZero = countNonZero( foreground(grid[i]));  
  10.         double _r = double(nonZero)/(double)(winSize*winSize);  
  11.         //if ( nonZero>32)  
  12.         if ( _r> ratio)  
  13.             count++;          
  14.     }  
  15.     double ratio = (double)count/(float)gridSize;  
  16.     cout<<" NonZero ratio: "<<ratio<<endl;  
  17.     if ( ratio > 0.60 )  
  18.     {  
  19.         imwrite("fore.jpg",foreground);  
  20.         return true;  
  21.     }  
  22.     return false;  
  23. }  
posted @ 2015-05-12 12:58  于为  阅读(1219)  评论(1编辑  收藏  举报