运动检测（前景检测）

最新推荐文章于 2018-10-01 17:09:18 发布

原创最新推荐文章于 2018-10-01 17:09:18 发布 · 1.1k 阅读

1 ·

CC 4.0 BY-SA版权

机器视觉算法专栏收录该内容

15 篇文章

订阅专栏

ViBe是一种像素级视频背景建模或前景检测的算法，效果优于所熟知的几种算法，对硬件内存占用也少，很简单。我之前根据stellar0的代码（在这里，非常感谢stellar0）改写成一个Mat格式的代码了，现在摆上来和大家交流，具体如下：（在VS2010+OpenCV2.4.2中测试通过）

ViBe.h

[cpp]view plaincopy 
   
 #pragma once  
 #include <iostream>  
 #include "opencv2/opencv.hpp"  
   
 using namespace cv;  
 using namespace std;  
   
 #define NUM_SAMPLES 20      //每个像素点的样本个数  
 #define MIN_MATCHES 2       //#min指数  
 #define RADIUS 20       //Sqthere半径  
 #define SUBSAMPLE_FACTOR 16 //子采样概率  
   
   
 class ViBe_BGS  
 {  
 public:  
     ViBe_BGS(void);  
     ~ViBe_BGS(void);  
   
     void init(const Mat _image);   //初始化  
     void processFirstFrame(const Mat _image);  
     void testAndUpdate(const Mat _image);  //更新  
     Mat getMask(void){return m_mask;};  
   
 private:  
     Mat m_samples[NUM_SAMPLES];  
     Mat m_foregroundMatchCount;  
     Mat m_mask;  
 };  

ViBe.cpp

[cpp]view plaincopy 
   
 #include <opencv2/opencv.hpp>  
 #include <iostream>  
 #include "ViBe.h"  
   
 using namespace std;  
 using namespace cv;  
   
 int c_xoff[9] = {-1,  0,  1, -1, 1, -1, 0, 1, 0};  //x的邻居点  
 int c_yoff[9] = {-1,  0,  1, -1, 1, -1, 0, 1, 0};  //y的邻居点  
   
 ViBe_BGS::ViBe_BGS(void)  
 {  
   
 }  
 ViBe_BGS::~ViBe_BGS(void)  
 {  
   
 }  
   
 /**************** Assign space and init ***************************/  
 void ViBe_BGS::init(const Mat _image)  
 {  
      for(int i = 0; i < NUM_SAMPLES; i++)  
      {  
          m_samples[i] = Mat::zeros(_image.size(), CV_8UC1);  
      }  
      m_mask = Mat::zeros(_image.size(),CV_8UC1);  
      m_foregroundMatchCount = Mat::zeros(_image.size(),CV_8UC1);  
 }  
   
 /**************** Init model from first frame ********************/  
 void ViBe_BGS::processFirstFrame(const Mat _image)  
 {  
     RNG rng;  
     int row, col;  
   
     for(int i = 0; i < _image.rows; i++)  
     {  
         for(int j = 0; j < _image.cols; j++)  
         {  
              for(int k = 0 ; k < NUM_SAMPLES; k++)  
              {  
                  // Random pick up NUM_SAMPLES pixel in neighbourhood to construct the model  
                  int random = rng.uniform(0, 9);  
   
                  row = i + c_yoff[random];  
                  if (row < 0)   
                      row = 0;  
                  if (row >= _image.rows)  
                      row = _image.rows - 1;  
   
                  col = j + c_xoff[random];  
                  if (col < 0)   
                      col = 0;  
                  if (col >= _image.cols)  
                      col = _image.cols - 1;  
   
                  m_samples[k].at<uchar>(i, j) = _image.at<uchar>(row, col);  
              }  
         }  
     }  
 }  
   
 /**************** Test a new frame and update model ********************/  
 void ViBe_BGS::testAndUpdate(const Mat _image)  
 {  
     RNG rng;  
   
     for(int i = 0; i < _image.rows; i++)  
     {  
         for(int j = 0; j < _image.cols; j++)  
         {  
             int matches(0), count(0);  
             float dist;  
   
             while(matches < MIN_MATCHES && count < NUM_SAMPLES)  
             {  
                 dist = abs(m_samples[count].at<uchar>(i, j) - _image.at<uchar>(i, j));  
                 if (dist < RADIUS)  
                     matches++;  
                 count++;  
             }  
   
             if (matches >= MIN_MATCHES)  
             {  
                 // It is a background pixel  
                 m_foregroundMatchCount.at<uchar>(i, j) = 0;  
   
                 // Set background pixel to 0  
                 m_mask.at<uchar>(i, j) = 0;  
   
                 // 如果一个像素是背景点，那么它有 1 / defaultSubsamplingFactor 的概率去更新自己的模型样本值  
                 int random = rng.uniform(0, SUBSAMPLE_FACTOR);  
                 if (random == 0)  
                 {  
                     random = rng.uniform(0, NUM_SAMPLES);  
                     m_samples[random].at<uchar>(i, j) = _image.at<uchar>(i, j);  
                 }  
   
                 // 同时也有 1 / defaultSubsamplingFactor 的概率去更新它的邻居点的模型样本值  
                 random = rng.uniform(0, SUBSAMPLE_FACTOR);  
                 if (random == 0)  
                 {  
                     int row, col;  
                     random = rng.uniform(0, 9);  
                     row = i + c_yoff[random];  
                     if (row < 0)   
                         row = 0;  
                     if (row >= _image.rows)  
                         row = _image.rows - 1;  
   
                     random = rng.uniform(0, 9);  
                     col = j + c_xoff[random];  
                     if (col < 0)   
                         col = 0;  
                     if (col >= _image.cols)  
                         col = _image.cols - 1;  
   
                     random = rng.uniform(0, NUM_SAMPLES);  
                     m_samples[random].at<uchar>(row, col) = _image.at<uchar>(i, j);  
                 }  
             }  
             else  
             {  
                 // It is a foreground pixel  
                 m_foregroundMatchCount.at<uchar>(i, j)++;  
   
                 // Set background pixel to 255  
                 m_mask.at<uchar>(i, j) = 255;  
   
                 //如果某个像素点连续N次被检测为前景，则认为一块静止区域被误判为运动，将其更新为背景点  
                 if (m_foregroundMatchCount.at<uchar>(i, j) > 50)  
                 {  
                     int random = rng.uniform(0, SUBSAMPLE_FACTOR);  
                     if (random == 0)  
                     {  
                         random = rng.uniform(0, NUM_SAMPLES);  
                         m_samples[random].at<uchar>(i, j) = _image.at<uchar>(i, j);  
                     }  
                 }  
             }  
         }  
     }  
 }  

Main.cpp

[cpp]view plaincopy 
   
 // This is based on   
 // "VIBE: A POWERFUL RANDOM TECHNIQUE TO ESTIMATE THE BACKGROUND IN VIDEO SEQUENCES"  
 // by Olivier Barnich and Marc Van Droogenbroeck  
 // Author : zouxy  
 // Date   : 2013-4-13  
 // HomePage : http://blog.youkuaiyun.com/zouxy09  
 // Email  : zouxy09@qq.com  
   
 #include "opencv2/opencv.hpp"  
 #include "ViBe.h"  
 #include <iostream>  
 #include <cstdio>  
   
 using namespace cv;  
 using namespace std;  
   
 int main(int argc, char* argv[])  
 {  
     Mat frame, gray, mask;  
     VideoCapture capture;  
     capture.open("video.avi");  
   
     if (!capture.isOpened())  
     {  
         cout<<"No camera or video input!\n"<<endl;  
         return -1;  
     }  
   
     ViBe_BGS Vibe_Bgs;  
     int count = 0;  
   
     while (1)  
     {  
         count++;  
         capture >> frame;  
         if (frame.empty())  
             break;  
         cvtColor(frame, gray, CV_RGB2GRAY);  
       
         if (count == 1)  
         {  
             Vibe_Bgs.init(gray);  
             Vibe_Bgs.processFirstFrame(gray);  
             cout<<" Training GMM complete!"<<endl;  
         }  
         else  
         {  
             Vibe_Bgs.testAndUpdate(gray);  
             mask = Vibe_Bgs.getMask();  
             morphologyEx(mask, mask, MORPH_OPEN, Mat());  
             imshow("mask", mask);  
         }  
   
         imshow("input", frame);   
   
         if ( cvWaitKey(10) == 'q' )  
             break;  
     }  
   
     return 0;  
 }  