精华内容
下载资源
问答
  • 基于改进高斯混合模型前景检测
  • 基于混合高斯模型前景目标检测,代码已调通,只需把读入的文件名称改成相同路径下自己的文件名即可。
  • 高斯混合模型有效更新前景物体检测结果准确
  • Matlab自带的computer vision toolbox主要是toolbox里的vision模块,下面使用vision工具箱自带的混合高斯模型检测前景。 二、代码 %GMM前景检测 foregroundDetector = vision.ForegroundDetector('NumGaussians', ...

    一、前言

    Matlab自带的computer vision toolbox主要是toolbox里的vision模块,下面使用vision工具箱自带的混合高斯模型检测前景。

    二、代码

    %GMM前景检测
    foregroundDetector = vision.ForegroundDetector('NumGaussians', 3, ...
        'NumTrainingFrames', 20);
    
    videoReader = vision.VideoFileReader('Crowd-Activity-All.avi');
    while ~isDone(videoReader)
        frame = step(videoReader); % read the next video frame
        foreground = step(foregroundDetector, frame);
        
         subplot(1,2,1);
         imshow(frame);
         title('Video Frame');
        
        subplot(1,2,2);
        imshow(foreground);
        title('Foreground');
        pause(0.001);
       
    end

    三、结果






    展开全文
  • 通过将帧差法引入高斯混合模型,快速区分背景区域和运动目标区域,从而提取前景中完整的行人目标。结合视频帧边缘和边缘帧差信息,采用多种模型更新率,提高高斯混合模型对复杂背景的自适应性和快速收敛性,从而消除...
  • 用这种改进的混合高斯模型来获取运动物体的边缘图像和前景图像。对边缘图像进行图像膨胀,再与前景图像进行与运算,通过光流信息来填补空洞部分,得到最后的结果。实验结果表明,可以很好地去除噪音和解决光照突变的...
  • import numpy as np import cv2 # cap = cv2.VideoCapture("1594789861366240.mp4") kernel = np.ones((5,5),np.uint8) fgbg = cv2.createBackgroundSubtractorMOG2() # 获得视频的格式 videoCapture = cv2....
    import numpy as np
    import cv2
    #
    cap = cv2.VideoCapture("1594789861366240.mp4")
    kernel = np.ones((5,5),np.uint8)
    fgbg = cv2.createBackgroundSubtractorMOG2()
    
    # 获得视频的格式
    videoCapture = cv2.VideoCapture('1594789861366240.mp4')
    
    # 获得码率及尺寸
    fps = videoCapture.get(cv2.CAP_PROP_FPS)
    size = (int(videoCapture.get(cv2.CAP_PROP_FRAME_WIDTH)),
            int(videoCapture.get(cv2.CAP_PROP_FRAME_HEIGHT)))
    fNUMS = videoCapture.get(cv2.CAP_PROP_FRAME_COUNT)
    
    # 读帧
    success, frame = videoCapture.read()
    while success:
        fgmask = fgbg.apply(frame)
        fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel)
        contours = cv2.findContours(fgmask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[0]
        for c in contours:
            perimeter = cv2.arcLength(c,True)
            if perimeter > 800:
                x,y,w,h = cv2.boundingRect(c)
                cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)
    
        cv2.imshow('frame',frame)
        cv2.imshow('windows', fgmask)  # 显示
        if cv2.waitKey(int(1000 / int(fps))) == 27:
            break# 延迟
    
        success, frame = videoCapture.read()  # 获取下一帧
    
    
    videoCapture.release()
    
    
    展开全文
  • 运动检测(前景检测)之(二)混合高斯模型GMM zouxy09@qq.com http://blog.csdn.net/zouxy09 因为监控发展的需求,目前前景检测的研究还是很多的,也出现了很多新的方法和思路。个人了解的大概概括为以下一些...

    运动检测(前景检测)之(二)混合高斯模型GMM

    zouxy09@qq.com

    http://blog.csdn.net/zouxy09

     

            因为监控发展的需求,目前前景检测的研究还是很多的,也出现了很多新的方法和思路。个人了解的大概概括为以下一些:

    帧差、背景减除(GMM、CodeBook、 SOBS、 SACON、 VIBE、 W4、多帧平均……)、光流(稀疏光流、稠密光流)、运动竞争(Motion Competition)、运动模版(运动历史图像)、时间熵……等等。如果加上他们的改进版,那就是很大的一个家族了。

            对于上一些方法的一点简单的对比分析可以参考下:

    http://www.cnblogs.com/ronny/archive/2012/04/12/2444053.html

            至于哪个最好,看使用环境吧,各有千秋,有一些适用的情况更多,有一些在某些情况下表现更好。这些都需要针对自己的使用情况作测试确定的。呵呵。

            推荐一个牛逼的库:http://code.google.com/p/bgslibrary/里面包含了各种背景减除的方法,可以让自己少做很多力气活。

            还有王先荣博客上存在不少的分析:

    http://www.cnblogs.com/xrwang/archive/2010/02/21/ForegroundDetection.html

            下面的博客上转载王先荣的上面几篇,然后加上自己分析了两篇:

    http://blog.csdn.net/stellar0

     

            本文主要关注其中的一种背景减除方法:GMM。tornadomeet的博客上对ViBe进行了分析,我这里就不再啰嗦了,具体的理论分析可以参考:

    http://www.cnblogs.com/tornadomeet/archive/2012/06/02/2531565.html

            里面有了GMM的代码,并有了详细的注释。我之前根据这个代码(在这里,非常感谢tornadomeet)改写了一个Mat格式的版本,现在发上来和大家交流,具体如下:(在VS2010+OpenCV2.4.2中测试通过)。(当然了,OpenCV也已经提供了MOG的背景减除方法)

     

    MOG_BGS.h

    #pragma once
    #include <iostream>
    #include "opencv2/opencv.hpp"
    
    using namespace cv;
    using namespace std;
    
    //定义gmm模型用到的变量
     #define GMM_MAX_COMPONT 6			//每个GMM最多的高斯模型个数
     #define GMM_LEARN_ALPHA 0.005  
     #define GMM_THRESHOD_SUMW 0.7
     #define TRAIN_FRAMES 60	// 对前 TRAIN_FRAMES 帧建模
    
    class MOG_BGS
    {
    public:
    	MOG_BGS(void);
    	~MOG_BGS(void);
    
    	void init(const Mat _image);
    	void processFirstFrame(const Mat _image);
    	void trainGMM(const Mat _image);
    	void getFitNum(const Mat _image);
    	void testGMM(const Mat _image);
    	Mat getMask(void){return m_mask;};
     
    private:
    	Mat m_weight[GMM_MAX_COMPONT];  //权值
    	Mat m_mean[GMM_MAX_COMPONT];    //均值
    	Mat m_sigma[GMM_MAX_COMPONT];   //方差
    
    	Mat m_mask;
    	Mat m_fit_num;
    };


    MOG_BGS.cpp

    #include "MOG_BGS.h"
    
    MOG_BGS::MOG_BGS(void)
    {
    
    }
    
    MOG_BGS::~MOG_BGS(void)
    {
    
    }
    
    // 全部初始化为0
    void MOG_BGS::init(const Mat _image)
    {
    	/****initialization the three parameters ****/
         for(int i = 0; i < GMM_MAX_COMPONT; i++)
         {
    		 m_weight[i] = Mat::zeros(_image.size(), CV_32FC1);
             m_mean[i] = Mat::zeros(_image.size(), CV_8UC1);
             m_sigma[i] = Mat::zeros(_image.size(), CV_32FC1);
         }
    	 m_mask = Mat::zeros(_image.size(),CV_8UC1);
    	 m_fit_num = Mat::ones(_image.size(),CV_8UC1);
    }
    
    //gmm第一帧初始化函数实现
    //捕获到第一帧时对高斯分布进行初始化.主要包括对每个高斯分布的权值、期望和方差赋初值.
    //其中第一个高斯分布的权值为1,期望为第一个像素数据.其余高斯分布权值为0,期望为0.
    //每个高斯分布都被赋予适当的相等的初始方差 15
    void MOG_BGS::processFirstFrame(const Mat _image)
    {
    	for(int i = 0; i < GMM_MAX_COMPONT; i++)
        {
    		if (i == 0)
    		{
    			m_weight[i].setTo(1.0);
    			_image.copyTo(m_mean[i]);
    			m_sigma[i].setTo(15.0);
    		}
    		else
    		{
    			m_weight[i].setTo(0.0);
    			m_mean[i].setTo(0);
    			m_sigma[i].setTo(15.0);
    		}
        }
    }
     
    // 通过新的帧来训练GMM
    void MOG_BGS::trainGMM(const Mat _image)
    {
    	for(int i = 0; i < _image.rows; i++)
    	{
    		for(int j = 0; j < _image.cols; j++)
    		{
                 int num_fit = 0;
    
    			 /**************************** Update parameters Start ******************************************/
                 for(int k = 0 ; k < GMM_MAX_COMPONT; k++)
                 {
    				 int delm = abs(_image.at<uchar>(i, j) - m_mean[k].at<uchar>(i, j));
    				 long dist = delm * delm;
    				 // 判断是否匹配:采样值与高斯分布的均值的距离小于3倍方差(表示匹配)
                     if( dist < 3.0 * m_sigma[k].at<float>(i, j)) 
                     {
    					 // 如果匹配
                         /****update the weight****/
                         m_weight[k].at<float>(i, j) += GMM_LEARN_ALPHA * (1 - m_weight[k].at<float>(i, j));
     
                         /****update the average****/
                         m_mean[k].at<uchar>(i, j) += (GMM_LEARN_ALPHA / m_weight[k].at<uchar>(i, j)) * delm;
     
                         /****update the variance****/
                         m_sigma[k].at<float>(i, j) += (GMM_LEARN_ALPHA / m_weight[k].at<float>(i, j)) * (dist - m_sigma[k].at<float>(i, j));
                     }
                     else
    				 {
    					// 如果不匹配。则该该高斯模型的权值变小
                         m_weight[k].at<float>(i, j) += GMM_LEARN_ALPHA * (0 - m_weight[k].at<float>(i, j));
                         num_fit++; // 不匹配的模型个数
                     }        
                 }
     			 /**************************** Update parameters End ******************************************/	
    		
    
    			 /*********************** Sort Gaussian component by 'weight / sigma' Start ****************************/
                 //对gmm各个高斯进行排序,从大到小排序,排序依据为 weight / sigma
                 for(int kk = 0; kk < GMM_MAX_COMPONT; kk++)
                 {
                     for(int rr=kk; rr< GMM_MAX_COMPONT; rr++)
                     {
                         if(m_weight[rr].at<float>(i, j)/m_sigma[rr].at<float>(i, j) > m_weight[kk].at<float>(i, j)/m_sigma[kk].at<float>(i, j))
                         {
                             //权值交换
                             float temp_weight = m_weight[rr].at<float>(i, j);
                             m_weight[rr].at<float>(i, j) = m_weight[kk].at<float>(i, j);
                             m_weight[kk].at<float>(i, j) = temp_weight;
     
                             //均值交换
                             uchar temp_mean = m_mean[rr].at<uchar>(i, j);
                             m_mean[rr].at<uchar>(i, j) = m_mean[kk].at<uchar>(i, j);
                             m_mean[kk].at<uchar>(i, j) = temp_mean;
     
                             //方差交换
                             float temp_sigma = m_sigma[rr].at<float>(i, j);
                             m_sigma[rr].at<float>(i, j) = m_sigma[kk].at<float>(i, j);
                             m_sigma[kk].at<float>(i, j) = temp_sigma;
                         }
                     }
                 }
    			 /*********************** Sort Gaussian model by 'weight / sigma' End ****************************/
     
    
    			 /*********************** Create new Gaussian component Start ****************************/
                 if(num_fit == GMM_MAX_COMPONT && 0 == m_weight[GMM_MAX_COMPONT - 1].at<float>(i, j))
                 {
    				 //if there is no exit component fit,then start a new component
    				 //当有新值出现的时候,若目前分布个数小于M,新添一个分布,以新采样值作为均值,并赋予较大方差和较小权值
                      for(int k = 0 ; k < GMM_MAX_COMPONT; k++)
                     {
                         if(0 == m_weight[k].at<float>(i, j))
    					 {
    						 m_weight[k].at<float>(i, j) = GMM_LEARN_ALPHA;
    						 m_mean[k].at<uchar>(i, j) = _image.at<uchar>(i, j);
    						 m_sigma[k].at<float>(i, j) = 15.0;
                            
    						 //normalization the weight,let they sum to 1
                             for(int q = 0; q < GMM_MAX_COMPONT && q != k; q++)
                             {
    							//对其他的高斯模型的权值进行更新,保持权值和为1
                                 /****update the other unfit's weight,u and sigma remain unchanged****/
                                 m_weight[q].at<float>(i, j) *= (1 - GMM_LEARN_ALPHA);
                             }
                             break; //找到第一个权值不为0的即可
                          }                            
                      }
                 }
                 else if(num_fit == GMM_MAX_COMPONT && m_weight[GMM_MAX_COMPONT -1].at<float>(i, j) != 0)
                 {
    				 //如果GMM_MAX_COMPONT都曾经赋值过,则用新来的高斯代替权值最弱的高斯,权值不变,只更新均值和方差
                     m_mean[GMM_MAX_COMPONT-1].at<uchar>(i, j) = _image.at<uchar>(i, j);
                     m_sigma[GMM_MAX_COMPONT-1].at<float>(i, j) = 15.0;
                 }
    			 /*********************** Create new Gaussian component End ****************************/
             }
    	}
    }
    
     //对输入图像每个像素gmm选择合适的高斯分量个数
     //排序后最有可能是背景分布的排在最前面,较小可能的短暂的分布趋向于末端.我们将排序后的前fit_num个分布选为背景模型;
     //在排过序的分布中,累积概率超过GMM_THRESHOD_SUMW的前fit_num个分布被当作背景模型,剩余的其它分布被当作前景模型.
    void MOG_BGS::getFitNum(const Mat _image)
    {
    	for(int i = 0; i < _image.rows; i++)
    	{
    		for(int j = 0; j < _image.cols; j++)
    		{
    			float sum_w = 0.0;	//重新赋值为0,给下一个像素做累积
    			for(uchar k = 0; k < GMM_MAX_COMPONT; k++)
    			{
    				sum_w += m_weight[k].at<float>(i, j);
    				if(sum_w >= GMM_THRESHOD_SUMW)	//如果这里THRESHOD_SUMW=0.6的话,那么得到的高斯数目都为1,因为每个像素都有一个权值接近1
                    {
                         m_fit_num.at<uchar>(i, j) = k + 1;
                         break;
                    }
    			}
    		}
    	}
    }
    
     //gmm测试函数的实现
    void MOG_BGS::testGMM(const Mat _image)
    {
    	for(int i = 0; i < _image.rows; i++)
    	{
    		for(int j = 0; j < _image.cols; j++)
    		{
    			int k = 0;
    			for( ; k < m_fit_num.at<uchar>(i, j); k++)
    			{
    				if(abs(_image.at<uchar>(i, j) - m_mean[k].at<uchar>(i, j)) < (uchar)( 2.5 * m_sigma[k].at<float>(i, j)))
    				{
    					m_mask.at<uchar>(i, j) = 0;
    					break;
    				}
    			}
    			if(k == m_fit_num.at<uchar>(i, j))
    			{
    				m_mask.at<uchar>(i, j) = 255;
    			}
    		}
    	}
    }


    Main.cpp

    // This is based on the "An Improved Adaptive Background Mixture Model for
    // Real-time Tracking with Shadow Detection" by P. KaewTraKulPong and R. Bowden
    // Author : zouxy
    // Date   : 2013-4-13
    // HomePage : http://blog.csdn.net/zouxy09
    // Email  : zouxy09@qq.com
    
    #include "opencv2/opencv.hpp"
    #include "MOG_BGS.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;
    	}
    
    	MOG_BGS Mog_Bgs;
    	int count = 0;
    
    	while (1)
    	{
    		count++;
    		capture >> frame;
    		if (frame.empty())
    			break;
    		cvtColor(frame, gray, CV_RGB2GRAY);
    	
    		if (count == 1)
    		{
    			Mog_Bgs.init(gray);
    			Mog_Bgs.processFirstFrame(gray);
    			cout<<" Using "<<TRAIN_FRAMES<<" frames to training GMM..."<<endl;
    		}
    		else if (count < TRAIN_FRAMES)
    		{
    			Mog_Bgs.trainGMM(gray);
    		}
    		else if (count == TRAIN_FRAMES)
    		{
    			Mog_Bgs.getFitNum(gray);
    			cout<<" Training GMM complete!"<<endl;
    		}
    		else
    		{
    			Mog_Bgs.testGMM(gray);
    			mask = Mog_Bgs.getMask();
    			morphologyEx(mask, mask, MORPH_OPEN, Mat());
    			erode(mask, mask, Mat(7, 7, CV_8UC1), Point(-1, -1));  // You can use Mat(5, 5, CV_8UC1) here for less distortion
    			dilate(mask, mask, Mat(7, 7, CV_8UC1), Point(-1, -1));
    			imshow("mask", mask);
    		}
    
    		imshow("input", frame);	
    
    		if ( cvWaitKey(10) == 'q' )
    			break;
    	}
    
    	return 0;
    }


    转载于:https://my.oschina.net/abcijkxyz/blog/1617913

    展开全文
  • 利用混合高斯模型对目标场景进行背景建模,分割出前景与背景。 代码输入:一组图片或一段视频 代码输出:前景与背景分割开的灰度图 环境:linux+opencv+eigen 语言:C++
  • OpenCV混合高斯模型前景分离

    千次阅读 2013-08-20 21:39:44
    对于摄像机固定的情形,当然也可以用光流法,但是由于光流法的复杂性,往往难以实时的计算,所以我采用高斯背景模型。因为,在摄像机固定的情况下,背景的变化是缓慢的,而且大都是光照,风等等的影

    运动检测的一般方法

      目前,运动物体检测的问题主要分为两类,摄像机固定和摄像机运动。对于摄像机运动的运动物体检测问题,比较著名的解决方案是光流法,通过求解偏微分方程求的图像序列的光流场,从而预测摄像机的运动状态。对于摄像机固定的情形,当然也可以用光流法,但是由于光流法的复杂性,往往难以实时的计算,所以我采用高斯背景模型。因为,在摄像机固定的情况下,背景的变化是缓慢的,而且大都是光照,风等等的影响,通过对背景建模,对一幅给定图像分离前景和背景,一般来说,前景就是运动物体,从而达到运动物体检测的目的
     
    单分布高斯背景模型
    单分布高斯背景模型认为,对一个背景图像,特定像素亮度的分布满足高斯分布,即对背景图像B,(x,y)点的亮度满足:
      IB(x,y) ~ N(u,d)
      这样我们的背景模型的每个象素属性包括两个参数:平均值u 和 方差d。
      对于一幅给定的图像G,如果 Exp(-(IG(x,y)-u(x,y))^2/(2*d^2)) > T,认为(x,y)是背景点,反之是前景点。
      同时,随着时间的变化,背景图像也会发生缓慢的变化,这时我们要不断更新每个象素点的参数
      u(t+1,x,y) = a*u(t,x,y) + (1-a)*I(x,y)
      这里,a称为更新参数,表示背景变化的速度,一般情况下,我们不更新d(实验中发现更不更新d,效果变化不大)。
      高斯混合模型是用于背景提取的方法,OpenCV的cvaux中cvbgfg_gaussmix.cpp文件根据文献An improved adaptive background mixture model for real-time tracking with shadow中提供的方法编写了高斯混合模型函数。其中定义了CvGaussBGModel类用于存放高斯混合模型的各个参数。我用OpenCV使用高斯混合模型函数分以下几步:
      1。在程序初始化部分定义高斯混合模型参数CvGaussBGModel* bg_model=NULL;在读取第一帧图像(背景图像)时,进行高斯背景建模bg_model = (CvGaussBGModel*)cvCreateGaussianBGModel(image, 0);image可以是灰度图象也可以是彩色图像。接下来再读取当前帧时,更新高斯模型
      regioncount=icvUpdateGaussianBGModel(currframe, bg_model );regioncount的含义我不确定,我理解是代表背景中不同颜色区域的个数,这个参数我没有用到,它只是icvUpdateGaussianBGModel函数的返回值。
      2。现在bg_model已经保存了经过高斯混合模型分类后的结果,bg_model->background保存了背景图像,bg_model->foreground保存了前景图像。
    1. #include <stdio.h>   
    2. #include <cv.h>   
    3. #include <cxcore.h>   
    4. #include <highgui.h>   
    5. #include <cvaux.h>//必须引此头文件   
    6. int main( int argc, char** argv )  
    7. {   
    8.   
    9.    IplImage* pFrame = NULL;     
    10.    IplImage* pFrImg = NULL;   
    11.    IplImage* pBkImg = NULL;     
    12.    CvCapture* pCapture = NULL;     
    13.    int nFrmNum = 0;  
    14.   
    15.    cvNamedWindow("video", 1);   
    16.    cvNamedWindow("background",1);   
    17.    cvNamedWindow("foreground",1);     
    18.    cvMoveWindow("video", 30, 0);   
    19.    cvMoveWindow("background", 360, 0);   
    20.    cvMoveWindow("foreground", 690, 0);  
    21.   
    22.    //打开视频文件    
    23.   
    24.    pCapture = cvCaptureFromFile("bike.avi");  
    25.    //pCapture = cvCaptureFromFile("20120726.avi");   
    26.    if( !pCapture )       
    27.    {     
    28.       fprintf(stderr, "Can not open video file %s\n", argv[1]);     
    29.       return -2;       
    30.    }  
    31.   
    32.   
    33.    //初始化高斯混合模型参数   
    34.    CvGaussBGModel* bg_model=NULL;  
    35.   
    36.    while(pFrame = cvQueryFrame( pCapture ))     
    37.    {       
    38.       nFrmNum++;             
    39.       if(nFrmNum == 1)     
    40.       {      
    41.          pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  pFrame->depth, pFrame->nChannels /*IPL_DEPTH_8U,3*/);     
    42.          pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);       
    43.   
    44.   
    45.          //高斯背景建模,pFrame可以是多通道图像也可以是单通道图像   
    46.          //cvCreateGaussianBGModel函数返回值为CvBGStatModel*,   
    47.          //需要强制转换成CvGaussBGModel*   
    48.          bg_model = (CvGaussBGModel*)cvCreateGaussianBGModel(pFrame, 0);  
    49.       }       
    50.       else  
    51.       {      
    52.          //更新高斯模型   
    53.          cvUpdateBGStatModel(pFrame, (CvBGStatModel *)bg_model );  
    54.   
    55.          //pFrImg为前景图像,只能为单通道   
    56.          //pBkImg为背景图像,可以为单通道或与pFrame通道数相同   
    57.          cvCopy(bg_model->foreground,pFrImg,0);  
    58.          cvCopy(bg_model->background,pBkImg,0);  
    59.          cvThreshold(pFrImg, pFrImg, 128, 255, CV_THRESH_BINARY_INV);  
    60.   
    61.          //把图像正过来   
    62.       //   pBkImg->origin=1;   
    63.       //   pFrImg->origin=1;   
    64.   
    65.          cvShowImage("video", pFrame);      
    66.          cvShowImage("background", pBkImg);      
    67.          cvShowImage("foreground", pFrImg);         
    68.          if( cvWaitKey(100) >= 0 )        
    69.             break;       
    70.       }       
    71.   
    72.    }  
    73.   
    74.    //释放高斯模型参数占用内存      
    75.    cvReleaseBGStatModel((CvBGStatModel**)&bg_model);  
    76.    cvDestroyWindow("video");   
    77.    cvDestroyWindow("background");   
    78.    cvDestroyWindow("foreground");     
    79.    cvReleaseImage(&pFrImg);   
    80.    cvReleaseImage(&pBkImg);     
    81.    cvReleaseCapture(&pCapture);     
    82.    return 0;  
    83. }  
    展开全文
  • GMM(高斯混合模型)的动态背景分割

    千次阅读 热门讨论 2019-11-13 14:19:10
    以下是GMM(高斯混合模型)的动态背景分割的实验报告以及源码,另外用到了形态学操作与多通道的处理,提升了实验结果的性能。 一.实验名称 基于混合高斯模型的动态背景分割 二.实验目的 探索如何对...
  • 因为监控发展的需求,目前前景检测的研究还是很多的,也出现了很多新的方法和思路。个人了解的大概概括为以下一些: 帧差、背景减除(GMM、CodeBook、 SOBS、 SACON、 VIBE、 W4、多帧平均……)、光流(稀疏光流...
  • 背景建模之高斯混合模型

    万次阅读 多人点赞 2015-06-29 17:57:20
    前景是指在假设背景为静止的情况下,任何有意义的运动物体即为前景。 运动物体检测的问题主要分为两类,摄像机固定和摄像机运动。对于摄像机运动的运动物体检测问题,比较著名的解决方案是光流法,通过求解偏微分...
  • 提出了一种改进的混合高斯背景模型方法,克服了传统混合高斯背景建模方法计算时间长的缺点。通过对视频图像中运动目标区域进行背景建模,减小了每一帧的背景建模区域,同时在提取运动目标区域前先对初提取的前景目标...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 167
精华内容 66
关键字:

高斯混合模型前景检测