基于YOLO的实时目标检测系统设计与实现

随着人工智能和计算机视觉技术的飞速发展，实时目标检测技术在自动驾驶、视频监控、人机交互等领域扮演着至关重要的角色。本设计旨在研究并实现一个基于YOLO (You Only Look Once) 深度学习算法的实时目标检测系统。系统以PyTorch/TensorFlow为深度学习框架，选用YOLOv5作为核心检测模型，完成了从数据准备、模型训练、优化到系统集成与部署的全流程。最终实现了一个具有图形用户界面（GUI）的桌面应用，能够对本地图像、视频文件以及实时摄像头流进行高效、准确的目标检测与识别。测试结果表明，该系统在保证较高检测精度的同时，具有良好的实时性，满足实际应用需求。

关键词：目标检测；YOLOv5；实时处理；深度学习；PyTorch；系统实现

第一章绪论

1.1 研究背景与意义

背景：介绍计算机视觉的发展，目标检测技术的演进（从传统方法到深度学习方法，如R-CNN系列到YOLO系列），强调实时性需求的增长（如智能驾驶对毫秒级响应的要求）。
意义：阐述实时目标检测系统的实用价值，如在安防监控（可疑人员/物品识别）、自动驾驶（车辆/行人/交通标志识别）、工业检测（产品缺陷检测）、医疗影像分析等领域的广泛应用。说明本设计对于理解和掌握前沿AI技术、培养工程实践能力的重要意义。

1.2 国内外研究现状

两阶段检测算法：简要介绍R-CNN, Fast R-CNN, Faster R-CNN，分析其精度高但速度慢的特点。
单阶段检测算法：重点介绍YOLO系列（v1-v8）、SSD、RetinaNet等，分析其“一步到位”的设计思想带来的速度优势。特别详细说明YOLOv5因其在精度、速度和易用性上的平衡而成为目前工业界最受欢迎的版本之一。
总结：当前的研究趋势是向着更快的速度、更高的精度、更轻量的模型（便于移动端部署）发展。

1.3 主要研究内容

深入学习YOLO（特别是v5/v7/v8）算法的核心原理和网络结构。
构建目标检测数据集，或使用公开数据集（如COCO, Pascal VOC），并进行数据预处理与增强。
利用深度学习框架完成YOLO模型的训练、验证与测试，并对模型进行优化（如剪枝、量化）。
设计并开发一个集成了训练好模型的桌面应用程序，提供图像、视频、实时摄像头检测功能。
设计实验对系统的性能（精度mAP、速度FPS）进行评估与分析。

1.4 论文结构安排

简述论文各个章节的主要内容（如下文所述）。

第二章相关技术与理论

2.1 目标检测基本概念

边界框（Bounding Box）、交并比（IoU）、置信度（Confidence）、非极大值抑制（NMS）。

2.2 YOLO算法原理

YOLO核心思想：将目标检测视为回归问题，直接在单个网络中预测边界框和类别概率。
YOLOv5网络结构详解：
- Backbone（主干网络）：CSPDarknet，用于特征提取。
- Neck（颈部网络）：FPN+PAN结构，用于多尺度特征融合。
- Head（检测头）：最终用于预测边界框、物体置信度和类别概率。
损失函数：YOLOv5使用的复合损失函数（分类损失、置信度损失、定位损失）。

2.3 开发工具与框架

深度学习框架：PyTorch（推荐，因为YOLOv5官方基于PyTorch）。
编程语言：Python。
GUI开发库：PyQt5或Tkinter（推荐PyQt5，界面更美观专业）。
其他库：OpenCV（图像处理）、NumPy（数值计算）、CUDA&cuDNN（GPU加速）。

第三章系统总体设计

3.1 系统需求分析

功能性需求：图像目标检测、视频文件逐帧检测、实时摄像头流检测、检测结果可视化（绘制框、标签、置信度）、模型切换功能。
非功能性需求：实时性（≥30 FPS）、准确性（mAP值）、系统易用性（友好的GUI）、跨平台性（可选）。

3.2 系统架构设计

整体架构图：（绘制一个框图）
- 表示层（UI）：GUI界面，负责接收用户输入和显示结果。
- 业务逻辑层：核心控制模块，调用检测模块处理数据，并管理视频流。
- 算法层：加载好的YOLO模型，执行 inference（推理）。
- 数据层：本地图像/视频文件、摄像头采集的数据流。

3.3 功能模块设计

模型加载模块：负责加载预训练或自定义训练的YOLO权重（.pt文件）。
图像处理模块：负责读取图像，进行尺寸缩放、归一化等预处理。
视频/Camera处理模块：负责读取视频帧或摄像头数据流。
推理检测模块：核心模块，调用YOLO模型进行前向传播，得到检测结果。
结果可视化模块：使用OpenCV将检测结果（框、标签）绘制在图像/帧上。
GUI交互模块：提供按钮、菜单、文件选择对话框、结果显示区域等。

第四章系统实现与测试

4.1 开发环境搭建

列出详细环境：Python 3.8, PyTorch 1.12.1, CUDA 11.3, PyQt5 5.15.7, OpenCV 4.6.0等。

4.2 模型训练与优化（可选但加分）

说明使用的是COCO预训练模型，还是在自己的数据集上进行了微调训练。描述数据集的构建、数据增强策略、训练超参数设置和训练过程。

4.3 各功能模块实现

GUI实现：展示UI界面截图，并解释主要控件（上传图片按钮、开始摄像按钮、模型选择下拉框、置信度滑块等）。

核心检测代码片段：提供关键代码，如调用YOLOv5模型进行推理的代码。

python

复制

下载

# 示例代码 - 使用PyTorch Hub加载YOLOv5
import torch
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) # 加载官方预训练模型

# 对图像进行推理
img = 'path/to/image.jpg'
results = model(img)

# 结果显示和保存
results.show()
results.save() # 保存结果图像

4.4 系统测试与分析

测试环境：硬件（CPU: i7-12700H, GPU: RTX 3060 Laptop）、软件（Windows 11）。
测试数据：使用公开测试集或自行收集的图片/视频。
评价指标：
- 精度：mAP@0.5（在IoU=0.5下的平均精度）。
- 速度：FPS（Frames Per Second）。
测试结果：制作表格，对比不同模型（如YOLOv5s, YOLOv5m, YOLOv5l）在不同输入尺寸下的FPS和mAP，分析速度与精度的权衡。
系统展示：提供系统运行的效果图（检测图片、视频、摄像头的截图），并对结果进行分析。

第五章总结与展望

5.1 工作总结

全面总结本设计完成的工作：从理论学习、环境搭建、模型准备、代码编写、系统集成到测试评估的全过程。强调实现了一个功能完整、达到实时性要求的检测系统。

5.2 主要创新点（可选）

例如：实现了基于注意力机制的轻量化改进、设计了一种新的数据增强方法、开发了基于C++的加速部署等（如果没有，可以省略）。

5.3 存在问题与未来展望

问题：模型在小目标检测上表现不佳；在极端光照条件下精度下降；依赖GPU，难以在低功耗设备上部署。
展望：尝试更新的YOLO版本（如v8, v9）；探索模型剪枝、量化技术以部署到移动端或嵌入式设备（如Jetson Nano）；增加更多功能，如目标计数、越界报警等。

参考文献

[1] Redmon J, et al. You Only Look Once: Unified, Real-Time Object Detection[C]// CVPR. 2016.
[2] Redmon J, Farhadi A. YOLO9000: Better, Faster, Stronger[C]// CVPR. 2017.
[3] Bochkovskiy A, et al. YOLOv4: Optimal Speed and Accuracy of Object Detection[J]. arXiv preprint arXiv:2004.10934, 2020.
[4] Jocher G, et al. ultralytics/yolov5: v5.0 - YOLOv5-P6 1280 models, AWS, Supervise.ly and YouTube integrations[J]. Zenodo, 2021. (YOLOv5官方代码库)
[5] Lin T Y, et al. Microsoft COCO: Common Objects in Context[C]// ECCV. 2014.

致谢

感谢导师的悉心指导，感谢实验室同学的支持，感谢家人朋友的鼓励。

下一步行动建议：

环境搭建：立即开始安装Python、PyTorch、CUDA等环境。这是第一步，可能会遇到很多问题。
跑通官方Demo：从YOLOv5官方GitHub仓库（https://github.com/ultralytics/yolov5）下载代码，按照教程尝试用预训练模型检测一下图片和视频，先感受一下效果。
确定技术栈：决定你用PyQt5还是Tkinter做GUI。PyQt5学习曲线稍陡但效果更好。
开始编码：先实现核心的检测函数，然后再用GUI把它包装起来。分模块开发，逐个击破。
撰写论文：在开发过程中，就可以同步撰写论文的相关章节，如绪论、关键技术等。

代码举例

### **项目结构**
```
yolo_detection_system/
├── main.py # 程序主入口
├── ui_window.py # PyQt5 主窗口类
├── detection.py # 封装YOLO检测功能的类
├── models/
│ └── yolov5s.pt # 预训练的YOLOv5s模型（需自行下载）
├── examples/ # 存放测试用的图片和视频
└── requirements.txt # 项目依赖
```

### **1. 环境配置 (requirements.txt)**
首先，创建并安装依赖：
```bash
pip install -r requirements.txt
```
`requirements.txt` 内容：
```
torch>=1.7.0
torchvision>=0.8.1
opencv-python>=4.5.1
pyqt5>=5.15.0
numpy>=1.19.3
pyqt5-tools # 可选，用于设计界面
```

### **2. 下载预训练模型**
请从 YOLOv5 官方 GitHub 仓库下载 `yolov5s.pt` (小型模型，速度最快) 并放入 `models/` 文件夹。
[下载链接](https://github.com/ultralytics/yolov5/releases/download/v5.0/yolov5s.pt)

---

### **3. 核心代码**

#### **3.1 检测功能模块 (`detection.py`)**
这个类封装了所有与YOLO模型交互的逻辑。
```python
import cv2
import numpy as np
import torch
from models.experimental import attempt_load
from utils.general import non_max_suppression, scale_boxes
from utils.datasets import LoadImages
from utils.plots import plot_one_box

class YOLODetector:
def __init__(self, weights_path, conf_thres=0.5, iou_thres=0.45):
"""
初始化YOLO检测器
:param weights_path: 模型权重文件路径
:param conf_thres: 置信度阈值
:param iou_thres: IOU阈值，用于NMS
"""
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model = attempt_load(weights_path, map_location=self.device) # 加载模型
self.stride = int(self.model.stride.max()) # 模型步长
self.conf_thres = conf_thres
self.iou_thres = iou_thres
self.names = self.model.module.names if hasattr(self.model, 'module') else self.model.names # 获取类别名称

def detect(self, img_bgr):
"""
对输入的BGR图像进行目标检测
:param img_bgr: OpenCV读取的BGR图像
:return: 绘制了检测框的图像，检测结果信息
"""
# 复制原图像，用于绘制结果
img_draw = img_bgr.copy()
# 图像预处理
img = self.preprocess(img_bgr)

# 模型推理
with torch.no_grad():
pred = self.model(img)[0]

# NMS后处理
pred = non_max_suppression(pred, self.conf_thres, self.iou_thres)

det_info = [] # 存储检测信息

# 处理检测结果
for det in pred:
if len(det):
# 将检测框坐标缩放回原图尺寸
det[:, :4] = scale_boxes(img.shape[2:], det[:, :4], img_draw.shape).round()
for *xyxy, conf, cls in reversed(det):
label = f'{self.names[int(cls)]} {conf:.2f}'
# 在图像上绘制边界框和标签
plot_one_box(xyxy, img_draw, label=label, color=(0, 255, 0), line_thickness=2)
# 记录检测信息
det_info.append({
'class': self.names[int(cls)],
'confidence': float(conf),
'bbox': [int(xyxy[0]), int(xyxy[1]), int(xyxy[2]), int(xyxy[3])]
})

return img_draw, det_info

def preprocess(self, img_bgr):
"""
图像预处理
:param img_bgr: OpenCV读取的BGR图像
:return: 处理后的张量
"""
# 调整图像尺寸为模型的输入尺寸，保持宽高比
img_resized = letterbox(img_bgr, new_shape=640, stride=self.stride)[0]
# BGR to RGB, HWC to CHW
img_rgb = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
img_chw = img_rgb.transpose((2, 0, 1)) # HWC to CHW
img_chw = np.ascontiguousarray(img_chw)
# 转换为张量并归一化
img_tensor = torch.from_numpy(img_chw).to(self.device).float()
img_tensor /= 255.0 # 归一化到 [0,1]
# 添加批次维度
img_tensor = img_tensor.unsqueeze(0)
return img_tensor

# 由于utils中的函数需要导入，这里提供一个简单的letterbox实现
def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), stride=32):
# 调整图像尺寸并保持宽高比
shape = im.shape[:2] # 当前形状 [高, 宽]
# 计算缩放比例
r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
# 计算填充
new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding
# 调整图像大小
if shape[::-1] != new_unpad:
im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
# 计算上下左右填充值
top, bottom = int(round(dh / 2 - 0.1)), int(round(dh / 2 + 0.1))
left, right = int(round(dw / 2 - 0.1)), int(round(dw / 2 + 0.1))
# 添加边框
im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
return im, (left, top), (new_unpad[0] / shape[1], new_unpad[1] / shape[0]) # 图像, 填充比例
```

#### **3.2 用户界面模块 (`ui_window.py`)**
这个类创建了系统的主界面。
```python
import sys
import cv2
from PyQt5.QtWidgets import (QApplication, QMainWindow, QLabel, QPushButton,
QVBoxLayout, QHBoxLayout, QWidget, QFileDialog,
QSlider, QComboBox, QTextEdit)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QImage, QPixmap
from detection import YOLODetector

class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("基于YOLOv5的实时目标检测系统")
self.setGeometry(100, 100, 1200, 800)

# 初始化变量
self.detector = None
self.cap = None
self.timer = QTimer()
self.current_mode = None # 'image', 'video', 'camera'

self.init_ui()
self.load_model() # 初始化时加载模型

def init_ui(self):
# 中央部件和主布局
central_widget = QWidget()
self.setCentralWidget(central_widget)
main_layout = QHBoxLayout(central_widget)

# 左侧控制面板
control_panel = QWidget()
control_layout = QVBoxLayout(control_panel)
control_panel.setMaximumWidth(300)

# 模型选择
self.model_combo = QComboBox()
self.model_combo.addItems(['yolov5s', 'yolov5m', 'yolov5l']) # 可扩展
self.model_combo.currentTextChanged.connect(self.change_model)

# 置信度滑块
self.conf_slider = QSlider(Qt.Horizontal)
self.conf_slider.setRange(0, 100)
self.conf_slider.setValue(50) # 默认0.5
self.conf_slider.valueChanged.connect(self.update_conf_thres)

# 功能按钮
self.btn_open_image = QPushButton("打开图片")
self.btn_open_video = QPushButton("打开视频")
self.btn_open_camera = QPushButton("打开摄像头")
self.btn_stop = QPushButton("停止")

self.btn_open_image.clicked.connect(self.open_image)
self.btn_open_video.clicked.connect(self.open_video)
self.btn_open_camera.clicked.connect(self.open_camera)
self.btn_stop.clicked.connect(self.stop)

# 信息显示
self.info_text = QTextEdit()
self.info_text.setMaximumHeight(150)

# 添加到控制面板布局
control_layout.addWidget(QLabel("选择模型:"))
control_layout.addWidget(self.model_combo)
control_layout.addWidget(QLabel("置信度阈值:"))
control_layout.addWidget(self.conf_slider)
control_layout.addWidget(self.btn_open_image)
control_layout.addWidget(self.btn_open_video)
control_layout.addWidget(self.btn_open_camera)
control_layout.addWidget(self.btn_stop)
control_layout.addWidget(QLabel("检测信息:"))
control_layout.addWidget(self.info_text)

# 右侧图像显示区域
self.image_label = QLabel()
self.image_label.setAlignment(Qt.AlignCenter)
self.image_label.setMinimumSize(640, 480)
self.image_label.setText("请选择图片、视频或摄像头")

# 将控制面板和图像显示区域添加到主布局
main_layout.addWidget(control_panel)
main_layout.addWidget(self.image_label)

# 连接定时器
self.timer.timeout.connect(self.update_frame)

def load_model(self, model_name='yolov5s'):
"""加载YOLO模型"""
try:
model_path = f'models/{model_name}.pt'
self.detector = YOLODetector(model_path, conf_thres=0.5)
self.info_text.append(f"模型 {model_name} 加载成功！")
except Exception as e:
self.info_text.append(f"模型加载失败: {str(e)}")

def change_model(self, model_name):
"""切换模型"""
self.load_model(model_name)

def update_conf_thres(self, value):
"""更新置信度阈值"""
if self.detector:
self.detector.conf_thres = value / 100.0

def open_image(self):
"""打开图片文件"""
file_path, _ = QFileDialog.getOpenFileName(self, "选择图片", "", "Image Files (*.png *.jpg *.jpeg *.bmp)")
if file_path:
self.stop()
self.current_mode = 'image'
img = cv2.imread(file_path)
if img is not None:
self.process_image(img)

def open_video(self):
"""打开视频文件"""
file_path, _ = QFileDialog.getOpenFileName(self, "选择视频", "", "Video Files (*.mp4 *.avi *.mov)")
if file_path:
self.stop()
self.current_mode = 'video'
self.cap = cv2.VideoCapture(file_path)
self.timer.start(30) # 30ms间隔，约33FPS

def open_camera(self):
"""打开摄像头"""
self.stop()
self.current_mode = 'camera'
self.cap = cv2.VideoCapture(0) # 0表示默认摄像头
self.timer.start(30)

def stop(self):
"""停止检测"""
if self.timer.isActive():
self.timer.stop()
if self.cap:
self.cap.release()
self.current_mode = None

def update_frame(self):
"""更新视频帧"""
if self.cap and self.cap.isOpened():
ret, frame = self.cap.read()
if ret:
self.process_image(frame)

def process_image(self, img_bgr):
"""处理图像并进行检测"""
if self.detector:
# 进行目标检测
result_img, det_info = self.detector.detect(img_bgr)

# 显示检测信息
info_str = f"检测到 {len(det_info)} 个目标:\n"
for info in det_info:
info_str += f"{info['class']} ({info['confidence']:.2f}) "
self.info_text.setPlainText(info_str)

# 转换图像格式并显示
img_rgb = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
h, w, ch = img_rgb.shape
bytes_per_line = ch * w
qt_img = QImage(img_rgb.data, w, h, bytes_per_line, QImage.Format_RGB888)
self.image_label.setPixmap(QPixmap.fromImage(qt_img).scaled(
640, 480, Qt.KeepAspectRatio, Qt.SmoothTransformation))

def closeEvent(self, event):
"""关闭窗口时释放资源"""
self.stop()
event.accept()
```

#### **3.3 主程序入口 (`main.py`)**
```python
import sys
from PyQt5.QtWidgets import QApplication
from ui_window import MainWindow

def main():
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())

if __name__ == '__main__':
main()
```

---

### **4. 运行系统**
1. 确保所有文件放在正确的目录结构中。
2. 下载 `yolov5s.pt` 模型文件到 `models/` 文件夹。
3. 在终端运行：
```bash
python main.py
```

### **5. 系统功能说明**
1. **模型选择**：可以选择不同的YOLOv5模型（需要下载对应的.pt文件）。
2. **置信度调节**：通过滑块实时调整检测的置信度阈值。
3. **图片检测**：支持打开本地图片文件进行检测。
4. **视频检测**：支持打开本地视频文件进行逐帧检测。
5. **实时摄像头**：支持调用电脑摄像头进行实时检测。
6. **信息显示**：实时显示检测到的目标数量和类别。

### **注意事项**
1. 首次运行时会自动下载YOLOv5的相关代码（通过torch.hub）。
2. 确保有可用的摄像头（如果使用摄像头功能）。
3. GPU环境会显著提升检测速度。如果没有GPU，系统仍可在CPU上运行，但速度会较慢。

这个系统提供了一个完整的、可扩展的框架，你可以在此基础上继续添加更多功能，如目标计数、保存检测结果、模型性能评估等。祝你毕业设计顺利！

代码直接运行

直接运行的“基于 YOLO 的实时目标检测系统”完整参考实现（Python 3.8+）。
特点

以 YOLOv8（Ultralytics）为核心检测器，支持 GPU/CPU
支持 3 种输入：本地摄像头、本地视频文件、RTSP/HTTP 网络流
实时显示检测结果（类别、置信度、边框）
模块化设计，后续可无缝接入 DeepSORT、行为识别、报警等模块

一、环境准备

bash

复制

# 1. 创建虚拟环境（可选）
python -m venv yolo_rt
source yolo_rt/bin/activate        # Win: yolo_rt\Scripts\activate

# 2. 安装依赖
pip install ultralytics opencv-python PyQt5
# 若需 GPU，确保已安装 CUDA + PyTorch GPU 版本

二、项目结构

复制

yolo_rt_system/
├─ main.py          # PyQt 主界面
├─ detector.py      # YOLO 检测线程
├─ config.py        # 全局配置
└─ README.md

三、核心代码

config.py

Python

复制

# 全局配置
MODEL_WEIGHTS = "yolov8n.pt"      # 也可换成自己训练的 best.pt
IOU_THRES   = 0.45
CONF_THRES  = 0.35
INPUT_SRC   = 0                   # 0=摄像头，或 "test.mp4"/"rtsp://..."

detector.py

Python

复制

import cv2, time, threading
from ultralytics import YOLO
from PyQt5.QtCore import QThread, pyqtSignal
from config import *

class YOLODetector(QThread):
    send_frame = pyqtSignal(object)      # 原始帧
    send_result = pyqtSignal(object)     # 画好框的帧

    def __init__(self):
        super().__init__()
        self.model = YOLO(MODEL_WEIGHTS)
        self.running = True
        self.cap = cv2.VideoCapture(INPUT_SRC)

    def run(self):
        while self.running and self.cap.isOpened():
            ret, frame = self.cap.read()
            if not ret:
                break
            # 推理
            results = self.model.predict(
                frame,
                conf=CONF_THRES,
                iou=IOU_THRES,
                verbose=False
            )[0]
            annotated = results.plot()   # 画框
            self.send_frame.emit(frame)
            self.send_result.emit(annotated)
            time.sleep(0.01)
        self.cap.release()

    def stop(self):
        self.running = False
        self.wait()

main.py

Python

复制

import sys, cv2
from PyQt5.QtWidgets import (QApplication, QMainWindow, QLabel, QVBoxLayout,
                             QWidget, QPushButton, QHBoxLayout)
from PyQt5.QtGui import QImage, QPixmap
from PyQt5.QtCore import Qt
from detector import YOLODetector

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("YOLO 实时检测系统")
        self.resize(900, 650)

        # 视频标签
        self.raw_label = QLabel("原始画面")
        self.raw_label.setAlignment(Qt.AlignCenter)
        self.res_label = QLabel("检测结果")
        self.res_label.setAlignment(Qt.AlignCenter)

        # 控制按钮
        self.btn_start = QPushButton("开始")
        self.btn_stop  = QPushButton("停止")
        self.btn_start.clicked.connect(self.start_detect)
        self.btn_stop.clicked.connect(self.stop_detect)

        hbox = QHBoxLayout()
        hbox.addWidget(self.raw_label)
        hbox.addWidget(self.res_label)

        vbox = QVBoxLayout()
        vbox.addLayout(hbox)
        vbox.addWidget(self.btn_start)
        vbox.addWidget(self.btn_stop)

        w = QWidget()
        w.setLayout(vbox)
        self.setCentralWidget(w)

        self.detector = None

    # 将 numpy 数组转为 QPixmap
    def cv2_to_pixmap(self, cv_img):
        rgb = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
        h, w, ch = rgb.shape
        bytes_per_line = ch * w
        qimg = QImage(rgb.data, w, h, bytes_per_line, QImage.Format_RGB888)
        return QPixmap.fromImage(qimg)

    def update_raw(self, frame):
        self.raw_label.setPixmap(self.cv2_to_pixmap(frame).scaled(
            400, 300, Qt.KeepAspectRatio))

    def update_result(self, frame):
        self.res_label.setPixmap(self.cv2_to_pixmap(frame).scaled(
            400, 300, Qt.KeepAspectRatio))

    def start_detect(self):
        if self.detector is None or not self.detector.isRunning():
            self.detector = YOLODetector()
            self.detector.send_frame.connect(self.update_raw)
            self.detector.send_result.connect(self.update_result)
            self.detector.start()

    def stop_detect(self):
        if self.detector and self.detector.isRunning():
            self.detector.stop()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    w = MainWindow()
    w.show()
    sys.exit(app.exec_())

四、运行

bash

复制

python main.py

五、后续扩展建议

跟踪：将 DeepSORT 或 ByteTrack 集成进 detector.py，实现跨帧 ID 关联。
行为识别：用 MediaPipe 提取关键点 + LSTM 做摔倒/奔跑检测。
报警：检测异常后通过 SMTP、Twilio、Flask API 等方式推送。
加速：TensorRT 或 OpenVINO 优化 YOLO 模型，在 Jetson 等边缘端可达 30~60 FPS。
Web 部署：将界面改为 Streamlit/FastAPI，浏览器即可使用

创新点

创新点：基于YOLO的多模态智能感知与行为分析系统

创新内容具体描述

多模态反馈机制：
- 视觉增强：使用不同颜色和闪烁效果区分不同危险等级的目标
- 声音预警：根据检测到的目标类型和距离播放不同的预警音效
- 语音播报：实时语音提示检测到的关键目标信息
智能行为分析：
- 区域入侵检测：自定义监控区域，检测是否有目标进入禁区
- 目标计数与统计：实时统计各类别目标数量并生成报表
- 轨迹预测：基于历史位置预测目标运动轨迹
自适应优化：
- 动态模型切换：根据场景复杂度自动切换不同大小的YOLO模型
- 智能分辨率调整：根据目标密度自动调整检测分辨率以平衡速度与精度
增强现实显示：
- 3D边界框：在视频流上显示伪3D效果的目标框
- 信息面板：实时显示系统状态和检测统计信息【计算机视觉】基于YOLO的多模态智能感知系统：融合行为分析与自适应优化的实时目标检测设计资源-优快云下载https://download.youkuaiyun.com/download/matlab_python22/91866320