精华内容
下载资源
问答
  • opencv 运动检测 三帧差法

    千次阅读 多人点赞 2018-12-09 08:00:09
    opencv 运动检测 三帧差法    三帧差法 优点: 实时性高 缺点: 1、运动物体本身颜色相近时,会出现较大的空洞。 2、无法应对光照骤变的情况 理论上:三帧差法 比 二帧差法更好一些(可在一定程度上消除帧...

                                    opencv 运动检测 三帧差法

     

     三帧差法 优点:

    实时性高

    缺点:

    1、运动物体本身颜色相近时,会出现较大的空洞。

    2、无法应对光照骤变的情况

    理论上:三帧差法 比 二帧差法更好一些(可在一定程度上消除帧间差分法的“双影”现象),但是也要结合实际情况而用。

     

    1. 帧差法基本原理

    帧差法的实现非常简单:

     

       如图可见,由目标运动引起的运动变化区域,包括运动目标在前后两帧中的共同位置(图中黑色区域)、在当前帧中新显露出的背景区域和新覆盖的背景区域三部分。

    数学原理:

                     

     

     

    三帧差法的流程:

    1 结果1 = (第二幅图像 - 第一幅图像) ∩ (第三幅图像 - 第二幅图像) 
    2 结果2 = 滤波(结果1) 
    3 结果3 = 形态学处理(结果2) 
    4 结果4 = 二值化(结果3)

    第一步:第二幅图像减去第一幅图像的值与第三幅图像减去第二幅图像的值作交集运算. 
     对第一步产生的结果做滤波处理. 
     对第二步产生的结果做形态学处理. 
    对第三步产生的结果做二值化处理.

     

    直接上代码:

    #include <opencv2/opencv.hpp>
    using namespace std;
    using namespace cv;
    
    int main()
    {
    	//读入视频  
    	VideoCapture capture("1.avi");  //Laboratory_raw.avi
    	//VideoCapture capture(0);
    
    	Mat tempframe, currentframe, previousframe, difframe,s3;
    	Mat difframe2, difframe3;
    	Mat frame;
    	int framenum = 0;
    	//读取一帧处理  
    	while (true)
    	{
    		if (!capture.isOpened())
    		{
    			cout << "read video failure" << endl;
    			return -1;
    		}
    		//tempframe = capture.read(frame);  
    		capture >> frame;
    		imshow("原视频", frame);
    		previousframe = frame.clone();   //第一帧
    
    		capture >> frame;
    		currentframe = frame.clone();   //第二帧
    
    		capture >> frame;
    		s3 = frame.clone();            //第三帧
    
    		cvtColor(previousframe, previousframe, CV_BGR2GRAY);
    		cvtColor(currentframe, currentframe, CV_BGR2GRAY);
    		cvtColor(s3,s3, CV_BGR2GRAY); 
    
    
    		absdiff(currentframe, previousframe, difframe);//做差求绝对值   1-2  
    		absdiff(previousframe, s3, difframe2);//做差求绝对值            2-3
    		
    		
           //准备做与运算,difframe3= difframe2^difframe
    		// void bitwise_and(InputArray src1, InputArray src2,OutputArray dst, InputArray mask=noArray());//dst = src1 & src2
    		bitwise_and(difframe, difframe2, difframe3);  //
    
    
    		threshold(difframe3, tempframe, 20, 255.0, CV_THRESH_BINARY);
    		dilate(tempframe, tempframe, Mat());//膨胀  
    		erode(tempframe, tempframe, Mat());//腐蚀
    
    		imshow("运动目标", tempframe);
    
    		waitKey(50);
    	}//end while    
    }
    

     

    运行结果:

     

     

     

    希望对你有帮助。

     

     

     

     

     

     

     

     

    展开全文
  • 帧差法依据的原则是:当视频中存在移动物体的时候,相邻帧(或相邻三帧)之间在灰度上会有差别,求取两帧图像灰度差的绝对值,则静止的物体在差值图像上表现出来全是0,而移动物体特别是移动物体的轮廓处由于存在...

    帧间差分法是通过对视频中相邻两帧图像做差分运算来标记运动物体的方法。


    帧差法依据的原则是:当视频中存在移动物体的时候,相邻帧(或相邻三帧)之间在灰度上会有差别,求取两帧图像灰度差的绝对值,则静止的物体在差值图像上表现出来全是0,而移动物体特别是移动物体的轮廓处由于存在灰度变化为非0,这样就能大致计算出移动物体的位置、轮廓和移动路径等。


    帧间差分法的优点是算法实现简单,程序设计复杂度低;对光线等场景变化不太敏感,能够适应各种动态环境,稳定性较好。缺点是不能提取出对象的完整区域,对象内部有“空洞”,只能提取出边界,边界轮廓比较粗,往往比实际物体要大。对快速运动的物体,容易出现鬼影的现象,甚至会被检测为两个不同的运动物体,对慢速运动的物体,当物体在前后两帧中几乎完全重叠时,则检测不到物体。


    相邻帧间差分法

    相邻帧间差分法直接对相邻的两帧图像做差分运算,并取差分运算的绝对值构成移动物体,优点是运算快速,实时性高,缺点是无法应对光照的突变,物体间一般具有空洞。


    C++、Opencv实现:

    #include "core/core.hpp"
    #include "highgui/highgui.hpp"
    #include "imgproc/imgproc.hpp"
    
    using namespace cv;
    
    int main(int argc,char *argv[])
    {
    	VideoCapture videoCap(argv[1]);
    	if(!videoCap.isOpened())
    	{
    		return -1;
    	}
    	double videoFPS=videoCap.get(CV_CAP_PROP_FPS);  //获取帧率
    	double videoPause=1000/videoFPS;
    
    	Mat framePre; //上一帧
    	Mat frameNow; //当前帧
    	Mat frameDet; //运动物体
    	videoCap>>framePre;
    	cvtColor(framePre,framePre,CV_RGB2GRAY);	
    	while(true)
    	{
    		videoCap>>frameNow;
    		if(frameNow.empty()||waitKey(2500)==27)
    		{
    			break;
    		}
    		cvtColor(frameNow,frameNow,CV_RGB2GRAY);
    		absdiff(frameNow,framePre,frameDet);
    		framePre=frameNow;		
    		imshow("Video",frameNow);
    		imshow("Detection",frameDet);		
    	}
    	return 0;
    }


    调用了Opencv自带的视频文件“768x576.avi”,视频文件位置:“opencv\sources\samples\gpu”,下图是视频第100帧时图像:



    下图是相邻两帧差法检测到的物体,检测效果没有经过膨胀或腐蚀等处理:



    可以看到物体的轮廓是“双边”的,并且物体的移动速度越快,双边轮廓现象越粗越明显(这是不是给监控中速度检测提供了一个思路~~),另一个就是物体具有较大的空洞。


    三帧差法


    三帧差法是在相邻帧差法基础上改进的算法,在一定程度上优化了运动物体双边,粗轮廓的现象,相比之下,三帧差法比相邻帧差法更适用于物体移动速度较快的情况,比如道路上车辆的智能监控。


    三帧差法基本实现步骤:

    1. 前两帧图像做灰度差

    2. 当前帧图像与前一帧图像做灰度差

    3. 1和2的结果图像按位做“与”操作


    C++、Opencv实现:

    #include "core/core.hpp"
    #include "highgui/highgui.hpp"
    #include "imgproc/imgproc.hpp"
    
    using namespace cv;
    
    int main(int argc,char *argv[])
    {
    	VideoCapture videoCap(argv[1]);
    	if(!videoCap.isOpened())
    	{
    		return -1;
    	}
    	double videoFPS=videoCap.get(CV_CAP_PROP_FPS);  //获取帧率
    	double videoPause=1000/videoFPS;
    	Mat framePrePre; //上上一帧
    	Mat framePre; //上一帧
    	Mat frameNow; //当前帧
    	Mat frameDet; //运动物体
    	videoCap>>framePrePre;
    	videoCap>>framePre;
    	cvtColor(framePrePre,framePrePre,CV_RGB2GRAY);	
    	cvtColor(framePre,framePre,CV_RGB2GRAY);	
    	int save=0;
    	while(true)
    	{
    		videoCap>>frameNow;
    		if(frameNow.empty()||waitKey(videoPause)==27)
    		{
    			break;
    		}
    		cvtColor(frameNow,frameNow,CV_RGB2GRAY);	
    		Mat Det1;
    		Mat Det2;
    		absdiff(framePrePre,framePre,Det1);  //帧差1
    		absdiff(framePre,frameNow,Det2);     //帧差2
    		threshold(Det1,Det1,0,255,CV_THRESH_OTSU);  //自适应阈值化
    		threshold(Det2,Det2,0,255,CV_THRESH_OTSU);
    		Mat element=getStructuringElement(0,Size(3,3));  //膨胀核
    		dilate(Det1,Det1,element);    //膨胀
    		dilate(Det2,Det2,element);
    		bitwise_and(Det1,Det2,frameDet);		
    		framePrePre=framePre;		
    		framePre=frameNow;		
    		imshow("Video",frameNow);
    		imshow("Detection",frameDet);
    	}
    	return 0;
    }

    同样是“768x576.avi”视频文件,并且也保存了第100帧的原始图像和运动物体检测图像:


    未经形态学处理的原始的三帧差法检测到的运动物体:



    未经任何形态学处理的原始的三帧差法检测到的物体的双边轮廓现象有所改善,但同时也有丢失轮廓的现象。


    下图是在两个帧差图像按位与操作之前做了一下膨胀处理的效果:



    相比相邻两帧差法,原始的三帧差法对物体的双边粗轮廓和“鬼影”现象有所改善,比较适合对运动速度较快物体的检测,但是仍然会有空洞出现,并且物体移动速度较慢时容易丢失轮廓。


    当然三帧差法做了两次的差分运算,给了三帧差法更多可操作和优化的空间,为更优秀的检测效果提供了可能。


    展开全文
  • 帧差法求运动目标

    2015-12-01 15:40:06
    代码使用简单的帧差法进行求视频序列中的运动目标,通过设置参数可以改变帧间的间隔,即每隔几帧进行帧差。该方法对噪声比较敏感,且容易产生运动目标内部空洞
  • 【目标追踪】三帧差法原理及实现

    千次阅读 2020-01-06 23:23:51
    帧差法原理及实现(一)帧差法原理及实现:(二)帧差法存在的问题:(三)三帧差法的原理:(四)三帧差法的实现代码:(五)视频中的目标追踪效果: (一)帧差法原理及实现: 这里可以看一下我的这篇博客,这里...

    (一)帧差法原理及实现:

    这里可以看一下我的这篇博客,这里就不赘述了:【目标追踪】python帧差法原理及其实现

    (二)帧差法存在的问题:

    运动物体本身颜色相近时,会出现较大的空洞。
    在这里插入图片描述

    位置变化缓慢时,难以检测到目标。
    在这里插入图片描述

    对光线非常敏感。

    (三)三帧差法的原理:

    在这里插入图片描述

    三帧差法的关键是,不再仅仅采用相邻的两帧图片作差查找运动目标,而是在相邻三帧图片的两张帧差图中取“与”操作,即:
    在这里插入图片描述

    (四)三帧差法的实现代码:

    (具体处理和代码解析还是推荐看一下我的上一篇博客:【目标追踪】python帧差法原理及其实现

    代码:

    import cv2
    import numpy as np
    from nms import py_cpu_nms
    from time import sleep
    
    
    class Detector(object):
    
        def __init__(self, name='my_video', frame_num=10, k_size=7, color=(0, 255, 0)):
    
            self.name = name
    
            self.color = color
    
            self.nms_threshold = 0.3
    
            self.time = 1/frame_num  # 频率
    
            self.es = cv2.getStructuringElement(
                cv2.MORPH_ELLIPSE, (k_size, k_size))
    
        def catch_video(self, video_index=0, k_size=7,
                        iterations=3, threshold=20, bias_num=1,
                        min_area=360, show_test=True, nms=True,
                        logical='or'):
    
            # video_index:摄像头索引(数字)或者视频路径(字符路径)
            # k_size:中值滤波的滤波器大小
            # iteration:腐蚀+膨胀的次数,0表示不进行腐蚀和膨胀操作
            # threshold:二值化阙值
            # bias_num:计算帧差图时的帧数差
            # min_area:目标的最小面积
            # show_test:是否显示二值化图片
            # nms:是否进行非极大值抑制
            # logical:三帧差取or或and
    
            logical = logical.lower()
    
            if not bias_num > 0:
                raise Exception('bias_num must > 0')
    
            if isinstance(video_index, str):
                is_camera = False
                # 如果是视频,则需要调整帧率
            else:
                is_camera = True
    
            cap = cv2.VideoCapture(video_index)  # 创建摄像头识别类
    
            if not cap.isOpened():
                # 如果没有检测到摄像头,报错
                raise Exception('Check if the camera is on.')
    
            frame_num = 0
    
            previous = []
    
            while cap.isOpened():
    
                catch, frame = cap.read()  # 读取每一帧图片
    
                if not catch:
    
                    raise Exception('Unexpected Error.')
    
                if frame_num < bias_num:    
                    value = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                    previous = [value]*bias_num
    
                    frame_num += 1
    
                raw = frame.copy()
    
                gray1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                gray1 = cv2.absdiff(gray1, previous[0])
    
                gray1 = cv2.medianBlur(gray1, k_size)
    
                _, mask1 = cv2.threshold(
                    gray1, threshold, 255, cv2.THRESH_BINARY)
    
                gray2 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                gray2 = cv2.absdiff(gray2, previous[1])
    
                gray2 = cv2.medianBlur(gray2, k_size)
    
                _, mask2 = cv2.threshold(
                    gray2, threshold, 255, cv2.THRESH_BINARY)
    
                if logical == 'or':
                    mask = (np.logical_or(mask1, mask2) + 0)
                elif logical == 'and':
                    mask = (np.logical_and(mask1, mask2) + 0)
                else:
                    raise Exception('Logical must be \'OR\' or \'AND\'')
                mask = (mask * 255).astype(np.uint8)
    
                mask = cv2.dilate(mask, self.es, iterations)
                mask = cv2.erode(mask, self.es, iterations)
    
                _, cnts, _ = cv2.findContours(
                    mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
                bounds = self.nms_cnts(cnts, mask, min_area, nms=nms)
    
                for b in bounds:
    
                    x, y, w, h = b
    
                    thickness = (w*h)//min_area
    
                    thickness = thickness if thickness <= 3 else 3
                    thickness = thickness if thickness >= 1 else 1
    
                    cv2.rectangle(frame, (x, y), (x+w, y+h), self.color, thickness)
    
                if not is_camera:
    
                    sleep(self.time)
    
                cv2.imshow(self.name, frame)  # 在window上显示图片
                if show_test:
                    cv2.imshow(self.name+'_frame', mask)  # 边界
    
                value = cv2.cvtColor(raw, cv2.COLOR_BGR2GRAY)
                previous = self.pop(previous, value)
    
                cv2.waitKey(10)
    
                if cv2.getWindowProperty(self.name, cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
                if show_test and cv2.getWindowProperty(self.name+'_frame', cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
            # 释放摄像头
            cap.release()
            cv2.destroyAllWindows()
    
        def nms_cnts(self, cnts, mask, min_area, nms=True):
            # 对检测到的边界框使用非极大值抑制
            bounds = [cv2.boundingRect(
                c) for c in cnts if cv2.contourArea(c) > min_area]
    
            if len(bounds) == 0:
                return []
    
            if not nms:
                return bounds
    
    
            scores = [self.calculate(b, mask) for b in bounds]
    
            bounds = np.array(bounds)
    
            scores = np.expand_dims(np.array(scores), axis=-1)
    
            keep = py_cpu_nms(np.hstack([bounds, scores]), self.nms_threshold)
    
            return bounds[keep]
    
        def calculate(self, bound, mask):
    
            x, y, w, h = bound
    
            area = mask[y:y+h, x:x+w]
    
            pos = area > 0
            pos = pos.astype(np.float)
            # 得分应与检测框大小也有关系
    
            score = np.sum(pos)/(w*h)
    
            return score
    
        def pop(self, l, value):
    
            l.pop(0)
            l.append(value)
    
            return l
    
    
    if __name__ == "__main__":
    
        detector = Detector(name='test')
    
        detector.catch_video('./test.avi', bias_num=2, iterations=1,
                             k_size=5, show_test=True, min_area=360, nms=False)
    
    

    (五)视频中的目标追踪效果:

    在这里插入图片描述

    关注我的公众号:

    感兴趣的同学关注我的公众号——可达鸭的深度学习教程:
    在这里插入图片描述

    展开全文
  • 关于帧差法的想法(opencv)

    千次阅读 2019-07-19 16:05:31
    帧差法 帧差法,顾名思义就是将视频中前后两帧做减法,当前帧在(x,y)点处的像素值减去上一帧在(x,y)处的像素值。该方法的优点是提取效果比较稳定,速度比较快。缺点也是蛮明显的,如果你要提取的目标是静止的...

    帧差法

    帧差法,顾名思义就是将视频中前后两帧做减法,当前帧在(x,y)点处的像素值减去上一帧在(x,y)处的像素值。该方法的优点是提取效果比较稳定,速度比较快。缺点也是蛮明显的,如果你要提取的目标是静止的或者移动速度很慢,前后两帧的前景物体会有很大一部分重合,从而会导致提取出来的图像有空洞。

    当我们要提取前景时,帧差法基本上是最简单的一种方法了,变化缓慢的背景,以及运动较快的物体,在进行帧差法之后,进行阈值分割,将差值图像变成二值图像,就完成了运动目标以及背景的分离。

    本文主要讲一下最简单的帧差,三帧差法原理相差不大,对称差分就不讲了。
    公式如下:
    在这里插入图片描述

    示例

    我简单编写了一个帧差法及阈值分割的程序如下:

    #include <opencv2/opencv.hpp>
    #include<iostream>
    using namespace std;
    using namespace cv;
    int main(int argc, char** argv)
    {
    	VideoCapture capture("F://crop.avi");
    	//VideoCapture capture(0);//直接调用摄像头
    	if (!capture.isOpened())
    	{
    		cout << "data error" << endl;
    		return false;
    	}//测试数据是否读入
    	Mat temp, pre, current, result;
    	Mat element = getStructuringElement(MORPH_RECT, Size(3, 3));//结构元素
    	Mat image1, image2;
    	Mat After_midfiler;
    	//Mat bsmaskMOG2;
    	int num = 0;
    	///Ptr<BackgroundSubtractor> pMOG2 = createBackgroundSubtractorMOG2();
    	while (1)
    	{
    		capture >> temp;
    		imshow("show", temp);
    		//------------------------------------------
    		++num;
    		//pMOG2->apply(temp, bsmaskMOG2);
    		if (num == 1)
    		{
    			//BackgroundSubtractorMOG2::getBackgroundImage();
    			cvtColor(temp, pre, COLOR_BGR2GRAY);
    
    		}
    		if (num > 1)
    		{
    			cvtColor(temp, current, COLOR_BGR2GRAY);
    			absdiff(pre, current, result);//用帧差法求前景
    			imshow("【背景】", pre);
    			imshow("【帧差】", result);
    			threshold(result, result, 60, 255, 0);
    			imshow("【阈值分割后】", result);
    			medianBlur(result, After_midfiler, 3);     //中值滤波法
    			imshow("After_midfiler", After_midfiler);
    			morphologyEx(After_midfiler, image1, MORPH_OPEN, element);
    			morphologyEx(image1, image2, MORPH_CLOSE, element);
    			imshow("image2", image2);
    			char c = waitKey(30);
    			if (c == 27)
    				break;
    			cvtColor(temp, pre, COLOR_BGR2GRAY);
    			
    		}
    	}
    }
    
    
    

    这里只放上原视频截图以及帧差的结果
    在这里插入图片描述
    在这里插入图片描述
    由于鱼的游动十分缓慢,帧差的结果并不理想。

    优化尝试1

    当运动物体变化很慢时,前面已经说过帧差会产生空洞,再进行阈值分割,这些部分会被当做背景处理。思考了一下,每一帧的变化很慢,但是总是会有变化的,如果将这每一帧与第一帧进行差分会有什么结果?
    (注释掉代码cvtColor(temp, pre, COLOR_BGR2GRAY);即可)
    尝试的运行结果如下:
    在这里插入图片描述
    这里的结果明显清晰了许多,因为后面鱼的位置与第一帧相比有了很大的区别,然而这里的问题是,第一帧中的鱼干扰了结果,本来只有两条,帧差之后变成了四条。

    优化尝试2

    再上面的基础上进行优化,思路是想办法将第一帧中的鱼去掉,只留下鱼缸。也就是尝试进行简单的背景建模。
    我的具体做法是,将当前每一帧与第一帧进行逐个像素的对比,由于鱼的游动,每一像素点都会存在没有鱼的时刻,想办法将这些不同时刻的像素点整合到一帧里就可以。我用的代码如下:

    for (int i = 0;i < current.rows;i++)
    			{
    				uchar *p = current.ptr<uchar>(i);
    				uchar *q = pre.ptr<uchar>(i);
    				for (int j = 0;j < current.cols;j++)
    				{
    					if (q[j] < p[j])
    						q[j] = p[j];
    				}
    			}
    

    运行效果如下:
    在这里插入图片描述结果较为喜人,但是这个建模需要一定的时间,并且建模过程中会受到光照的影响。通过遍历,会把光照增加的部分添加到背景之中。

    ——————————————————————————————
    分割线,后续针对帧差法的优化措施待更新~~~~~~~~~~~~~

    展开全文
  • 25局部与分割-帧差法

    2018-04-10 20:04:55
    25局部与分割-帧差法 主要思想: 通过当前帧的灰度图(currentGrayFrame)和前一帧的灰度图(previousGrayFrame)的差,进行像素级的比较 优点: 实时性高 缺点: 1、运动物体本身颜色相近时,会出现较大的空洞。 ...
  • 帧差是目前较为常见的运动目标检测算法之一。它的执行速度较快,但是它会存在各种干扰以及易受到环境噪声的影响,而且容易在检测到的运动目标内部产生较大的空洞,以致影响到最后的检测效果。针对这些问题,将...
  • 针对传统混合高斯模型(GMM)在检测运动目标时存在噪声、计算量大、效果不佳等问题,提出了一种混合四帧差分算法的改进混合高斯目标检测方法。通过选定不同规则,分别更新前后帧图像的学习速率来消除“鬼影”;提出...
  • 为了实现在监控视频中对人体运动目标的准确提取,针对传统的三帧差在运动目标提取过程中容易出现“空洞”现象,提出了一种鲁棒主成分分析(robust principal component analysis,RPCA)与三帧差分相融合的运动...
  • 针对帧差分法易产生空洞以及背景减法不能检测出与背景灰度接近的目标的问题,提出了一种将背景减和帧差法相结合的运动目标检测算法。首先利用连续两帧图像进行背景减法得到两种差分图像,并用最大类间与类内方差比法...
  • 针对传统三帧差提取的运动目标存在大量的噪声和空洞,提出一种改进的三帧差分运动目标实时检测算法;该算法采用Surendra背景提取算法提取有效背景,对视频流中连续三帧图像分别进行背景减除,得到的结果作为反馈对...
  • 目前光流、背景差分帧差是前景提前的主流算法.光流其计算量大,对噪声比较敏感;背景差分需要有比较稳健的背景模型支撑,对背景的扰动比较敏感;帧间差分难以获取目标的完整区域,容易出现空洞和双...
  • ViBe算法是一种快速高效的背景建模算法,但该算法在运动目标检测过程中会产生鬼影。...实验表明,改进的ViBe算法能够加快鬼影的消除,并且与帧差法以及混合高斯建模算法相比,前景检测效果更精确。
  • 只把相邻间存在较大...引入粗糙熵作为的补充,通过颜色灰度信息完成图像形态学重构,并进行形态学滤波和连通性检测,由此克服了检测出运动目标内部的空洞现象,满足实时性,检测效果显著提高。
  • 针对基于背景提取运动目标后广泛存在“空洞”、“重影”等问题,提出了一种新型的抑制运动目标周围“空洞”的算法。首先,对视频图像进行前景提取,在进行去阴影以及形态学上的处理后,采用非极大值抑制的算法...
  • 针对经典自适应背景中存在的问题,提出一种基于分级自适应背景分的运动检测方法%方法结合了和背景的优点,解决了运动检测中常见的拖尾问题和空洞问题%
  • 相比相邻帧差分法和三帧差分法,背景模型做差法可以较为完整的体现运动物体的整体轮廓,运动物体的双重轮廓、“鬼影”、空洞现象改善明显,下文的对比效果可以看到这一点。 但背景模型的选取...
  • 运动物体检测以及追踪

    万次阅读 多人点赞 2018-02-23 23:34:48
    帧差法适用于更多场景,如:摄像头移动以及多目标运动场景,缺点就是检测的人物之间容易出现空洞。 背景减除法,适用场景局限,只适用于第一帧是背景图的视频,但检测人物没有空洞。 以上这两种方法均...
  • 背景建模

    2020-01-15 13:56:37
    帧差法非常简单,但是会引入噪音和空洞的问题。 混合高斯模型 混合高斯模型学习方法: 首先初始化每个高斯模型矩阵参数。 取视频中T帧数据图像用来训练高斯混合模型,来了第一个像素之后用它来当做第一个高斯分布...
  • openCV简要-07 背景建模

    2021-01-27 17:15:26
    帧差法会引入噪声和空洞问题。 2.混合高斯模型 对视频中的图像背景用混合高斯模型模拟;当新来的像素点不能满足当前混合高斯模型中所有的分布,则判定为前景,否则判定为背景。 判定标准:新来的像素点的分布均值...
  • 解决了三帧差在运动目标检测结果中出现噪声、断点与内部空洞等问题,并采用基于形态学处理方法对图像处理的结果进行补偿.为了保证运动目标检测的准确性,加快消除Vibe算法中第一帧出现“鬼影”现象,本文结合了...
  • 1、帧差法 弊端噪声&空洞问题 2、混合高斯模型 背景 和 人有不同的分布
  • 背景建模 帧差法 由于场景中的目标在...帧差法非常简单,但是会引入噪音和空洞问题 混合高斯模型 在进行前景检测前,先对背景进行训练,对图像中每个背景采用一个混合高斯模型进行模拟,每个背景的混合高斯的个数...
  • 一、背景建模:帧差法 由于场景中的目标在...帧差法非常简单,但是会引入噪音和空洞问题。 二、混合高斯模型 1、在进行前景检测前,先对背景进行训练,对图像中每个背景采用一个混合高斯模型进行模拟,每个背景的...
  • 背景建模 1.帧差法 由于场景中的目标在运动,...帧差法非常简单,但是会引入噪音和空洞(人物中间是黑色的)问题 2.混合高斯模型 在进行前景检测前,先对背景进行训练,对图像中每个背景采用一个混合高斯模型进行模...
  • 基于高空平台的运动车辆提取算法研究,刘涛,张长海,根据高空平台获取的交通视频信息,研究运动车辆的快速检测方法。针对目前车辆检测的帧差法存在的空洞现象和背景减除法存在的不能
  • 帧差法非常简单,但是会引入噪音 和 空洞问题 法2:混合高斯模型 在进行前景检测前,先对背景进行训练,对图像中每个背景采用一个混合高斯模型进行模拟,每个背景的混合高斯的个数可以自适应。 然后在测试阶段,对新...
  • 背景建模 帧差法 ...帧差法非常简单,但会引入噪音点和空洞问题(如上图中人物的身上是黑色,因为两帧之间的差别明显造成的)。 鲁棒性也称为健壮性、稳健性、强健性,是系统的特性,它是系统在...
  • 帧差法非常简单,但是会引入噪音和空洞问题 混合高斯模型 在进行前景检测前,先对背景进行训练,对图像中每个背景采用一个混合高斯模型进行模拟,每个背景的混合高斯的个数可以自适应。然后在测试阶

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

帧差法空洞