Python人工智能之混合高斯模型运动目标检测详解分析


Posted in Python onNovember 07, 2021

【人工智能项目】混合高斯模型运动目标检测

Python人工智能之混合高斯模型运动目标检测详解分析

本次工作主要对视频中运动中的人或物的边缘背景进行检测。
那么走起来瓷!!!

原视频

Python人工智能之混合高斯模型运动目标检测详解分析

高斯算法提取工作

import cv2
import numpy as np

# 高斯算法
class gaussian:
    def __init__(self):
        self.mean = np.zeros((1, 3))
        self.covariance = 0
        self.weight = 0;
        self.Next = None
        self.Previous = None

class Node:
    def __init__(self):
        self.pixel_s = None
        self.pixel_r = None
        self.no_of_components = 0
        self.Next = None

class Node1:
    def __init__(self):
        self.gauss = None
        self.no_of_comp = 0
        self.Next = None

covariance0 = 11.0
def Create_gaussian(info1, info2, info3):
    ptr = gaussian()
    if (ptr is not None):
        ptr.mean[1, 1] = info1
        ptr.mean[1, 2] = info2
        ptr.mean[1, 3] = info3
        ptr.covariance = covariance0
        ptr.weight = 0.002
        ptr.Next = None
        ptr.Previous = None

    return ptr

def Create_Node(info1, info2, info3):
    N_ptr = Node()
    if (N_ptr is not None):
        N_ptr.Next = None
        N_ptr.no_of_components = 1
        N_ptr.pixel_s = N_ptr.pixel_r = Create_gaussian(info1, info2, info3)

    return N_ptr

List_node = []
def Insert_End_Node(n):
    List_node.append(n)

List_gaussian = []
def Insert_End_gaussian(n):
    List_gaussian.append(n)

def Delete_gaussian(n):
    List_gaussian.remove(n);

class Process:
    def __init__(self, alpha, firstFrame):
        self.alpha = alpha
        self.background = firstFrame

    def get_value(self, frame):
        self.background = frame * self.alpha + self.background * (1 - self.alpha)
        return cv2.absdiff(self.background.astype(np.uint8), frame)

def denoise(frame):
    frame = cv2.medianBlur(frame, 5)
    frame = cv2.GaussianBlur(frame, (5, 5), 0)

    return frame

capture = cv2.VideoCapture('1.mp4')
ret, orig_frame = capture.read( )
if ret is True:
    value1 = Process(0.1, denoise(orig_frame))
    run = True
else:
    run = False

while (run):
    ret, frame = capture.read()
    value = False;
    if ret is True:
        cv2.imshow('input', denoise(frame))
        grayscale = value1.get_value(denoise(frame))
        ret, mask = cv2.threshold(grayscale, 15, 255, cv2.THRESH_BINARY)
        cv2.imshow('mask', mask)
        key = cv2.waitKey(10) & 0xFF
    else:
        break

    if key == 27:
        break

    if value == True:
        orig_frame = cv2.resize(orig_frame, (340, 260), interpolation=cv2.INTER_CUBIC)
        orig_frame = cv2.cvtColor(orig_frame, cv2.COLOR_BGR2GRAY)
        orig_image_row = len(orig_frame)
        orig_image_col = orig_frame[0]

        bin_frame = np.zeros((orig_image_row, orig_image_col))
        value = []

        for i in range(0, orig_image_row):
            for j in range(0, orig_image_col):
                N_ptr = Create_Node(orig_frame[i][0], orig_frame[i][1], orig_frame[i][2])
                if N_ptr is not None:
                    N_ptr.pixel_s.weight = 1.0
                    Insert_End_Node(N_ptr)
                else:
                    print("error")
                    exit(0)

        nL = orig_image_row
        nC = orig_image_col

        dell = np.array((1, 3));
        mal_dist = 0.0;
        temp_cov = 0.0;
        alpha = 0.002;
        cT = 0.05;
        cf = 0.1;
        cfbar = 1.0 - cf;
        alpha_bar = 1.0 - alpha;
        prune = -alpha * cT;
        cthr = 0.00001;
        var = 0.0
        muG = 0.0;
        muR = 0.0;
        muB = 0.0;
        dR = 0.0;
        dB = 0.0;
        dG = 0.0;
        rval = 0.0;
        gval = 0.0;
        bval = 0.0;

        while (1):
            duration3 = 0.0;
            count = 0;
            count1 = 0;
            List_node1 = List_node;
            counter = 0;
            duration = cv2.getTickCount( );
            for i in range(0, nL):
                r_ptr = orig_frame[i]
                b_ptr = bin_frame[i]

                for j in range(0, nC):
                    sum = 0.0;
                    sum1 = 0.0;
                    close = False;
                    background = 0;

                    rval = r_ptr[0][0];
                    gval = r_ptr[0][0];
                    bval = r_ptr[0][0];

                    start = List_node1[counter].pixel_s;
                    rear = List_node1[counter].pixel_r;
                    ptr = start;

                    temp_ptr = None;
                    if (List_node1[counter].no_of_component > 4):
                        Delete_gaussian(rear);
                        List_node1[counter].no_of_component = List_node1[counter].no_of_component - 1;

                    for k in range(0, List_node1[counter].no_of_component):
                        weight = List_node1[counter].weight;
                        mult = alpha / weight;
                        weight = weight * alpha_bar + prune;
                        if (close == False):
                            muR = ptr.mean[0];
                            muG = ptr.mean[1];
                            muB = ptr.mean[2];

                            dR = rval - muR;
                            dG = gval - muG;
                            dB = bval - muB;

                            var = ptr.covariance;

                            mal_dist = (dR * dR + dG * dG + dB * dB);

                            if ((sum < cfbar) and (mal_dist < 16.0 * var * var)):
                                background = 255;

                            if (mal_dist < (9.0 * var * var)):
                                weight = weight + alpha;
                                if mult < 20.0 * alpha:
                                    mult = mult;
                                else:
                                    mult = 20.0 * alpha;

                                close = True;

                                ptr.mean[0] = muR + mult * dR;
                                ptr.mean[1] = muG + mult * dG;
                                ptr.mean[2] = muB + mult * dB;
                                temp_cov = var + mult * (mal_dist - var);
                                if temp_cov < 5.0:
                                    ptr.covariance = 5.0
                                else:
                                    if (temp_cov > 20.0):
                                        ptr.covariance = 20.0
                                    else:
                                        ptr.covariance = temp_cov;

                                temp_ptr = ptr;

                        if (weight < -prune):
                            ptr = Delete_gaussian(ptr);
                            weight = 0;
                            List_node1[counter].no_of_component = List_node1[counter].no_of_component - 1;
                        else:
                            sum += weight;
                            ptr.weight = weight;

                        ptr = ptr.Next;

                    if (close == False):
                        ptr = gaussian( );
                        ptr.weight = alpha;
                        ptr.mean[0] = rval;
                        ptr.mean[1] = gval;
                        ptr.mean[2] = bval;
                        ptr.covariance = covariance0;
                        ptr.Next = None;
                        ptr.Previous = None;
                        Insert_End_gaussian(ptr);
                        List_gaussian.append(ptr);
                        temp_ptr = ptr;
                        List_node1[counter].no_of_components = List_node1[counter].no_of_components + 1;

                    ptr = start;
                    while (ptr != None):
                        ptr.weight = ptr.weight / sum;
                        ptr = ptr.Next;

                    while (temp_ptr != None and temp_ptr.Previous != None):
                        if (temp_ptr.weight <= temp_ptr.Previous.weight):
                            break;
                        else:
                            next = temp_ptr.Next;
                            previous = temp_ptr.Previous;
                            if (start == previous):
                                start = temp_ptr;
                                previous.Next = next;
                                temp_ptr.Previous = previous.Previous;
                                temp_ptr.Next = previous;
                            if (previous.Previous != None):
                                previous.Previous.Next = temp_ptr;
                            if (next != None):
                                next.Previous = previous;
                            else:
                                rear = previous;
                                previous.Previous = temp_ptr;

                        temp_ptr = temp_ptr.Previous;

                    List_node1[counter].pixel_s = start;
                    List_node1[counter].pixel_r = rear;
                    counter = counter + 1;

capture.release()
cv2.destroyAllWindows()

Python人工智能之混合高斯模型运动目标检测详解分析

createBackgroundSubtractorMOG2

  • 背景减法 (BS) 是一种常用且广泛使用的技术,用于通过使用静态相机生成前景蒙版(即,包含属于场景中运动物体的像素的二值图像)。
  • 顾名思义,BS 计算前景蒙版,在当前帧和背景模型之间执行减法运算,其中包含场景的静态部分,或者更一般地说,根据观察到的场景的特征,可以将所有内容视为背景。

Python人工智能之混合高斯模型运动目标检测详解分析

背景建模包括两个主要步骤:

  • 后台初始化;
  • 背景更新。

在第一步中,计算背景的初始模型,而在第二步中,更新该模型以适应场景中可能的变化。

import cv2

#构造VideoCapture对象
cap = cv2.VideoCapture('1.mp4')

# 创建一个背景分割器
# createBackgroundSubtractorMOG2()函数里,可以指定detectShadows的值
# detectShadows=True,表示检测阴影,反之不检测阴影。默认是true
fgbg  = cv2.createBackgroundSubtractorMOG2()
while True :
    ret, frame = cap.read() # 读取视频
    fgmask = fgbg.apply(frame) # 背景分割
    cv2.imshow('frame', fgmask) # 显示分割结果
    if cv2.waitKey(100) & 0xff == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Python人工智能之混合高斯模型运动目标检测详解分析

小结

点赞评论走起来,瓷们!!!

Python人工智能之混合高斯模型运动目标检测详解分析

到此这篇关于Python人工智能之混合高斯模型运动目标检测详解分析的文章就介绍到这了,更多相关Python 高斯模型运动目标检测内容请搜索三水点靠木以前的文章或继续浏览下面的相关文章希望大家以后多多支持三水点靠木!

Python 相关文章推荐
python数据库操作常用功能使用详解(创建表/插入数据/获取数据)
Dec 06 Python
python中文编码问题小结
Sep 28 Python
Python中的集合类型知识讲解
Aug 19 Python
Python实现七彩蟒蛇绘制实例代码
Jan 16 Python
django反向解析和正向解析的方式
Jun 05 Python
pycharm修改界面主题颜色的方法
Jan 17 Python
对django views中 request, response的常用操作详解
Jul 17 Python
如何利用python给图片添加半透明水印
Sep 06 Python
keras获得某一层或者某层权重的输出实例
Jan 24 Python
如何实现更换Jupyter Notebook内核Python版本
May 18 Python
零基础小白多久能学会python
Jun 22 Python
学python需要去培训机构吗
Jul 01 Python
7个关于Python的经典基础案例
Nov 07 #Python
python机器学习创建基于规则聊天机器人过程示例详解
Python中Numpy和Matplotlib的基本使用指南
python模块与C和C++动态库相互调用实现过程示例
Nov 02 #Python
Qt自定义Plot实现曲线绘制的详细过程
Nov 02 #Python
Python 正则模块详情
Nov 02 #Python
Python 数据可视化之Bokeh详解
Nov 02 #Python
You might like
动画 《Pokemon Sword·Shield》系列WEB动画《薄明之翼》第2话声优阵容公开!
2020/03/06 日漫
zf框架的zend_cache缓存使用方法(zend框架)
2014/03/14 PHP
php中preg_replace_callback函数简单用法示例
2016/07/21 PHP
PHP编程计算日期间隔天数的方法
2017/04/26 PHP
javascript 控制弹出窗口
2007/04/10 Javascript
jQuery学习笔记 操作jQuery对象 属性处理
2012/09/19 Javascript
使用js操作cookie的一点小收获分享
2013/09/03 Javascript
window.print打印指定div实例代码
2013/12/13 Javascript
JS模拟键盘打字效果的方法
2015/08/05 Javascript
基于jQuery和CSS3制作数字时钟附源码下载(jquery篇)
2015/11/24 Javascript
教你如何终止JQUERY的$.AJAX请求
2016/02/23 Javascript
BOM系列第二篇之定时器requestAnimationFrame
2016/08/17 Javascript
详细谈谈AngularJS的子级作用域问题
2016/09/05 Javascript
jQuery实现的简单悬浮层功能完整实例
2017/01/23 Javascript
深入理解vue路由的使用
2017/03/24 Javascript
Angular.js自动化测试之protractor详解
2017/07/07 Javascript
jQuery实现的淡入淡出与滑入滑出效果示例
2018/04/18 jQuery
Vuejs 实现简易 todoList 功能 与 组件实例代码
2018/09/10 Javascript
JavaScript canvas实现跟随鼠标事件
2020/02/10 Javascript
微信小程序对图片进行canvas压缩的方法示例详解
2020/11/12 Javascript
Python常用随机数与随机字符串方法实例
2015/04/09 Python
python关闭windows进程的方法
2015/04/18 Python
Python类的动态修改的实例方法
2017/03/24 Python
python实现多进程代码示例
2018/10/31 Python
Win10+GPU版Pytorch1.1安装的安装步骤
2019/09/27 Python
解决Python pip 自动更新升级失败的问题
2020/02/21 Python
matplotlib 使用 plt.savefig() 输出图片去除旁边的空白区域
2021/01/05 Python
美国女孩服装购物网站:Justice
2017/03/04 全球购物
施华洛世奇天猫官方旗舰店:SWAROVSKI
2017/04/17 全球购物
面向对象概念面试题(.NET)
2016/11/04 面试题
2014年教师节讲话稿5篇
2014/09/10 职场文书
教师三严三实心得体会
2014/10/11 职场文书
学校机关党总支领导班子整改工作方案
2014/10/26 职场文书
导游词之海南-南湾猴岛
2019/10/12 职场文书
Python字符串对齐方法使用(ljust()、rjust()和center())
2021/04/26 Python
如何让你的Nginx支持分布式追踪详解
2022/07/07 Servers