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的web.py框架实现类似Django的ORM查询的教程
May 02 Python
简单谈谈Python中的反转字符串问题
Oct 24 Python
Python使用QQ邮箱发送Email的方法实例
Feb 09 Python
Python使用getpass库读取密码的示例
Oct 10 Python
python jieba分词并统计词频后输出结果到Excel和txt文档方法
Feb 11 Python
Python反爬虫技术之防止IP地址被封杀的讲解
Jan 09 Python
Python测试模块doctest使用解析
Aug 10 Python
解决python3 安装不了PIL的问题
Aug 16 Python
对pytorch中的梯度更新方法详解
Aug 20 Python
python应用Axes3D绘图(批量梯度下降算法)
Mar 25 Python
Python实现UDP程序通信过程图解
May 15 Python
Python用SSH连接到网络设备
Feb 18 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
使用PHP维护文件系统
2006/10/09 PHP
PHP IF ELSE简化/三元一次式的使用
2011/08/22 PHP
php数组函数序列之asort() - 对数组的元素值进行升序排序,保持索引关系
2011/11/02 PHP
4种PHP异步执行的常用方式
2015/12/24 PHP
PHP用continue跳过本次循环中剩余代码的注意点
2017/06/27 PHP
php实现构建排除当前元素的乘积数组方法
2018/10/06 PHP
phpMyAdmin通过密码漏洞留后门文件
2018/11/20 PHP
写了10年的Javascript也未必全了解的连续赋值运算
2011/03/25 Javascript
js中scrollHeight,scrollWidth,scrollLeft,scrolltop等差别介绍
2012/05/16 Javascript
JavaScript中的Math.E属性使用详解
2015/06/12 Javascript
移动端横屏的JS代码(beta)
2016/05/16 Javascript
深入理解JS addLoadEvent函数
2016/05/20 Javascript
浅谈jQuery中ajaxPrefilter的应用
2016/08/01 Javascript
Easyui Tree获取当前选择节点的所有顶级父节点
2017/02/14 Javascript
js前端日历控件(悬浮、拖拽、自由变形)
2017/03/02 Javascript
es6 字符串String的扩展(实例讲解)
2017/08/03 Javascript
Rollup处理并打包JS文件项目实例代码
2018/05/31 Javascript
vue实现在线翻译功能
2019/09/27 Javascript
ant design vue中表格指定格式渲染方式
2020/10/28 Javascript
python3.5仿微软计算器程序
2020/03/30 Python
django rest framework 数据的查找、过滤、排序的示例
2018/06/25 Python
解决Python pandas df 写入excel 出现的问题
2018/07/04 Python
Python判断一个list中是否包含另一个list全部元素的方法分析
2018/12/24 Python
把pandas转换int型为str型的方法
2019/01/29 Python
python将字符串转换成json的方法小结
2019/07/09 Python
详解Django-channels 实现WebSocket实例
2019/08/22 Python
HTML5输入框下拉菜单功能的示例代码
2020/09/08 HTML / CSS
阿里巴巴英国:Alibaba英国
2019/12/11 全球购物
CK加拿大官网:Calvin Klein加拿大
2020/03/14 全球购物
Java中有几种方法可以实现一个线程?用什么关键字修饰同步方法?stop()和suspend()方法为何不推荐使用?
2015/08/04 面试题
自荐信包含哪些内容
2013/10/30 职场文书
应聘编辑自荐信范文
2014/03/12 职场文书
县政协领导班子群众路线教育实践活动四风问题整改方案
2014/10/26 职场文书
2014年社区工会工作总结
2014/12/18 职场文书
2015年清明节网上祭英烈活动总结
2015/03/26 职场文书
销售口号霸气押韵
2015/12/24 职场文书