ViBe运动目标检测python实现

最新推荐文章于 2024-08-23 08:00:22 发布
最新推荐文章于 2024-08-23 08:00:22 发布
阅读量2.9k 收藏 28
点赞数 7
分类专栏： opencv 算法 ViBe前景检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ricardo232525/article/details/107451674
版权

代码实现参考官方开源C代码，仅实现了对灰度图的运动目标检测，即对应C代码中三个核心函数：

libvibeModel_Sequential_AllocInit_8u_C1R
libvibeModel_Sequential_Segmentation_8u_C1R
libvibeModel_Sequential_Update_8u_C1R

其中，Segmentation部分循环进行了相应的修改，没有对像素进行遍历逐一修改，而是通过获取mask，直接对图像矩阵进行修改（可能逻辑有点问题）；Update部分完全照着C代码改的python，判断语句太多了。

官网截图

全部代码：https://github.com/232525/ViBe.python

ViBe类文件

# -*- coding: utf-8 -*-
"""
Created on Sat Jul 18 17:43:58 2020
@filename: lib_vibe.py
@author: curya
"""

import numpy as np
import time

class vibe_gray:
    def __init__(self, ):
        self.width = 0
        self.height = 0
        self.numberOfSamples = 20
        self.matchingThreshold = 20
        self.matchingNumber = 2
        self.updateFactor = 16
        
        # Storage for the history
        self.historyImage = None
        self.historyBuffer = None
        self.lastHistoryImageSwapped = 0
        self.numberOfHistoryImages = 2
        
        # Buffers with random values
        self.jump = None
        self.neighbor = None
        self.position = None
        
    def AllocInit(self, image):
        print('AllocInit!')
        height, width = image.shape[:2]
        # set the parametors
        self.width = width
        self.height = height
        print(self.height, self.width)
        
        # create the historyImage
        self.historyImage = np.zeros((self.height, self.width, self.numberOfHistoryImages), np.uint8)
        for i in range(self.numberOfHistoryImages):
            self.historyImage[:, :, i] = image
            
        # create and fill the historyBuffer
        self.historyBuffer = np.zeros((self.height, self.width, self.numberOfSamples-self.numberOfHistoryImages), np.uint8)
        for i in range(self.numberOfSamples-self.numberOfHistoryImages):
            image_plus_noise = image + np.random.randint(-10, 10, (self.height, self.width))
            image_plus_noise[image_plus_noise > 255] = 255
            image_plus_noise[image_plus_noise < 0] = 0
            self.historyBuffer[:, :, i] = image_plus_noise.astype(np.uint8)
        
        # fill the buffers with random values
        size = 2 * self.width + 1 if (self.width > self.height) else 2 * self.height + 1
        self.jump = np.zeros((size), np.uint32)
        self.neighbor = np.zeros((size), np.int)
        self.position = np.zeros((size), np.uint32)
        for i in range(size):
            self.jump[i] = np.random.randint(1, 2*self.updateFactor+1)
            self.neighbor[i] = np.random.randint(-1, 3-1) + np.random.randint(-1, 3-1) * self.width
            self.position[i] = np.random.randint(0, self.numberOfSamples)
        
    
    def Segmentation(self, image):
        # segmentation_map init
        segmentation_map = np.zeros((self.height, self.width)) + (self.matchingNumber - 1)
        
        # first history image
        mask = np.abs(image - self.historyImage[:, :, 0]) > self.matchingThreshold
        segmentation_map[mask] = self.matchingNumber
        
        # next historyImages
        for i in range(1, self.numberOfHistoryImages):
            mask = np.abs(image - self.historyImage[:, :, i]) <= self.matchingThreshold
            segmentation_map[mask] = segmentation_map[mask] - 1
        
        # for swapping
        self.lastHistoryImageSwapped = (self.lastHistoryImageSwapped + 1) % self.numberOfHistoryImages
        swappingImageBuffer = self.historyImage[:, :, self.lastHistoryImageSwapped]
        
        # now, we move in the buffer and leave the historyImage
        numberOfTests = self.numberOfSamples - self.numberOfHistoryImages
        mask = segmentation_map > 0
        for i in range(numberOfTests):
            mask_ = np.abs(image - self.historyBuffer[:, :, i]) <= self.matchingThreshold
            mask_ = mask * mask_
            segmentation_map[mask_] = segmentation_map[mask_] - 1
            
            # Swapping: Putting found value in history image buffer
            temp = swappingImageBuffer[mask_].copy()
            swappingImageBuffer[mask_] = self.historyBuffer[:, :, i][mask_].copy()
            self.historyBuffer[:, :, i][mask_] = temp
        
        # simulate the exit inner loop
        mask_ = segmentation_map <= 0
        mask_ = mask * mask_
        segmentation_map[mask_] = 0
        
        # Produces the output. Note that this step is application-dependent
        mask = segmentation_map > 0
        segmentation_map[mask] = 255
        return segmentation_map.astype(np.uint8)
    
    def Update(self, image, updating_mask):
        numberOfTests = self.numberOfSamples - self.numberOfHistoryImages
        
        inner_time = 0
        t0 = time.time()
        # updating
        for y in range(1, self.height-1):
            t1 = time.time()
            shift = np.random.randint(0, self.width)
            indX = self.jump[shift]
            t2 = time.time()
            inner_time += (t2 - t1)
            #""" too slow
            while indX < self.width - 1:
                t3 = time.time()
                index = indX + y * self.width
                t4 = time.time()
                inner_time += (t4 - t3)
                if updating_mask[y, indX] == 255:
                    t5 = time.time()
                    value = image[y, indX]
                    index_neighbor = index + self.neighbor[shift]
                    y_, indX_ = int(index_neighbor / self.width), int(index_neighbor % self.width)
                    
                    if self.position[shift] < self.numberOfHistoryImages:
                        self.historyImage[y, indX, self.position[shift]] = value
                        self.historyImage[y_, indX_, self.position[shift]] = value
                    else:
                        pos = self.position[shift] - self.numberOfHistoryImages
                        self.historyBuffer[y, indX, pos] = value
                        self.historyBuffer[y_, indX_, pos] = value
                    t6 = time.time()
                    inner_time += (t6 - t5)
                t7 = time.time()
                shift = shift + 1
                indX = indX + self.jump[shift]
                t8 = time.time()
                inner_time += (t8 - t7)
            #"""
        t9 = time.time()
        # print('update: %.4f, inner time: %.4f' % (t9 - t0, inner_time))
        
        # First row
        y = 0
        shift = np.random.randint(0, self.width)
        indX = self.jump[shift]
        
        while indX <= self.width - 1:
            index = indX + y * self.width
            if updating_mask[y, indX] == 0:
                if self.position[shift] < self.numberOfHistoryImages:
                    self.historyImage[y, indX, self.position[shift]] = image[y, indX]
                else:
                    pos = self.position[shift] - self.numberOfHistoryImages
                    self.historyBuffer[y, indX, pos] = image[y, indX]
            
            shift = shift + 1
            indX = indX + self.jump[shift]
            
        # Last row
        y = self.height - 1
        shift = np.random.randint(0, self.width)
        indX = self.jump[shift]
        
        while indX <= self.width - 1:
            index = indX + y * self.width
            if updating_mask[y, indX] == 0:
                if self.position[shift] < self.numberOfHistoryImages:
                    self.historyImage[y, indX, self.position[shift]] = image[y, indX]
                else:
                    pos = self.position[shift] - self.numberOfHistoryImages
                    self.historyBuffer[y, indX, pos] = image[y, indX]
            
            shift = shift + 1
            indX = indX + self.jump[shift]
        
        # First column
        x = 0
        shift = np.random.randint(0, self.height)
        indY = self.jump[shift]
        
        while indY <= self.height - 1:
            index = x + indY * self.width
            if updating_mask[indY, x] == 0:
                if self.position[shift] < self.numberOfHistoryImages:
                    self.historyImage[indY, x, self.position[shift]] = image[indY, x]
                else:
                    pos = self.position[shift] - self.numberOfHistoryImages
                    self.historyBuffer[indY, x, pos] = image[indY, x]
            
            shift = shift + 1
            indY = indY + self.jump[shift]
            
        # Last column
        x = self.width - 1
        shift = np.random.randint(0, self.height)
        indY = self.jump[shift]
        
        while indY <= self.height - 1:
            index = x + indY * self.width
            if updating_mask[indY, x] == 0:
                if self.position[shift] < self.numberOfHistoryImages:
                    self.historyImage[indY, x, self.position[shift]] = image[indY, x]
                else:
                    pos = self.position[shift] - self.numberOfHistoryImages
                    self.historyBuffer[indY, x, pos] = image[indY, x]
            
            shift = shift + 1
            indY = indY + self.jump[shift]
            
        # The first pixel
        if np.random.randint(0, self.updateFactor) == 0:
            if updating_mask[0, 0] == 0:
                position = np.random.randint(0, self.numberOfSamples)
                
                if position < self.numberOfHistoryImages:
                    self.historyImage[0, 0, position] = image[0, 0]
                else:
                    pos = position - self.numberOfHistoryImages
                    self.historyBuffer[0, 0, pos] = image[0, 0]

# TO DO
class vibe_rgb:
    def __init__(self, ):
        pass
    
    def init(self, ):
        pass
    
    def segmentation(self, ):
        pass
    
    def update(self, ):
        pass

调用主函数文件

# -*- coding: utf-8 -*-
"""
Created on Sat Jul 18 17:43:58 2020
@filename: vibe_demo.py
@author: curya
"""

import numpy as np
import cv2
import time
from lib_vibe import vibe_gray

cap = cv2.VideoCapture('./TownCentreXVID.avi')
vibe = vibe_gray()


frame_index = 0
segmentation_time = 0
update_time = 0
t1 = time.time()
while True:
    ret, frame = cap.read()
    if not ret:
        break
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    if frame_index % 100 == 0:
        print('Frame number: %d' % frame_index)
        
    if frame_index == 0:
        vibe.AllocInit(gray_frame)
    
    t2 = time.time()
    segmentation_map = vibe.Segmentation(gray_frame)
    t3 = time.time()
    vibe.Update(gray_frame, segmentation_map)
    t4 = time.time()
    segmentation_time += (t3-t2)
    update_time += (t4-t3)
    print('Frame %d, segmentation: %.4f, updating: %.4f' % (frame_index, t3-t2, t4-t3))
    segmentation_map = cv2.medianBlur(segmentation_map, 3)
    
    cv2.imshow('Actual Frame!', frame)  
    cv2.imshow('Gray Frame!', gray_frame)
    cv2.imshow('Segmentation Frame!', segmentation_map)
    frame_index += 1
    if cv2.waitKey(1) & 0xFF == ord('q'):                                 # Break while loop if video ends
        break
t5 = time.time()    
print('All time cost %.3f' % (t5-t1))
print('segmentation time cost: %.3f, update time cost: %.3f' % (segmentation_time, update_time))

cap.release()
cv2.waitKey()
cv2.destroyAllWindows()

运行

python vibe_demo.py

问题

和C代码比较，效率就是个弟弟，跑分辨率不是太高的视频勉强凑合，分辨率太高的视频就真的干看着了，不过和我找的几份别人用python实现的ViBe代码比较，感觉还算是快的。

其次就是发现效率的硬伤之后，也就没去检查代码逻辑是不是和C代码一致，反正是可以检测目标。

还是想办法用Cython复用C代码？我太难了。。。。。。好不容易照着别人的东西造了个轮子，结果轮子不是很圆。😦 Sad

Curya
关注
专栏目录
ViBe：基于Python实现的加速版（2019.10）
Yancy的博客
10-11 6734
网络上流行的ViBe算法的python实现版本运行速度非常慢，根本达不到实时的目的；而论文作者提供的C++版本则速度超快。借鉴一些网络上的说法改成numpy来操作速度更快，有些大佬也给出了新的思路。新的代码初始化速度有明显提升，记录于此。 #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Oct 11 13:19...
python运动目标检测_运动目标检测ViBe算法
weixin_39722196的博客
12-11 1979
一、运动目标检测简介视频中的运动目标检测这一块现在的方法实在是太多了。运动目标检测的算法依照目标与摄像机之间的关系可以分为静态背景下运动检测和动态背景下运动检测。先简单从视频中的背景类型来讨论。静态背景下的目标检测，就是从序列图像中将实际的变化区域和背景区分开了。在背景静止的大前提下进行运动目标检测的方法有很多，这些方法比较侧重于背景扰动小噪声的消除，如：1.背景差分法2.帧间差分法3.光流法4....
基于Python的Vibe目标检测代码
08-27
该.py文件为基于vibe原理的目标检测Python代码。由于第一次写Python，程序运行比较慢，欢迎交流。 运行方式：将该文件和名称为video的avi文件放在同一个文件夹，然后运行即可。当然也可以在程序中修改待检测的视频文件名称。
PyVibe 开源项目指南
最新发布
gitblog_00121的博客
08-23 411
PyVibe 开源项目指南 pyvibeGenerate styled HTML pages from Python项目地址:https://gitcode.com/gh_mirrors/py/pyvibe 项目介绍 PyVibe 是一个基于 Python 的框架，旨在简化音乐分析、情感识别及音频处理的任务。该项目利用先进的信号处理技术与机器学习算法，为开发者提供了一个强大且灵活的工具集，让他们...
运动检测ViBe算法python实现代码
09-20
主要为大家详细介绍了运动检测ViBe算法python实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
运动检测ViBe算法python实现
孤独de雨
07-02 1万+
运动物体检测一般分为背景建模和运动物体分析两步。即构建不包含运动物体的背景模型。然后将新的视频帧和背景模型对比，找出其中的运动物体。目前比较好的背景建模算法有两种：1)文章（Zivkovic Z. (2004) Improved adaptive Gausianmixture model for  backgroundsubtraction, Proceedings of ICPR 2004,
VIBE运动目标检测算法实现
Belial计算机视觉&机器视觉专栏
06-27 1万+
近来，有不少人咨询我关于VIBE算法的问题，而且对于有些细节问题懵懵懂懂，索要源码类的，考虑这个算法的应用以及很多人对此有比较深的兴趣，遂将其放在博客上供大家学习。该版本的代码是在学校的时候写的，里面也加入了一些其他的后处理内容，尽管还有不足，但是对于加深对VIBE算法的理解肯定有一定帮助。另外，由于最新版本的代码在公司电脑上，不便提供。关于理论方面的请参考下面二篇文章： 1）VIBE-A po
基于Python的VIBE源码
05-20
本文是使用Python编写的VIBE源码，不使用封装函数，原理层面实现。Vibe算法是一种基于背景更新的前景检测算法，其原理是通过提取像素点（x, y）周围的像素值及以前的像素值建立像素点的样本集，然后再将另一帧（x，y）处的像素值与样本集中的像素值进行比较，如果其与样本集中的像素值的距离大于某阈值的话，则认为该像素点为前景像素点，否则为背景像素点。
python实现算法改进_运动目标检测vibe算法及其改进Python实现
weixin_40007541的博客
12-19 1153
vibe是一个又简单又牛逼的算法，没有什么数学公式，就只有三步1.初始化背景模型，总共有20个背景模型样本，每个样本中的每个点由其八邻域初始化(论文里面没有用到自己这个像素点，看了其他的改进，有用自己的，这个没必要较真，大家都是试出来的，不一定适合每个场景)。2.前景背景判定 新来的每一帧与背景模型做比较，如果新的帧的点与背景模型中样本的点的像素值大小不超过20(20是个经验值在网上搜了一下，实现...
vibe运动目标检测实现
05-02
我用c++实现了cpu版vibe运动目标检测算法，第一版的；还有用cuda也实现了一遍。都是基础版或者叫vibe第一版。
消除鬼影及阴影的改进ViBe运动目标检测算法
02-21
针对传统ViBe算法在运动目标检测中鬼影现象难以消除的问题,提出一种根据欧氏距离及Tanimoto系数计算前景-邻域背景像素灰度直方图相似度的方法来检测及消除鬼影;针对传统ViBe算法在运动目标检测中无法消除阴影的问题,...
运动目标检测代码(帧差、高斯混合、vibe代码实现)
snwang_miss的博客
05-14 7369
主要介绍四种运动目标检测的算法代码，每段代码博主实测可运行。当前主流的混合高斯背景模型，VIBE算法代码转载自他处。另外GMG算法，KNN算法在朱伟的书中有讲
vibe_python:用python实现氛围
04-28
vibe_python Python的实现 Barnich O，Van D M. ViBe：一种用于视频序列的通用背景减法算法[J]。计算机应用，2006,26（5）：1275-1279 IEEE Transactions on Image Processing，2011，20（6）：1709-1724。 要求 python3 麻木 OpenCV numba（加速） cython（加速） 用 您可以使用两种加速方式（numba，cython），如果您想使用cython，则需要知道如何组合。 更改app.py中的路径 python app.py
运动目标检测 之 Vibe背景模型算法
苏的专栏
11-17 8487
前段时间研究了下Vibe目标检算法并做了代码实现，今天得空讲下我对Vibe算法的理解。算法官方网站：http://www.telecom.ulg.ac.be/research/vibe/综述： ViBe是一种像素级视频通过背景建模的方式来检测前景目标的算法。具体的思想就是为每个像素点存储了一个样本集，样本集中采样值就是该像素点过去的像素值和其邻居点的像素值，然后将每一个新的像素值和
运动目标检测ViBe算法的numpy实现
ywxuan的专栏
09-11 2391
ViBe算法是一种优秀的运动目标检测，其背景建模是基于像素的邻域来建立，算法的具体原理我就不介绍了，网上可以搜到一大堆。网上提供的实现方法多是遍历图像中每个像素建立背景模型，有用c/c++实现的，也有用python实现的。我实验了一下，基于c/c++实现的基本能满足实时要求，用python遍历像素的方式完全不能用，速度太慢。由于我需要用python实现视频中的烟雾检测，运动目标检测只是第一...
python运动目标检测_基于上下文信息分离的无监督运动目标检测（附：论文及源码下载）...
weixin_40000131的博客
11-24 264
本文我们主要分享基于上下文的技术用于目标检查。深层神经网络被训练用于利用来自除该区域(上下文)以外的任何其他地方的信息来预测区域内的光流，而另一个网络则试图使这种上下文尽可能少信息。结果模型是一个假设不需要显式正则化或超参数的调整。尽管新方法不需要任何监督，但它的性能要好于在大型注释数据集上预先训练过的几种方法。上图可以看出：即使是相对简单的对象，当在场景中移动时，也会导致图像中复杂的不连续变化。...
背景建模算法比较与ViBe算法论文解读与python代码
Yancy的博客
02-26 4959
目录 背景建模方法需要考虑的3个问题 基于统计方法建模的缺陷 其他背景建模方法的不足 VIBE算法的巧妙之处 VIBE算法详解 初始化方法 模型更新方法 参考资料 ViBe的Python代码 在运动目标检测领域，抛开最近热火朝天的深度学习方法，最经典、可靠、传统的方法还是基于图像差分的方法。在这类方法中，往往会用到背景差分法。背景建模的优劣决定了目标检测结果的好坏，因此选...
vibe目标检测python代码
热门推荐
不爱成长的笨蛋
01-01 2万+
#! /usr/bin/env python from cProfile import Profile import pstats import numpy as np import cv2 import random import time import matplotlib.pyplot as plt defaultNbSamples = 20 defaultReqMatches = 2 d...
vibe算法的另外一种实现
jia_zhengshen的专栏
08-07 2166
近来，有不少人咨询我关于VIBE算法的问题，而且对于有些细节问题懵懵懂懂，索要源码类的，考虑这个算法的应用以及很多人对此有比较深的兴趣，遂将其放在博客上供大家学习。该版本的代码是在学校的时候写的，里面也加入了一些其他的后处理内容，尽管还有不足，但是对于加深对VIBE算法的理解肯定有一定帮助。另外，由于最新版本的代码在公司电脑上，不便提供。关于理论方面的请参考下面二篇文章： 1）VIBE-A
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值