基于YOLOv8与Django框架的智能交通标志识别系统

基于YOLOv8与Django框架的智能交通标志识别系统

基于YOLOv8的交通标志检测与分析系统

【包含内容】
【一】项目提供完整源代码及详细注释
【二】系统设计思路与实现说明
【三】模型文件 (best.pt 等)

【技术栈】
①：系统环境：Windows 10/11, macOS, Linux (如 Ubuntu)
②：开发环境：PyCharm / VSCode + Python 3.8+
③：技术栈：Python + Django + YOLOv8 (ultralytics) + OpenCV + Pillow + NumPy

【功能模块】
①：图像标志检测：上传静态图片，系统识别图片中的交通标志，输出带有标注框和置信度的结果图，并统计各类标志数量。
②：视频标志检测：上传视频文件，系统逐帧分析视频流，检测交通标志，生成带有标注的结果视频，并汇总整个视频的检测信息。
③：实时标志检测：调用摄像头进行实时画面捕捉，动态检测画面中的交通标志，实时显示标注结果，并可录制保存检测过程。
④：结果可视化：在输出的图片或视频帧上绘制检测框、标志类别名称和置信度得分，支持中文标签显示（需配置字体）。
⑤：模型切换：支持加载不同的YOLOv8模型文件（如 best.pt, cmba.pt），方便进行效果对比或使用特定训练的模型。

【系统特点】
① 高精度识别: 基于先进的YOLOv8算法，对交通标志实现快速准确的检测。
② 多种输入源: 支持处理静态图像、本地视频文件以及实时摄像头视频流。
③ 详细信息输出: 提供每个检测目标的边界框、类别、置信度，并统计汇总检测结果。
④ 友好可视化: 检测结果直观地标注在图像或视频上，易于理解。

【核心技术】
① YOLOv8目标检测算法: 用于定位和识别图像/视频中的交通标志。
② OpenCV: 用于图像和视频的读取、处理、绘制和保存。
③ Pillow (PIL): 用于在图像上绘制文本标签，特别是处理中文字符。
④ NumPy: 用于高效处理图像数据和检测结果数组。

【应用场景】
① 智能交通监控: 分析路面情况，辅助交通流量管理。
② 辅助驾驶系统: 为车辆提供实时的交通标志信息。
③ 道路设施巡检: 自动统计和识别道路上的交通标志类型与数量。
④ 交通安全研究: 分析特定路段的标志设置或驾驶员行为。

【拓展服务】
① 部署+150
② 如果有数据需要+100

摘要

随着汽车保有量的持续增长和智慧城市建设的推进，道路交通安全与效率成为日益重要的议题。交通标志作为道路语言的关键组成部分，其准确、实时的识别对于保障交通安全、实现智能驾驶辅助至关重要。传统交通标志识别方法存在环境适应性差、识别精度不高等问题，难以满足现代智能交通系统的需求。近年来，以深度学习为代表的人工智能技术在计算机视觉领域取得了突破性进展，特别是YOLO（You Only Look Once）系列算法，以其出色的速度和精度平衡，在目标检测任务中表现突出。

本项目旨在设计并实现一个基于YOLOv8算法和Django Web框架的智能交通标志识别系统。系统利用先进的YOLOv8模型对输入的图像、视频或实时摄像头画面进行交通标志的快速、准确检测与识别。后端采用功能强大且成熟的Python Django框架，负责处理用户请求、管理数据以及与检测模型交互；前端采用HTML、CSS和JavaScript技术，结合Bootstrap框架和Particles.js库，构建了一个现代化、用户友好的交互界面，提供包括用户注册登录、个人信息管理、图片/视频/实时检测、历史记录查询与管理、管理员后台（系统看板、用户管理）等功能。系统实现了从数据上传到结果展示的完整流程，并特别考虑了用户体验和系统的可操作性。通过对YOLOv8和Django等关键技术的集成应用，本项目旨在为交通标志识别提供一个高效、可靠且易于扩展的解决方案，对提升道路交通安全管理水平和推动智能驾驶技术发展具有一定的实践意义和参考价值。

关键词： 交通标志识别；YOLOv8；Django；深度学习；目标检测；智能交通系统

1. 引言

1.1 研究背景与意义

进入21世纪，全球汽车工业飞速发展，汽车已成为人们日常出行的主要交通工具。随之而来的是日益严峻的交通安全问题和日益增长的交通管理压力。交通事故每年造成巨大的人员伤亡和财产损失，其中很大一部分事故与驾驶员未能及时、准确地识别和理解交通标志有关。交通标志作为道路交通法规和信息的重要载体，是引导交通流、警示潜在危险、保障行车安全的关键设施。因此，实现交通标志的自动化、智能化识别，不仅能够有效辅助驾驶员，减少因视觉疲劳、注意力不集中或环境干扰导致的误判，还能为高级驾驶辅助系统（ADAS）和自动驾驶技术提供关键的环境感知信息，是构建现代智能交通系统（Intelligent Transportation Systems, ITS）不可或缺的一环。

传统的交通标志识别方法通常依赖于手工设计的特征（如颜色、形状特征 SIFT、SURF、HOG 等）和经典的机器学习算法（如 SVM、AdaBoost 等）。这些方法在特定条件下能够取得一定的效果，但普遍存在以下局限性：1）对光照变化、天气条件（雨、雪、雾）、遮挡、污损、角度倾斜等复杂环境因素敏感，鲁棒性较差；2）特征设计依赖专家经验，泛化能力有限，难以适应种类繁多、形态各异的交通标志；3）识别流程复杂，实时性难以保证，无法满足高速行驶或实时监控的需求。

近年来，深度学习技术的迅猛发展，特别是卷积神经网络（Convolutional Neural Networks, CNN）在图像识别和目标检测领域的巨大成功，为解决传统方法的瓶颈带来了新的契机。基于深度学习的目标检测算法，如 Faster R-CNN、SSD 以及 YOLO 系列，能够自动从大量数据中学习强大的特征表示，显著提升了检测的精度和鲁棒性。YOLO（You Only Look Once）系列算法以其独特的单阶段检测思想，将目标定位和分类任务统一处理，实现了速度与精度的优异平衡，特别适合需要实时处理的应用场景。YOLOv8 作为该系列的最新进展，在前代基础上进一步优化了网络结构、损失函数和训练策略，在多个公开数据集上取得了领先的性能。

在此背景下，结合强大的YOLOv8目标检测算法和成熟的Django Web框架，开发一个集成了多种检测模式（图片、视频、实时）、具备用户管理和历史记录功能的智能交通标志识别系统，具有重要的理论研究价值和广阔的应用前景。它不仅可以作为研究深度学习在交通领域应用的实例，验证先进算法的有效性，也能为实际的交通管理、驾驶辅助提供一个实用、高效的技术平台，对于提升道路安全水平、推动智慧交通发展具有积极的促进作用。

1.2 国内外研究现状

交通标志识别（Traffic Sign Recognition, TSR）一直是计算机视觉和智能交通领域的研究热点。

国外研究起步较早，早期研究主要集中于基于颜色和形状特征的方法。例如，利用 HSI 或 HSV 颜色空间分割出候选区域，再通过霍夫变换、模板匹配或形状描述子（如傅里叶描述子）识别标志形状。随着机器学习的发展，支持向量机（SVM）、AdaBoost 等算法被广泛应用于标志分类。进入深度学习时代后，研究重心迅速转向基于 CNN 的方法。德国交通标志识别基准（GTSRB）等大型公开数据集的发布极大地推动了该领域的发展。研究者们提出了各种基于 CNN 的 TSR 系统，包括改进的 LeNet、AlexNet、VGG、ResNet 等，以及专门为 TSR 设计的轻量级网络。同时，目标检测算法如 Faster R-CNN、SSD、YOLO 等也被成功应用于交通标志的检测与识别，实现了端到端的处理。许多研究还关注于提升系统在恶劣天气、低光照、部分遮挡等挑战性场景下的鲁棒性。

国内在交通标志识别领域的研究也取得了长足的进步。早期同样经历了基于传统图像处理和机器学习的阶段。近年来，随着深度学习技术的普及，国内学者和研究机构在基于 CNN 的 TSR 方面开展了大量工作。一方面，积极跟进国际前沿，将最新的目标检测算法（特别是 YOLO 系列）应用于国内交通标志数据集（如 CCTSDB），并针对中国交通标志的特点进行优化。另一方面，也进行了创新性研究，例如，探索多任务学习（同时识别标志和属性）、注意力机制、模型压缩与加速等方法，以提升识别性能和效率。此外，结合 Web 技术和移动端技术，开发实用的 TSR 应用系统也成为研究的热点方向。

尽管国内外在交通标志识别方面已取得显著成果，但仍面临一些挑战：1）数据集偏差问题，模型在特定数据集上表现良好，但在真实复杂多变的道路环境中泛化能力可能下降；2）小目标和远距离目标检测困难；3）实时性与高精度的权衡，尤其是在资源受限的嵌入式平台上；4）如何有效融合多源信息（如地图数据、车辆状态）以提高识别的可靠性。本项目采用先进的 YOLOv8 算法，旨在提升检测的精度和速度，并通过 Django 框架构建一个易于使用和扩展的应用系统，是对现有研究的有益补充和实践。

1.3 本文主要工作

本项目的主要工作在于设计、开发并实现一个基于 YOLOv8 算法和 Django Web 框架的智能交通标志识别系统。具体工作内容包括：

1. 系统需求分析与可行性研究： 深入分析了交通标志识别系统的应用场景和用户需求，明确了系统的功能性需求（如多模式检测、用户管理、历史记录等）和非功能性需求（如性能、易用性、安全性等），并从技术、经济和操作层面进行了可行性论证。
2. 关键技术研究与选型： 深入研究了深度学习目标检测技术，特别是 YOLOv8 算法的原理、优势及应用；研究了 Django Web 框架的 MVT 架构、核心组件及开发流程；研究了 OpenCV 在图像/视频处理中的应用；选择了 Python 作为主要开发语言，SQLite 作为开发阶段数据库，并集成了 Bootstrap、Particles.js 等前端技术。
3. 系统整体架构与模块设计： 设计了系统的总体架构，采用前后端分离的思想，明确了前端（用户界面）、后端（Django 应用）和核心检测模块（YOLOv8/OpenCV）之间的交互方式。将系统划分为用户认证、用户管理、图片检测、视频检测、实时检测、历史记录等功能模块，并对各模块的功能和接口进行了详细设计。
4. 数据库设计： 根据系统需求，设计了数据库模型，包括用户信息（扩展 Django 内建 User）、用户档案（Profile，包含用户类型、电话等）和检测历史记录（DetectionHistory），明确了各模型之间的关系和关键字段。
5. 系统核心功能实现：
   • 实现了基于 YOLOv8 的交通标志检测核心逻辑，封装在 TrafficSignDetector 类中，包括加载模型、处理图像/视频/实时帧、绘制边界框和中文标签等。
   • 利用 Django 框架实现了完整的后端功能，包括用户注册、登录、注销、个人资料修改、密码重置（简化版）、检测历史的增删查、管理员后台的用户管理（增删改查）和系统统计数据展示。
   • 利用 HTML、CSS、JavaScript 和相关库构建了用户友好的前端界面，实现了文件上传、URL 输入、实时视频流展示、检测结果可视化、动态效果（粒子背景、加载动画）等。
6. 系统测试与评估： 设计了功能测试用例，对系统的各项功能进行了测试，验证了其正确性和稳定性；对检测模块的性能（如图片检测速度）进行了初步评估；对用户界面的易用性进行了检验。

1.4 论文结构安排

本论文的结构安排如下：

• 第一章：引言。 介绍项目的研究背景、意义、国内外研究现状、本文的主要工作内容以及论文的整体结构。
• 第二章：相关技术介绍。 详细介绍项目所涉及的关键技术，包括 Python 语言、Django Web 框架、YOLOv8 目标检测算法、OpenCV 库、前端技术（HTML/CSS/JS/Bootstrap/Particles.js）以及数据库技术。
• 第三章：系统分析。 进行系统需求分析，包括功能性需求和非功能性需求；进行系统可行性分析，包括技术可行性、经济可行性和操作可行性。
• 第四章：系统设计。 阐述系统的整体架构设计、各功能模块的设计、数据库设计（包括 E-R 图）以及用户界面设计。
• 第五章：系统实现。 详细介绍系统各主要模块的具体实现过程，结合核心代码片段进行说明，包括开发环境配置、用户管理模块、检测核心模块、各种检测模式（图片、视频、实时）的实现以及前端界面的实现。
• 第六章：系统测试。 描述测试环境的搭建，设计测试用例（功能测试、性能测试、可用性测试等），展示测试结果并进行分析。
• 第七章：结论。 总结全文工作，概括系统的主要功能和特点，指出存在的不足之处，并对未来的改进方向和研究前景进行展望。

2. 相关技术介绍

本系统的开发涉及多项关键技术，涵盖了后端开发、深度学习、计算机视觉以及前端展现等多个方面。本章将对这些核心技术进行详细介绍。

2.1 Python 语言

Python 是一种解释型、交互式、面向对象的高级编程语言。以其语法简洁清晰、代码可读性强、拥有丰富强大的标准库和第三方库生态系统而闻名。Python 在 Web 开发、数据科学、人工智能、自动化脚本等众多领域都得到了广泛应用。其主要特点包括：

• 易学易用： 语法接近自然语言，上手门槛相对较低。
• 强大的库支持： 拥有如 NumPy、Pandas、Scikit-learn、TensorFlow、PyTorch 等用于科学计算和机器学习的库，以及 Django、Flask 等成熟的 Web 框架，极大地提高了开发效率。
• 跨平台性： Python 代码可以无需修改或只需少量修改即可在 Windows、macOS、Linux 等多种操作系统上运行。
• 面向对象： 支持面向对象的编程范式，有助于构建结构清晰、可维护性强的应用程序。
• 动态类型： 变量类型在运行时确定，编码灵活。

本项目选择 Python 作为主要开发语言，主要是因为它在 Web 开发（Django）和人工智能（YOLOv8 基于 PyTorch）领域都有着无与伦比的生态优势，可以方便地集成各种所需库，实现从模型推理到 Web 应用的全栈开发。

2.2 Django Web 框架

Django 是一个基于 Python 的高级 Web 应用框架，遵循 MVT（Model-View-Template）设计模式（一种MTV变体，常被称为 Django 版的 MVC）。它鼓励快速开发和简洁、实用的设计哲学，旨在减轻 Web 开发中的繁琐工作，让开发者专注于业务逻辑的实现。Django 的核心特性包括：

• 对象关系映射器（ORM）： 提供了一个强大的数据库抽象层，允许开发者使用 Python 代码来定义数据模型并与数据库交互，无需编写复杂的 SQL 语句。本项目中的 users/models.py 文件就利用了 Django ORM 定义了 Profile 和 DetectionHistory 模型。
• URL 路由系统： 简洁灵活的 URL 分发器，可以将 URL 映射到相应的视图函数或类。本项目在 users/urls.py 和 detection/urls.py 中定义了各个功能的路由规则。
• 模板引擎： 内建了一个功能强大且可扩展的模板语言，用于将动态数据渲染到 HTML 页面中。本项目广泛使用了 Django 模板语言（如 {% extends %}, {% block %}, {% url %}, {% if %}, {{ variable }} 等）来构建前端页面 (templates/目录下文件）。
• 表单处理： 提供了处理 HTML 表单、验证用户输入以及将数据映射到 Python 对象的机制。本项目在 users/forms.py 中定义了用户注册、登录、个人资料更新等表单。
• 内建管理后台： Django 自动生成一个功能完善的管理界面（Admin Site），可以方便地对数据模型进行增删改查操作，极大方便了开发和维护。
• 安全性： 内建了对常见 Web 安全威胁的防护措施，如跨站脚本（XSS）攻击、跨站请求伪造（CSRF）攻击、SQL 注入等。本项目在表单提交中使用了 {% csrf_token %} 标签来防御 CSRF 攻击（尽管在 reset_password 视图中为了简化 AJAX 请求暂时使用了 @csrf_exempt）。
• 丰富的组件和生态： 提供了认证系统、缓存框架、国际化支持等众多内建组件，并且拥有庞大的第三方应用和插件生态。

选择 Django 作为后端框架，是因为它提供了构建复杂 Web 应用所需的全套工具，开发效率高，社区活跃，文档完善，能够很好地支持本项目用户管理、数据存储、API 服务等需求。

2.3 YOLOv8 目标检测算法

YOLO（You Only Look Once）是一种实时目标检测系统。与传统的两阶段检测器（如 Faster R-CNN 先生成候选区域再进行分类）不同，YOLO 将目标检测视为一个回归问题，直接从整个图像预测边界框（Bounding Boxes）和类别概率，从而实现了极快的检测速度。

YOLOv8 是 Ultralytics 公司在 2023 年初发布的 YOLO 系列的最新版本，它在 YOLOv5 的成功基础上进行了诸多改进和创新，并非直接继承自某个特定版本，而是作为一个全新的 SOTA（State-of-the-Art）模型推出。YOLOv8 的主要特点和改进包括：

• 模型架构： 提供了从 N (Nano) 到 X (Extra Large) 的多种尺寸模型，满足不同场景下对速度和精度的需求。其骨干网络（Backbone）和颈部（Neck）结构借鉴并优化了 YOLOv5、YOLOX 等设计，可能采用了如 C2f 模块替代 C3 模块等改进。头部（Head）采用了 Anchor-Free 的设计，并使用了 Decoupled Head（解耦头），将分类和回归任务分开处理，有助于提升性能。
• 损失函数： 可能采用了 Task Aligned Assigner 进行标签分配，并结合了 Distribution Focal Loss (DFL) 和 CIoU Loss 来优化边界框回归和分类。
• 训练策略： 引入了新的训练技巧，如最后一个 epoch 关闭 Mosaic 数据增强等，有助于提升最终精度。
• 易用性： Ultralytics 提供了非常友好的 Python SDK (ultralytics 包)，可以方便地进行模型的训练、验证、预测和导出。支持命令行和 Python API 两种使用方式。

本项目选用 YOLOv8 的原因在于：

1. 高性能： 在公开数据集（如 COCO）上展现了卓越的精度和速度平衡，能够满足交通标志识别对准确性和实时性的要求。
2. 易用性： Ultralytics 库使得模型的加载、推理和集成变得非常简单，如 detector.py 中仅需 from ultralytics import YOLO 和 self.model = YOLO(model_path) 即可加载模型，self.model(image_path) 即可执行预测。
3. 灵活性： 支持多种任务（检测、分割、分类、姿态估计），并易于进行自定义训练（Fine-tuning）以适应特定领域的任务（如针对特定交通标志数据集进行训练）。本项目使用了预训练模型或可能经过微调的模型 (best.pt)。
4. 活跃社区： YOLOv8 拥有活跃的社区支持和持续的更新。

在本项目中，detector.py 中的 TrafficSignDetector 类封装了 YOLOv8 模型的加载和推理过程，负责处理输入的图像、视频帧，输出检测到的交通标志的类别、位置和置信度。

2.4 OpenCV 库

OpenCV (Open Source Computer Vision Library) 是一个开源的计算机视觉和机器学习软件库。它包含了超过 2500 种优化的算法，涵盖了经典的计算机视觉任务和最先进的机器学习方法。OpenCV 具有 C++、Python、Java 和 MATLAB 等接口，支持 Windows、Linux、macOS 和 Android 等平台。

在本项目中，OpenCV 主要用于：

• 图像/视频读写： 使用 cv2.imread() 读取图像文件，cv2.VideoCapture() 打开视频文件或摄像头，cv2.imwrite() 保存处理后的图像，cv2.VideoWriter() 创建视频文件并写入帧。这些功能在 detector.py 的 detect_image、detect_video、start_realtime_detection 等方法中被广泛使用。
• 图像处理： 使用 cv2.cvtColor() 进行颜色空间转换（如 BGR 到 RGB）。虽然本项目中图像预处理主要由 YOLOv8 模型内部完成，但 OpenCV 提供了丰富的图像处理功能（如缩放、滤波、形态学操作等）可供扩展。
• 绘制图形： 使用 cv2.rectangle() 在图像或视频帧上绘制检测到的交通标志的边界框。
• 视频流处理： 在实时检测功能中，使用 cv2.imencode() 将处理后的帧编码为 JPEG 格式，用于通过网络传输生成 MJPEG 视频流 (detection/views.py 中的 gen_frames 函数)。

OpenCV 是本项目实现图像和视频输入输出、结果可视化以及实时视频流处理的基础工具库。

2.5 前端技术

为了提供用户友好的交互界面，本项目采用了标准的 Web 前端技术栈：

• HTML (HyperText Markup Language): 定义网页的结构和内容。本项目使用 HTML5 标准，在 templates/ 目录下定义了各个页面的骨架，如 base.html 作为基础模板，login.html, image_detection.html 等继承并填充具体内容。
• CSS (Cascading Style Sheets): 描述网页的样式和布局。本项目除了使用 Bootstrap 提供的样式外，还在模板文件 (<style> 标签内) 或独立的 CSS 文件（如果 static/css 目录下有）中定义了自定义样式，实现了科技感的视觉效果（如渐变背景、粒子效果容器、按钮样式、卡片样式等）。使用了 CSS 变量 (:root) 来管理颜色和尺寸，增强了可维护性。
• JavaScript: 实现网页的动态行为和交互逻辑。本项目使用原生 JavaScript 和 jQuery（引入了 jquery.min.js）来处理用户事件、操作 DOM、发送 AJAX 请求等。
  • Bootstrap: 一个流行的前端框架，提供了预定义的 CSS 样式和 JavaScript 组件（如导航栏、按钮、表单、模态框、网格系统等），用于快速构建响应式、美观的网页布局。本项目大量使用了 Bootstrap 的类 (navbar, container, row, col-md-6, card, btn, form-control, modal 等）。
  • Particles.js: 一个轻量级的 JavaScript 库，用于创建炫酷的粒子动画背景。本项目在登录 (login.html) 和注册 (register.html) 页面使用了该库，增强了页面的视觉吸引力。
  • Fetch API: 现代浏览器内置的用于发起网络请求（AJAX）的接口。本项目在 login.html 中使用 Fetch API 向后端发送忘记密码重置请求，实现了前后端数据的异步交互。

这些前端技术共同构建了用户与系统交互的界面，提供了信息展示、数据输入、操作反馈等功能。

2.6 数据库技术

本项目在开发阶段默认使用 Django 内建支持的 SQLite 数据库。SQLite 是一个轻量级的、基于文件的关系型数据库管理系统。它的特点是：

• 服务器无关： 数据库就是一个单一的文件，不需要独立的数据库服务器进程。
• 零配置： 使用简单，无需复杂的安装和配置。
• 事务性： 支持 ACID 事务。
• 跨平台： 数据库文件可以在不同系统间轻松迁移。

对于本项目这种中小型应用或开发/测试阶段，SQLite 是一个非常方便的选择。Django 的 ORM 使得更换数据库（如 PostgreSQL, MySQL）也相对容易，只需要修改 settings.py 中的数据库配置即可，无需更改模型定义 (models.py) 或大部分视图逻辑。本项目通过 Django ORM 定义了 Profile 和 DetectionHistory 模型，并将用户数据和检测记录持久化存储在 SQLite 数据库文件中。

3. 系统分析

系统分析是软件开发过程中的关键阶段，旨在明确系统需要做什么以及开发的可行性。本章将对智能交通标志识别系统进行详细的需求分析和可行性分析。

3.1 需求分析

需求分析的目标是全面、准确地理解用户和系统的需求，为后续的系统设计和实现奠定基础。本系统的需求主要分为功能性需求和非功能性需求。

3.1.1 功能性需求

功能性需求描述了系统应该具备的具体功能和服务。

1. 用户认证模块：

   • 用户注册： 提供用户注册入口，用户需要输入用户名、邮箱、密码（及确认密码），可选填姓名、电话。系统需验证用户名和邮箱的唯一性，密码的复杂度，两次密码输入的一致性。注册成功后自动创建用户档案。
   • 用户登录： 提供用户登录入口，用户通过用户名和密码进行登录。系统需验证用户身份，登录成功后记录用户会话状态。支持“记住我”功能（Django默认支持）。
   • 用户登出： 用户可以随时退出登录状态。
   • 忘记密码： 提供忘记密码功能，用户输入用户名、新密码和确认密码，系统验证用户存在后直接重置密码（简化流程，未包含邮箱/手机验证）。

2. 个人中心模块：

   • 个人资料查看与修改： 登录用户可以查看自己的用户名、邮箱、姓名、电话等信息，并可以修改除用户名外的其他信息。
   • 检测历史查看： 用户可以查看自己提交的所有检测任务的历史记录列表。

3. 交通标志检测模块：

   • 图片检测：
     • 支持用户上传本地图片文件（JPG, PNG, BMP 等常见格式）。
     • 支持用户输入图片的 URL 进行检测。
     • 系统接收图片后，调用 YOLOv8 模型进行检测。
     • 返回检测结果，包括：标注了边界框和类别标签（中文）的结果图片、原始图片、检测到的标志类别及数量统计、平均置信度、处理时间、每个检测框的详细信息（类别、坐标、置信度）。
   • 视频检测：
     • 支持用户上传本地视频文件（MP4, AVI 等常见格式）。
     • 系统接收视频后，逐帧调用 YOLOv8 模型进行检测。
     • 返回检测结果，包括：标注了检测结果的结果视频文件、原始视频文件（或其路径）、整个视频中检测到的标志类别及总数统计、所有检测框的平均置信度、总处理帧数。
   • 实时检测：
     • 提供启动/停止实时检测的控制按钮。
     • 启动后，系统通过本地摄像头获取实时视频流。
     • 实时在前端页面显示经过模型处理、标注了检测结果的视频画面（MJPEG 流）。
     • 停止后，系统保存该次实时检测的录制视频（包含标注），并展示本次检测的统计结果（检测到的标志类别及总数、平均置信度、处理帧数等）。
   • 结果展示： 检测结果需清晰、直观地展示给用户。图片和视频结果应并排展示原始文件和结果文件。统计数据应易于理解。

4. 历史记录管理模块：

   • 历史列表展示： 在个人中心或独立页面展示用户的检测历史记录列表，包含检测类型、原始文件名、检测时间、主要结果（如检测到的标志概览）等信息。列表应支持分页。
   • 历史记录统计： 展示用户各类检测任务（图片、视频、实时）的数量统计。
   • 历史记录删除： 用户可以删除自己的某条检测历史记录。

5. 管理员后台模块（系统看板）：

   • 访问控制： 仅限管理员角色的用户访问。
   • 系统统计概览：
     • 展示系统总用户数、管理员数、普通用户数。
     • 展示总检测次数、各类检测（图片、视频、实时）次数统计。
     • 展示人均检测次数、各类检测占比等衍生统计数据。
     • 展示最近注册的用户列表。
     • 展示最近的检测记录列表。
   • 用户管理：
     • 用户列表展示： 以卡片或列表形式展示所有用户信息（用户名、姓名、邮箱、用户类型等），支持分页。
     • 用户搜索/筛选： 支持按用户名、邮箱、姓名进行搜索，支持按用户类型（普通用户）进行筛选。
     • 添加用户： 管理员可以手动添加新用户，设置用户名、邮箱、密码（初始密码）、姓名、电话、用户类型（是否管理员）。
     • 编辑用户： 管理员可以修改现有用户的信息（用户名、邮箱、姓名、电话、用户类型）。
     • 删除用户： 管理员可以删除普通用户账号及其相关数据（管理员账号不可删除）。

3.1.2 非功能性需求

非功能性需求关注系统的质量属性和约束条件。

1. 易用性 (Usability):

   • 界面简洁美观，采用科技感风格设计，符合现代 Web 应用审美。
   • 导航清晰，用户可以轻松找到所需功能。
   • 操作流程直观，上传文件、发起检测、查看结果等操作应简单易懂。
   • 提供必要的提示信息（如加载状态、错误提示、成功反馈）。
   • 系统应具备良好的响应性，适应不同尺寸的屏幕（PC、平板）。

2. 性能 (Performance):

   • 图片检测响应时间：对于中等尺寸图片，应在数秒内返回结果（具体时间依赖服务器性能和模型大小）。
   • 视频检测处理时间：处理速度应尽可能快，但可接受离线处理模式，用户上传后等待处理完成。
   • 实时检测流畅度：实时视频流应保持一定的帧率（如 10-20 FPS 或更高，依赖硬件），不应有明显卡顿。
   • 网页加载速度：各页面加载时间应尽可能短。

3. 可靠性 (Reliability):

   • 系统应能稳定运行，对用户误操作（如上传非图片/视频文件、输入无效 URL）或异常情况（如模型加载失败、文件读写错误、网络中断）有相应的处理机制和错误提示，避免程序崩溃。
   • 检测结果应尽可能准确可靠（准确性主要依赖于 YOLOv8 模型本身及其训练数据）。
   • 数据持久化可靠，用户信息和历史记录不应丢失。

4. 安全性 (Security):

   • 用户认证安全：密码应加密存储（Django 内建实现）。
   • 访问控制：严格区分普通用户和管理员权限，非授权用户不能访问受限资源（如管理员后台）。
   • Web 安全防护：应能抵御常见的 Web 攻击，如 XSS、CSRF（本项目中忘记密码部分需注意 @csrf_exempt 的影响）。
   • 文件上传安全：对上传文件的大小、类型进行限制，防止恶意文件上传。

5. 可维护性 (Maintainability):

   • 代码结构清晰，遵循 Django 项目规范，模块化设计。
   • 代码注释充分，关键逻辑易于理解。
   • 配置与代码分离（如模型路径、数据库配置在 settings.py 中）。

6. 可扩展性 (Scalability):

   • 系统架构设计应考虑未来的功能扩展，如支持更多检测模型、添加更复杂的统计分析功能、集成其他智能交通服务等。
   • 代码应易于扩展和修改。

3.1.3 用例分析

为了更清晰地描述用户与系统的交互，可以绘制用例图。

(注意: 上述Mermaid用例图可能需要根据实际渲染环境微调语法细节)

3.2 可行性分析

可行性分析旨在评估项目在现有条件下是否能够成功完成。

3.2.1 技术可行性

• 算法成熟度： YOLOv8 是目前业界领先的目标检测算法之一，拥有公开的预训练模型和完善的实现库 (ultralytics)，其性能已在多个基准数据集上得到验证，应用于交通标志识别是完全可行的。虽然直接使用预训练模型可能对某些特定或罕见的交通标志效果不佳，但可以通过收集特定数据集进行微调来进一步提升性能。
• 框架支持： Django 是一个功能全面、文档丰富、社区活跃的 Python Web 框架，非常适合构建本项目所需的 Web 应用，包括用户管理、数据库交互、API 服务等。其 MVT 模式有助于保持代码结构清晰。
• 库的可用性： Python 拥有强大的生态系统。OpenCV 库提供了必需的图像和视频处理功能。requests 库可以方便地处理 URL 图片下载。这些库都是开源且广泛使用的，获取和集成没有障碍。
• 开发工具： 存在多种成熟的 Python IDE（如 VS Code, PyCharm）和版本控制工具（如 Git），可以支持高效的开发流程。
• 技术储备： 开发团队（假设为完成本项目的学生）具备 Python 编程基础、了解 Web 开发基本原理、并对深度学习和计算机视觉有一定了解，通过学习 Django 框架和 YOLOv8 的使用文档，掌握所需技术是可行的。

综上，从技术角度看，实现本系统所需的核心算法、框架和库都是现成可用且成熟的，技术风险较低。

3.2.2 经济可行性

• 软件成本： 本项目所使用的核心技术，包括 Python、Django、YOLOv8（Ultralytics库）、OpenCV、SQLite、Bootstrap 等，均为开源软件，无需支付授权费用，大大降低了软件成本。
• 硬件成本：
  • 开发阶段：普通的个人电脑即可满足开发需求。
  • 模型训练/微调（可选）：如果需要对 YOLOv8 进行微调，可能需要配备 GPU 的计算机以缩短训练时间，但这可以通过租用云 GPU 服务来解决，成本可控。
  • 部署阶段：需要一台 Web 服务器来运行 Django 应用。可以选择云服务器（如阿里云、腾讯云等），成本根据配置和流量而定。对于低并发场景，入门级云服务器即可满足需求。模型推理如果需要 GPU 加速以提高性能，则服务器成本会相应增加，但对于非实时或低要求的场景，CPU 推理也是可行的。
• 人力成本： 对于本科毕业设计而言，主要的成本是开发人员（学生）的时间投入。在合理的时间安排内（如一个学期），完成本项目核心功能的开发是可行的。

总体来看，本项目的经济成本主要在于潜在的服务器租赁费用和开发时间投入，对于学校或个人项目而言，经济上是可行的。

3.2.3 操作可行性

• 用户界面： 系统提供 Web 界面，用户通过浏览器即可访问和使用，无需安装额外软件，操作简单直观。现代化的 UI 设计和清晰的导航有助于降低用户学习成本。
• 系统部署： Django 应用的部署流程相对成熟，有多种部署方案（如 Nginx + Gunicorn/uWSGI）可供选择，存在大量的部署教程和文档。
• 系统维护： Django 框架结构清晰，代码模块化，便于后续的维护和升级。日志记录（如果添加）和 Django 管理后台可以辅助进行问题排查和数据管理。
• 管理员操作： 管理员后台提供了集中的用户管理和系统监控入口，操作便捷。

因此，系统在部署、使用和维护方面的操作是可行的。用户无需专业知识即可操作，管理员通过后台可以有效管理系统。

结论： 综合技术、经济和操作三个方面的分析，开发该智能交通标志识别系统是完全可行的。

4. 系统设计

系统设计阶段根据需求分析的结果，对系统的整体架构、功能模块、数据库和用户界面进行规划和设计，为后续的编码实现提供蓝图。

4.1 系统架构设计

本系统采用基于 MVT (Model-View-Template) 架构的 Django 框架作为后端，结合前端技术实现用户交互，并集成 YOLOv8 模型进行核心的交通标志检测。整体架构如下图所示：

graph LR
    subgraph "用户端 (Client)"
        Browser[浏览器]
    end

    subgraph "服务器端 (Server)"
        Nginx["Web 服务器 (Nginx/Apache)"] --- Gunicorn["WSGI 服务器 (Gunicorn/uWSGI)"]
        Gunicorn --- DjangoApp[Django 应用]

        subgraph DjangoApp
            direction LR
            Router["URL 路由 (urls.py)"] --> Views["视图 (views.py)"]
            Views --- Models["模型 (models.py)"]
            Views --- Templates["模板 (templates/*.html)"]
            Views --> Detector["检测模块 (detector.py)"]
            Models --- DB["(数据库 SQLite/PostgreSQL)"]
            Detector --- YOLOv8["YOLOv8 模型 (.pt)"]
            Detector --- OpenCV[OpenCV 库]
        end
    end

    Browser -- HTTP 请求 --> Nginx
    Nginx -- 反向代理 --> Gunicorn
    Templates -- HTML/CSS/JS --> Browser
    Browser -- AJAX 请求 (Fetch API) --> DjangoApp

    style DjangoApp fill:#ccf,stroke:#333,stroke-width:2px
    style Browser fill:#f9d,stroke:#333,stroke-width:2px

架构说明：

1. 用户端： 用户通过浏览器访问系统前端界面。前端页面由 HTML、CSS、JavaScript 构建，负责展示信息、接收用户输入。
2. Web 服务器 (Nginx/Apache): （部署时使用）负责处理静态文件请求和反向代理，将动态请求转发给 WSGI 服务器。
3. WSGI 服务器 (Gunicorn/uWSGI): （部署时使用）作为 Web 服务器与 Django 应用之间的桥梁，负责运行 Django 应用实例并处理并发请求。
4. Django 应用:
   • URL 路由 (urls.py): 接收到请求后，根据 URL 规则将其分发到对应的视图函数。
   • 视图 (views.py): 处理业务逻辑的核心。接收请求参数，调用模型进行数据库操作，调用检测模块执行识别任务，选择并渲染模板返回给用户，或者返回 JSON 数据（用于 AJAX 请求）。
   • 模型 (models.py): 定义数据结构（数据库表），通过 Django ORM 与数据库进行交互，实现数据的持久化存储和检索。
   • 模板 (templates/*.html): 定义前端页面的结构和展示逻辑，接收视图传递的数据并渲染成最终的 HTML 页面。
   • 检测模块 (detector.py): 封装了交通标志检测的核心逻辑。加载 YOLOv8 模型，使用 OpenCV 处理图像/视频，执行检测推理，绘制结果。视图层调用该模块来完成检测任务。
   • 数据库: 存储用户信息、检测历史等持久化数据。
   • YOLOv8 模型 (best.pt): 预训练或微调好的深度学习模型文件，由检测模块加载和使用。
   • OpenCV 库: 提供图像和视频处理的基础功能。

这种架构实现了前后端逻辑的分离，后端 MVT 模式使得各层职责清晰，便于开发和维护。检测逻辑被封装在独立的模块中，便于模型的替换或升级。

4.2 功能模块设计

根据需求分析，系统可划分为以下主要功能模块：

1. 用户认证模块:

   • 功能: 处理用户注册、登录、登出、密码重置请求。
   • 主要组件: users/views.py (register, CustomLoginView, logout, reset_password), users/forms.py (UserRegisterForm, UserLoginForm), users/urls.py, 相关 HTML 模板 (login.html, register.html), users/models.py (User, Profile)。
   • 流程: 用户提交表单 -> URL 路由 -> 对应视图函数处理 -> 表单验证 -> (成功) 数据库操作/会话管理/重定向, (失败) 返回错误信息。密码重置通过 AJAX 请求与 reset_password 视图交互。

2. 个人中心与历史记录模块:

   • 功能: 展示用户个人资料，允许修改；展示用户检测历史列表，允许删除单条记录；统计历史记录。
   • 主要组件: users/views.py (profile, history, delete_history), users/forms.py (ProfileUpdateForm), users/models.py (Profile, DetectionHistory), users/urls.py, 相关 HTML 模板 (profile.html, history.html)。
   • 流程: 用户访问页面 -> URL 路由 -> 视图函数查询数据库 (Profile/DetectionHistory) -> 传递数据给模板 -> 渲染页面。修改/删除操作通过表单提交或特定 URL 请求触发视图函数处理。

3. 图片检测模块:

   • 功能: 处理用户通过本地上传或 URL 提交的图片检测请求。
   • 主要组件: detection/views.py (image_detection), detection/forms.py (ImageUploadForm), detection/detector.py (detect_image), detection/urls.py, image_detection.html 模板, users/models.py (DetectionHistory)。
   • 流程: 用户上传图片/输入 URL -> 提交表单 -> URL 路由 -> image_detection 视图处理 -> (URL) 下载图片 / (上传) 保存图片 -> 调用 detector.detect_image -> 保存结果图片 -> 数据库记录历史 -> 渲染结果页面。

4. 视频检测模块:

   • 功能: 处理用户上传的视频检测请求。
   • 主要组件: detection/views.py (video_detection), detection/forms.py (VideoUploadForm), detection/detector.py (detect_video), detection/urls.py, video_detection.html 模板, users/models.py (DetectionHistory)。
   • 流程: 用户上传视频 -> 提交表单 -> URL 路由 -> video_detection 视图处理 -> 保存视频 -> 调用 detector.detect_video -> 保存结果视频 -> 数据库记录历史 -> 渲染结果页面。

5. 实时检测模块:

   • 功能: 控制摄像头的启动与停止，实时显示检测画面，结束后保存结果。
   • 主要组件: detection/views.py (realtime_detection, start_realtime, stop_realtime, video_feed, gen_frames), detection/detector.py (start_realtime_detection, process_realtime_frame, stop_realtime_detection), detection/urls.py, realtime_detection.html 模板, users/models.py (DetectionHistory)。
   • 流程: 用户点击启动 -> 前端 JS 发送请求 -> start_realtime 视图初始化摄像头和写入器 -> 前端 <img> 标签请求 video_feed -> video_feed 调用 gen_frames -> gen_frames 循环读取帧、调用 process_realtime_frame 处理并 yield JPEG 数据。用户点击停止 -> 前端 JS 发送请求 -> stop_realtime 视图停止处理、释放资源、保存历史记录、返回 JSON 结果。

6. 管理员后台模块:

   • 功能: 提供系统统计数据展示和用户管理功能（增删改查）。
   • 主要组件: users/views.py (user_management, user_detail, add_user, update_user, delete_user), users/models.py (User, Profile, DetectionHistory), users/urls.py, user_management.html 模板。
   • 流程: 管理员访问页面 -> user_management 视图查询统计数据和用户列表 -> 渲染页面。增删改查操作通过模态框表单提交 -> 对应视图函数处理数据库操作 -> 重定向回管理页面。

4.3 数据库设计

数据库是存储系统持久化数据的核心。本项目主要涉及以下数据模型：

1. User (Django 内建): 存储用户的基本认证信息。

   • username: 用户名 (唯一, 必填)
   • password: 哈希后的密码 (必填)
   • email: 邮箱 (唯一, 必填)
   • first_name: 名
   • last_name: 姓
   • is_staff: 是否可以访问 Admin 后台 (本项目中未使用，权限通过 Profile 控制)
   • is_active: 账户是否激活
   • is_superuser: 是否超级管理员
   • date_joined: 注册时间
   • last_login: 最后登录时间

2. Profile (users.models.Profile): 扩展用户信息，与 User 模型一对一关联。

   • user: 外键，关联 User 模型 (OneToOneField, 必填)
   • user_type: 用户类型 (‘admin’ 或 ‘regular’, CharField, 必填, 默认 ‘regular’)
   • phone: 电话号码 (CharField, 可为空)
   • created_at: 创建时间 (DateTimeField, 自动添加)
   • updated_at: 更新时间 (DateTimeField, 自动更新)

3. DetectionHistory (users.models.DetectionHistory): 存储用户的检测历史记录。

   • user: 外键，关联 User 模型 (ForeignKey, 必填)
   • detection_type: 检测类型 (‘image’, ‘video’, ‘realtime’, CharField, 必填)
   • original_file: 原始文件路径或标识 (CharField, 必填)
   • result_file: 结果文件路径 (CharField, 必填)
   • filename: 原始文件名 (CharField, 必填)
   • signs_detected: 检测到的标志 (JSON 格式字符串, TextField, 可为空)
   • confidence: 平均置信度 (FloatField, 可为空)
   • detection_details: 详细检测信息（如各框坐标、置信度，JSON 格式字符串, TextField, 可为空）
   • created_at: 检测时间 (DateTimeField, 自动添加)

E-R 图 (Mermaid):

设计说明:

• 采用 Django 内建的 User 模型处理核心认证信息。
• 通过 Profile 模型扩展用户信息，实现用户类型（管理员/普通用户）区分和电话号码存储，与 User 建立一对一关系。
• DetectionHistory 模型用于记录每一次检测操作，与 User 建立多对一关系。signs_detected 和 detection_details 字段存储 JSON 格式的字符串，方便存储结构化数据。

4.4 界面设计

用户界面设计遵循简洁、直观、美观、响应式的原则，并融入科技感元素以契合系统主题。

• 整体风格： 采用深色导航栏和页脚，搭配浅色内容区域背景。使用蓝色系（如 --primary-color）和绿色系（如 --secondary-color）作为主色调。运用渐变色、阴影、圆角等元素增强视觉效果。
• 布局： 主要采用 Bootstrap 网格系统进行响应式布局，确保在不同设备上都有良好的显示效果。导航栏置顶，主要内容居中显示，页脚固定在底部。管理员后台采用卡片式布局展示用户信息和统计数据。
• 导航： 顶部导航栏包含系统名称、主要功能入口（首页、图片检测、视频检测、实时检测、历史记录、系统看板 - 管理员可见）以及用户状态（登录/注册或用户名/退出）。导航链接在当前页面会高亮显示。
• 用户交互：
  • 表单：使用 Bootstrap 的 form-floating 样式，提供清晰的输入提示。输入错误时给出明确的反馈。
  • 按钮：按钮样式统一，具有悬停效果和加载状态（如果实现）。关键操作按钮（如登录、注册、开始检测）使用醒目的颜色和图标。
  • 反馈：操作成功或失败时，通过 Bootstrap 的 alert 组件显示提示消息。耗时操作（如检测）显示加载动画覆盖层 (loadingOverlay)。
  • 模态框：用于忘记密码、添加/编辑/删除用户等操作，避免页面跳转，提升流畅度。
• 视觉效果：
  • 粒子背景：在登录、注册页面使用 Particles.js 创建动态粒子背景，增加科技感。
  • 渐变与光效：在按钮、背景、卡片头部等处使用渐变色和模拟光效（如 tech-glow），营造科技氛围。
  • 图标：广泛使用 Font Awesome 图标库 (<i class="fas fa-...">)，增强信息的可识别性。
  • 动画：适当使用 CSS 动画（如 pulse, fadeIn, btn-shine）提升用户体验。
• 关键页面设计：
  • 首页 (index.html): 包含一个醒目的 Hero 区域介绍系统，功能卡片引导用户进行检测（登录后可见），或提示登录/注册（未登录时）。包含使用步骤说明。
  • 登录/注册页 (login.html, register.html): 居中表单，带有粒子背景和科技感元素。
  • 检测页 (image_detection.html, etc.): 提供清晰的文件上传/URL输入区域（支持拖放），结果展示区域并排显示原图/视频和结果图/视频，下方展示详细的统计数据和识别结果列表。
  • 系统看板 (user_management.html): 顶部 Banner，下方为统计数据卡片和用户管理区域（包含搜索/筛选和用户卡片列表）。

5. 系统实现

本章将详细介绍智能交通标志识别系统的具体实现过程，结合核心代码片段对关键模块和功能进行说明。

5.1 开发环境与项目结构

• 操作系统: Windows / macOS / Linux
• 编程语言: Python 3.x (例如 Python 3.9+)
• Web 框架: Django 4.x
• 深度学习库: ultralytics (包含 PyTorch)
• 图像处理库: opencv-python
• 数据库: SQLite (开发阶段)
• 前端库: Bootstrap 5, jQuery, Particles.js, Font Awesome
• 其他库: requests (用于 URL 图片下载)
• 开发工具: VS Code / PyCharm, Git

项目主要结构:

├── manage.py           # Django 项目管理脚本
├── traffic_sign_system # 项目配置目录 (settings.py, urls.py, wsgi.py...)
├── detection           # 检测功能的应用目录
│   ├── migrations/
│   ├── static/         # 检测相关的静态文件 (CSS, JS, Fonts)
│   ├── templates/      # 检测相关的 HTML 模板
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── detector.py     # 核心检测类
│   ├── forms.py        # 图片/视频上传表单
│   ├── models.py       # (如果检测应用有模型)
│   ├── tests.py
│   └── views.py        # 检测相关的视图函数
├── users               # 用户功能的应用目录
│   ├── migrations/
│   ├── static/
│   ├── templates/      # 用户相关的 HTML 模板 (包括 base.html)
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── forms.py        # 用户注册/登录/Profile 表单
│   ├── models.py       # Profile, DetectionHistory 模型
│   ├── tests.py
│   └── views.py        # 用户相关的视图函数
├── media               # 用户上传文件和检测结果存放目录
│   ├── uploads/
│   │   ├── images/
│   │   └── videos/
│   └── results/
│       ├── images/
│       └── videos/
├── static              # 全局静态文件 (项目级别的 CSS, JS, images)
├── requirements.txt    # 项目依赖库列表
└── best.pt             # YOLOv8 模型文件

5.2 用户管理模块实现

该模块负责用户的注册、登录、登出、个人资料管理、密码重置以及管理员后台的用户管理。

1. 模型定义 (users/models.py):

定义了 Profile 模型扩展 User，以及 DetectionHistory 模型记录检测历史。关键点是 Profile 与 User 的 OneToOneField 关联，以及通过信号 (@receiver) 自动创建和更新 Profile。

# users/models.py
from django.db import models
from django.contrib.auth.models import User
from django.db.models.signals import post_save
from django.dispatch import receiver

class Profile(models.Model):
    USER_TYPES = (('admin', '管理员'), ('regular', '普通用户'),)
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    user_type = models.CharField(max_length=10, choices=USER_TYPES, default='regular', verbose_name='用户类型')
    phone = models.CharField(max_length=20, blank=True, null=True, verbose_name='电话号码')
    # ... 其他字段 ...

    @property
    def is_admin(self):
        return self.user_type == 'admin'

@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        user_type = 'admin' if instance.is_superuser else 'regular'
        Profile.objects.create(user=instance, user_type=user_type)

@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    try:
        if instance.is_superuser and instance.profile.user_type != 'admin':
            instance.profile.user_type = 'admin'
        instance.profile.save()
    except Profile.DoesNotExist:
        # 处理 Profile 不存在的情况，虽然 create_user_profile 会创建
        user_type = 'admin' if instance.is_superuser else 'regular'
        Profile.objects.create(user=instance, user_type=user_type)


class DetectionHistory(models.Model):
    DETECTION_TYPES = (('image', '图片检测'), ('video', '视频检测'), ('realtime', '实时检测'),)
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='detection_history', verbose_name='用户')
    detection_type = models.CharField(max_length=10, choices=DETECTION_TYPES, verbose_name='检测类型')
    original_file = models.CharField(max_length=255, verbose_name='原始文件路径')
    result_file = models.CharField(max_length=255, verbose_name='结果文件路径')
    filename = models.CharField(max_length=255, verbose_name='原始文件名')
    signs_detected = models.TextField(blank=True, null=True, verbose_name='检测到的标志') # Store as JSON string
    confidence = models.FloatField(blank=True, null=True, verbose_name='平均置信度')
    detection_details = models.TextField(blank=True, null=True, verbose_name='检测详情') # Store as JSON string
    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
    # ... Meta and __str__ ...

2. 表单定义 (users/forms.py):

使用 Django forms 定义了用户注册、登录和 Profile 更新的表单，包含字段验证逻辑。

# users/forms.py
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from .models import Profile

class UserRegisterForm(UserCreationForm):
    email = forms.EmailField(required=True)
    first_name = forms.CharField(max_length=30, required=False)
    last_name = forms.CharField(max_length=150, required=False)
    phone = forms.CharField(max_length=20, required=False)

    class Meta(UserCreationForm.Meta):
        model = User
        fields = UserCreationForm.Meta.fields + ('email', 'first_name', 'last_name',)

    def save(self, commit=True):
        user = super().save(commit=False)
        if commit:
            user.save()
            # 获取或创建 Profile 并保存额外信息
            profile, created = Profile.objects.get_or_create(user=user)
            profile.phone = self.cleaned_data.get('phone')
            # user_type 在信号处理器中根据 is_superuser 设置，这里无需处理
            profile.save()
        return user

class UserLoginForm(AuthenticationForm):
    username = forms.CharField(widget=forms.TextInput(attrs={'class': 'form-control', 'placeholder': '用户名'}))
    password = forms.CharField(widget=forms.PasswordInput(attrs={'class': 'form-control', 'placeholder':'密码'}))

class ProfileUpdateForm(forms.ModelForm):
    class Meta:
        model = Profile
        fields = ['phone'] # 只允许用户修改电话
        # 如果允许修改姓名和邮箱，需要在视图中单独处理 User 模型的更新

3. 视图实现 (users/views.py):

• 注册 (register): 处理 GET 和 POST 请求，使用 UserRegisterForm，注册成功后自动登录并重定向。
• 登录 (CustomLoginView): 继承 Django 内建的 LoginView，使用自定义的 UserLoginForm 和模板，登录成功后显示欢迎消息并重定向（优先 next 参数）。
• 个人资料 (profile): 处理 GET 和 POST 请求，使用 ProfileUpdateForm 更新 Profile，同时查询并展示用户的检测历史。
• 历史记录 (history, delete_history): 分页展示用户历史记录，处理删除请求。
• 密码重置 (reset_password): @require_POST, @csrf_exempt（需要注意安全风险），接收 JSON 请求，解析用户名和新密码，验证用户存在后调用 user.set_password() 重置密码，返回 JSON 响应。

# users/views.py (部分示例)
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth import login
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST
from django.views.decorators.csrf import csrf_exempt
from django.http import JsonResponse
from .forms import UserRegisterForm, ProfileUpdateForm
from .models import User, DetectionHistory
import json

def register(request):
    if request.method == 'POST':
        form = UserRegisterForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            messages.success(request, "注册成功！您现在已登录。")
            return redirect('home') # 或者 'detection_index'
    else:
        form = UserRegisterForm()
    return render(request, 'users/register.html', {'form': form})

@login_required
def profile(request):
    if request.method == 'POST':
        # 更新 User 模型字段 (如果允许)
        # request.user.first_name = request.POST.get('first_name')
        # request.user.last_name = request.POST.get('last_name')
        # request.user.email = request.POST.get('email') # 需要额外验证
        # request.user.save()

        # 更新 Profile 模型字段
        form = ProfileUpdateForm(request.POST, instance=request.user.profile)
        if form.is_valid():
            form.save()
            messages.success(request, '您的资料已成功更新！')
            return redirect('profile')
    else:
        form = ProfileUpdateForm(instance=request.user.profile)
        # 可以预填充 User 模型的字段到表单初始值 (如果表单包含这些字段)
        # initial_data = {'first_name': request.user.first_name, ...}
        # form = ProfileUpdateForm(instance=request.user.profile, initial=initial_data)

    history = DetectionHistory.objects.filter(user=request.user).order_by('-created_at')[:10] # 只显示最近10条
    context = {'form': form, 'history': history}
    return render(request, 'users/profile.html', context)


@require_POST
@csrf_exempt # 注意：在生产环境中应使用更安全的 CSRF 处理方式
def reset_password(request):
    try:
        data = json.loads(request.body)
        username = data.get('username')
        new_password = data.get('new_password')

        if not username or not new_password:
            return JsonResponse({'success': False, 'message': '用户名和新密码不能为空'})

        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            return JsonResponse({'success': False, 'message': '用户不存在'})

        user.set_password(new_password)
        user.save()
        return JsonResponse({'success': True, 'message': '密码重置成功'})

    except json.JSONDecodeError:
        return JsonResponse({'success': False, 'message': '无效的请求数据'})
    except Exception as e:
        # Log the error in production
        print(f"Error in reset_password: {e}")
        return JsonResponse({'success': False, 'message': f'发生错误，请稍后重试'})

# --- 管理员视图 ---
@login_required
def user_management(request):
    if not request.user.profile.is_admin:
        messages.error(request, '您没有权限访问此页面！')
        return redirect('home')
    # ... 查询统计数据和用户列表 ...
    # ... 计算统计指标 ...
    users_list = User.objects.all().order_by('-date_joined') # 示例：获取所有用户
    paginator = Paginator(users_list, 9) # 每页9个用户卡片
    page = request.GET.get('page')
    try:
        users = paginator.page(page)
    except PageNotAnInteger:
        users = paginator.page(1)
    except EmptyPage:
        users = paginator.page(paginator.num_pages)

    stats = { # ... 填充统计数据 ...
         'total_users': User.objects.count(),
         # ... 其他统计 ...
         'latest_detections': DetectionHistory.objects.all().order_by('-created_at')[:5],
         'latest_users': User.objects.all().order_by('-date_joined')[:5],
    }

    return render(request, 'users/user_management.html', {'users': users, 'stats': stats})

# add_user, update_user, delete_user 视图类似地检查权限并处理 POST 请求

4. URL 配置 (users/urls.py):

定义了用户认证、个人中心、历史记录、管理员后台等功能的 URL 路由规则。

5. 模板实现 (templates/users/):

login.html, register.html, profile.html, history.html, user_management.html 等模板文件使用 Django 模板语言和前端技术实现用户界面。login.html 中的 JavaScript 使用 Fetch API 调用 reset_password 后端接口。

5.3 检测核心模块实现 (detection/detector.py)

该模块封装了使用 YOLOv8 和 OpenCV 进行交通标志检测的核心逻辑。

# detection/detector.py
import os
import cv2
import numpy as np
from ultralytics import YOLO
import uuid
from django.conf import settings
from datetime import datetime
from PIL import Image, ImageDraw, ImageFont

class TrafficSignDetector:
    def __init__(self, model_path=None):
        if model_path is None:
            model_path = os.path.join(settings.BASE_DIR, 'best.pt')
        self.model = YOLO(model_path)
        self.class_names = self.model.names

        # --- 中文字体查找 ---
        self.font_path = None
        project_font_path = os.path.join(settings.BASE_DIR, 'detection', 'static', 'fonts', 'simhei.ttf') # 修正路径
        if os.path.exists(project_font_path):
             self.font_path = project_font_path
        else:
            # ... (系统字体查找逻辑) ...
            print("警告：未找到中文字体，标签可能显示为方框。请将 simhei.ttf 放入 detection/static/fonts/ 目录。")


        # --- 英文到中文映射 (部分示例) ---
        self.sign_name_mapping = {
            'barrier ahead': '前方障碍', # 使用小写匹配
            'cattle': '注意牲畜',
            'caution': '注意',
            # ... (其他映射) ...
            'stop': '停止',
            'straight prohibitor no entry': '禁止直行',
            'walking': '行人通道'
        }

    def get_chinese_name(self, english_name):
        """将英文标志名称转换为中文，优先精确匹配，然后模糊匹配"""
        name_lower = english_name.lower().strip()
        # 精确匹配
        if name_lower in self.sign_name_mapping:
            return self.sign_name_mapping[name_lower]
        # 模糊匹配 (检查是否包含或被包含)
        for eng, chn in self.sign_name_mapping.items():
            if eng in name_lower or name_lower in eng:
                print(f"模糊匹配: '{english_name}' -> '{chn}' (基于 '{eng}')")
                return chn
        print(f"未找到匹配: '{english_name}'")
        return english_name # 返回原始英文名

    def detect_image(self, image_path):
        """检测图像中的交通标志"""
        start_time = time.time()
        results = self.model(image_path)
        result = results[0]
        img = cv2.imread(image_path)
        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        img_pil = Image.fromarray(img_rgb)
        draw = ImageDraw.Draw(img_pil)

        try:
            font = ImageFont.truetype(self.font_path, 20) if self.font_path else ImageFont.load_default()
        except Exception as e:
            print(f"加载字体失败: {e}, 使用默认字体")
            font = ImageFont.load_default()

        boxes = result.boxes.xyxy.cpu().numpy()
        classes = result.boxes.cls.cpu().numpy().astype(int)
        confidences = result.boxes.conf.cpu().numpy()

        detected_signs = {}
        detection_details = []

        for i, box in enumerate(boxes):
            x1, y1, x2, y2 = map(int, box)
            cls_id = classes[i]
            conf = confidences[i]
            original_class_name = self.class_names.get(cls_id, '未知类别') # 使用 .get() 避免 KeyError
            chinese_name = self.get_chinese_name(original_class_name)

            if chinese_name in detected_signs:
                detected_signs[chinese_name] += 1
            else:
                detected_signs[chinese_name] = 1

            detection_details.append({
                'class_name': chinese_name, 'original_class': original_class_name,
                'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2,
                'confidence': round(float(conf) * 100, 2) # 确保是 float 并保留两位小数
            })

            # --- 绘制 ---
            label = f"{chinese_name}: {conf:.2f}"
            text_bbox = draw.textbbox((0, 0), label, font=font)
            text_width = text_bbox[2] - text_bbox[0]
            text_height = text_bbox[3] - text_bbox[1]
            bg_y1 = max(0, y1 - text_height - 5) # 确保背景不超出图像顶部
            bg_y2 = y1 - 5

            draw.rectangle([(x1, bg_y1), (x1 + text_width + 10, bg_y2)], fill=(255, 0, 0, 180)) # 红色背景
            draw.text((x1 + 5, bg_y1), label, font=font, fill=(255, 255, 255)) # 白色文字
            draw.rectangle([(x1, y1), (x2, y2)], outline=(0, 255, 0), width=2) # 绿色框

        img_result_bgr = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)

        filename = f"{uuid.uuid4()}.jpg"
        result_dir = os.path.join(settings.MEDIA_ROOT, 'results', 'images')
        os.makedirs(result_dir, exist_ok=True)
        result_path_full = os.path.join(result_dir, filename)
        cv2.imwrite(result_path_full, img_result_bgr)

        end_time = time.time()
        processing_time = round(end_time - start_time, 2)

        avg_confidence = np.mean(confidences) * 100 if len(confidences) > 0 else 0.0

        return {
            'original_path': image_path,
            'result_path': os.path.join('results', 'images', filename), # 相对路径
            'detected_signs': detected_signs,
            'confidence': round(float(avg_confidence), 2),
            'count': len(boxes),
            'detection_details': detection_details,
            'processing_time': processing_time
        }

    # detect_video 和 realtime 相关方法类似地调用模型并处理帧
    # 需要注意视频处理的效率和实时检测的状态管理

关键实现点:

• 模型加载: 在 __init__ 中加载 YOLOv8 模型。
• 中文标签: 实现 get_chinese_name 方法进行英文到中文的转换。关键在于 sign_name_mapping 字典的维护。需要处理大小写和可能的名称不完全匹配问题。
• 字体处理: 查找可用的中文字体 (simhei.ttf)，并在 PIL.ImageDraw 中使用该字体绘制中文标签，解决中文乱码问题。提供了字体未找到的警告。
• 结果绘制: 使用 OpenCV (cv2.rectangle) 绘制边界框，使用 PIL (ImageDraw.text, ImageDraw.rectangle) 绘制带背景的中文标签，增强可读性。
• 结果保存: 将处理后的图像/视频保存到 media/results/ 目录下，并返回相对路径给视图。
• 数据结构: 返回包含结果路径、检测到的标志统计、平均置信度、检测框详情（JSON友好格式）、处理时间等信息的字典。

5.4 图片/视频/实时检测模块实现

这些模块的视图函数 (detection/views.py) 负责接收用户请求，调用 TrafficSignDetector 的相应方法，并将结果传递给模板或前端。

1. 图片检测视图 (image_detection):

• 区分处理本地文件上传和 URL 输入。
• 对于 URL，使用 requests 库下载图片到临时位置。
• 调用 detector.detect_image()。
• 创建 DetectionHistory 记录。
• 将结果传递给 image_detection.html 模板。

# detection/views.py (部分示例)
@login_required
def image_detection(request):
    if request.method == 'POST':
        results = None
        original_file_url = None
        filename_to_save = "未知图片"
        temp_image_path = None # 用于 URL 下载的临时文件路径

        try:
            if 'is_url' in request.POST:
                image_url = request.POST.get('image_url')
                if not image_url:
                    messages.error(request, "请提供有效的图片URL")
                    return redirect('image_detection')

                # ... (下载 URL 图片到 temp_image_path) ...
                # ... (生成原始文件名 filename_to_save) ...
                image_path_for_detection = temp_image_path
                original_file_url = image_url # 用于模板显示
                original_file_rel_path = image_url # 存储 URL 本身

            else: # 处理本地上传
                form = ImageUploadForm(request.POST, request.FILES)
                if form.is_valid():
                    uploaded_image = request.FILES['image']
                    filename_to_save = uploaded_image.name
                    # ... (保存上传图片到 upload_path) ...
                    image_path_for_detection = upload_path
                    original_file_rel_path = os.path.join('uploads', 'images', unique_filename)
                    original_file_url = os.path.join(settings.MEDIA_URL, original_file_rel_path)
                else:
                    # ... 处理表单错误 ...
                    return render(request, 'detection/image_detection.html', {'form': form})

            # 执行检测
            if image_path_for_detection:
                results = detector.detect_image(image_path_for_detection)

                # 保存历史记录
                DetectionHistory.objects.create(
                    user=request.user, detection_type='image',
                    original_file=original_file_rel_path, # 存相对路径或URL
                    result_file=results['result_path'],
                    filename=filename_to_save,
                    signs_detected=json.dumps(results['detected_signs']),
                    confidence=results['confidence'],
                    detection_details=json.dumps(results['detection_details'])
                )

            # 清理临时文件 (如果来自URL)
            if temp_image_path and os.path.exists(temp_image_path):
                os.remove(temp_image_path)

        except Exception as e:
            messages.error(request, f"检测过程中出错: {str(e)}")
            # 清理可能的临时文件
            if temp_image_path and os.path.exists(temp_image_path):
                os.remove(temp_image_path)
            return redirect('image_detection')

        # 准备上下文并渲染结果
        context = {
            'form': ImageUploadForm(), # 总是提供一个新表单
            'results': results,
            'original_file': original_file_url, # 用于模板显示的URL
            'result_file': os.path.join(settings.MEDIA_URL, results['result_path']) if results else None,
            'detected_signs': results.get('detected_signs', {}) if results else {},
            'confidence': results.get('confidence', 0) if results else 0,
            'count': results.get('count', 0) if results else 0
        }
        return render(request, 'detection/image_detection.html', context)

    else: # GET 请求
        form = ImageUploadForm()
        return render(request, 'detection/image_detection.html', {'form': form})

2. 视频检测视图 (video_detection):

• 处理视频文件上传。
• 调用 detector.detect_video()。
• 创建 DetectionHistory 记录。
• 传递结果给 video_detection.html 模板。

3. 实时检测视图 (realtime_detection, start_realtime, stop_realtime, video_feed):

• realtime_detection: 渲染主页面 (realtime_detection.html)。
• start_realtime: 通过 AJAX 调用，调用 detector.start_realtime_detection()，初始化全局状态 realtime_state，返回 JSON 确认。
• stop_realtime: 通过 AJAX 调用，调用 detector.stop_realtime_detection()，清理全局状态，保存 DetectionHistory，返回包含结果文件路径和统计数据的 JSON。
• video_feed: 返回 StreamingHttpResponse，内容由 gen_frames 生成器提供。
• gen_frames: 循环读取 realtime_state['cap'] 的帧，调用 detector.process_realtime_frame 处理，将处理后的帧编码为 JPEG 并 yield，实现 MJPEG 流。需要使用 realtime_state['lock'] 保证线程安全。

4. 模板实现 (templates/detection/):

• image_detection.html, video_detection.html: 包含文件上传表单（或 URL 输入），结果展示区域（使用 <img> 或 <video> 标签显示原文件和结果文件），以及检测统计信息。
• realtime_detection.html: 包含启动/停止按钮，以及一个 <img> 标签，其 src 指向 video_feed URL，用于显示实时视频流。通过 JavaScript 处理按钮点击事件，发送 AJAX 请求到 start_realtime 和 stop_realtime，并在停止后展示结果。

5.5 前端实现细节

• 基础模板 (templates/base/base.html): 定义了通用的页面结构（导航栏、主内容区、页脚），引入了 Bootstrap、Font Awesome 和全局 CSS/JS。其他模板通过 {% extends 'base/base.html' %} 和 {% block %} 标签继承和覆盖。
• 静态文件 (static/): 存放 CSS 文件、JavaScript 文件、图片、字体等静态资源。通过 {% load static %} 和 {% static 'path/to/file' %} 在模板中引用。
• AJAX 交互 (login.html):
  • 获取 CSRF Token: 使用 getCookie('csrftoken') 函数从浏览器 cookie 中读取 CSRF 令牌。
  • 发送 Fetch 请求: 使用 fetch() 函数向 reset_password URL 发送 POST 请求，请求头中包含 Content-Type: application/json 和 X-CSRFToken，请求体中包含 JSON 格式的用户名和新密码。
  • 处理响应: 通过 .then() 处理服务器返回的 JSON 响应，根据 success 字段显示成功或错误消息。使用 .catch() 处理网络或服务器错误。

// templates/users/login.html (部分 JS 示例)
        // 辅助函数：获取CSRF令牌
        function getCookie(name) {
            let cookieValue = null;
            if (document.cookie && document.cookie !== '') {
                const cookies = document.cookie.split(';');
                for (let i = 0; i < cookies.length; i++) {
                    const cookie = cookies[i].trim();
                    if (cookie.substring(0, name.length + 1) === (name + '=')) {
                        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                        break;
                    }
                }
            }
            return cookieValue;
        }

        resetBtn.addEventListener('click', function() {
            // ... (表单验证) ...

            const csrftoken = getCookie('csrftoken'); // 获取 CSRF token

            fetch('/users/reset-password/', { // 使用硬编码 URL 或 Django 的 {% url %} 标签生成的 URL
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRFToken': csrftoken // 在请求头中包含 CSRF token
                },
                body: JSON.stringify({
                    username: username,
                    new_password: newPassword
                })
            })
            .then(response => {
                if (!response.ok) { // 检查 HTTP 状态码
                    // 尝试解析错误信息
                    return response.json().then(errData => {
                        throw new Error(errData.message || `HTTP error! status: ${response.status}`);
                    }).catch(() => {
                         throw new Error(`HTTP error! status: ${response.status}`);
                    });
                }
                return response.json();
            })
            .then(data => {
                if (data.success) {
                    resetPasswordSuccess(); // 调用成功处理函数
                } else {
                    showError(data.message || '密码重置失败，请稍后重试');
                }
            })
            .catch(error => {
                console.error('Error:', error);
                showError(error.message || '服务器连接失败或发生错误，请稍后重试');
            });
        });

• 动态效果: 使用 CSS 动画和 Particles.js 库创建视觉效果，提升用户体验。
• 加载提示: 在触发表单提交（图片/视频检测）时，通过 JavaScript 显示一个覆盖整个页面的加载提示层 (loadingOverlay)，告知用户系统正在处理中。

6. 系统测试

系统测试是确保软件质量、验证系统是否满足需求的关键环节。本章将描述系统的测试环境、测试用例设计以及测试结果分析。

6.1 测试环境

• 硬件环境:
  • 处理器: Intel Core i5/i7 或同等 AMD 处理器
  • 内存: 8GB RAM 或以上
  • 硬盘: 50GB 可用空间或以上
  • 显卡: (可选，用于加速检测) NVIDIA GPU (如 GTX 1060 或更高)
  • 摄像头: (用于实时检测) USB 摄像头
• 软件环境:
  • 操作系统: Windows 10/11, macOS Monterey 或更高版本, Ubuntu 20.04 或更高版本
  • 浏览器: Google Chrome 最新版, Firefox 最新版, Edge 最新版
  • Python 版本: 3.9.x
  • Django 版本: 4.x
  • Ultralytics 版本: (根据 requirements.txt)
  • OpenCV-Python 版本: (根据 requirements.txt)
  • 数据库: SQLite 3.x

6.2 测试用例设计

测试用例旨在覆盖系统的主要功能和关键路径，验证其行为是否符合预期。测试主要分为功能测试、性能测试和易用性测试。

6.2.1 功能测试

用例 ID	模块	测试描述	测试步骤	预期结果	测试结果	备注
FT-001	用户认证	成功注册	1. 访问注册页面 2. 输入有效的、未注册的用户名、邮箱、密码（两次） 3. 点击注册按钮	1. 提示注册成功 2. 自动登录并跳转到首页或指定页面 3. 数据库新增用户及Profile	Pass
FT-002	用户认证	用户名已存在注册失败	1. 访问注册页面 2. 输入已存在的用户名，其他信息有效 3. 点击注册按钮	1. 提示用户名已存在错误 2. 停留在注册页面	Pass
FT-003	用户认证	邮箱已存在注册失败	1. 访问注册页面 2. 输入已存在的邮箱，其他信息有效 3. 点击注册按钮	1. 提示邮箱已存在错误 2. 停留在注册页面	Pass
FT-004	用户认证	两次密码不一致注册失败	1. 访问注册页面 2. 输入两次不一致的密码，其他信息有效 3. 点击注册按钮	1. 提示密码不一致错误 2. 停留在注册页面	Pass
FT-005	用户认证	成功登录	1. 访问登录页面 2. 输入已注册且正确的用户名和密码 3. 点击登录按钮	1. 提示登录成功 2. 跳转到首页或指定页面 3. 导航栏显示用户名和退出按钮	Pass
FT-006	用户认证	密码错误登录失败	1. 访问登录页面 2. 输入正确的用户名和错误的密码 3. 点击登录按钮	1. 提示用户名或密码错误 2. 停留在登录页面	Pass
FT-007	用户认证	用户不存在登录失败	1. 访问登录页面 2. 输入未注册的用户名和任意密码 3. 点击登录按钮	1. 提示用户名或密码错误 2. 停留在登录页面	Pass
FT-008	用户认证	成功登出	1. 用户已登录 2. 点击导航栏的“退出”按钮	1. 跳转到登录页面或首页 2. 导航栏显示登录和注册按钮	Pass
FT-009	用户认证	忘记密码-成功重置	1. 访问登录页面 2. 点击“忘记密码” 3. 输入存在的用户名、新密码、确认密码 4. 点击重置	1. 模态框提示成功 2. 数据库用户密码已更新 3. 模态框自动关闭	Pass	@csrf_exempt
FT-010	用户认证	忘记密码-用户不存在	1. 访问登录页面 2. 点击“忘记密码” 3. 输入不存在的用户名，其他有效 4. 点击重置	1. 模态框提示用户不存在错误	Pass
FT-011	用户认证	忘记密码-两次密码不一致	1. 访问登录页面 2. 点击“忘记密码” 3. 输入存在的用户名，两次密码不一致 4. 点击重置	1. 模态框提示密码不一致错误	Pass
FT-012	个人中心	查看并成功修改个人资料(电话)	1. 用户登录 2. 访问个人资料页面 3. 修改电话号码 4. 点击保存	1. 提示更新成功 2. 页面刷新后显示新电话号码 3. 数据库Profile已更新	Pass
FT-013	历史记录	查看检测历史列表（分页）	1. 用户登录 2. 访问历史记录页面 3. 查看列表及统计数据 4. （若有多页）点击分页	1. 显示正确的历史记录列表和统计 2. 分页功能正常	Pass
FT-014	历史记录	成功删除单条历史记录	1. 用户登录 2. 访问历史记录页面 3. 点击某条记录的删除按钮 4. 确认删除	1. 提示删除成功 2. 该条记录从列表消失 3. 数据库记录已删除	Pass
FT-015	图片检测	成功上传本地图片并检测	1. 用户登录 2. 访问图片检测页面 3. 选择有效图片文件上传 4. 点击检测按钮	1. 显示加载动画 2. 跳转到结果页 3. 显示原图、结果图、统计数据 4. 历史记录新增	Pass
FT-016	图片检测	上传非图片文件失败	1. 用户登录 2. 访问图片检测页面 3. 选择非图片文件上传 4. 点击检测按钮	1. 提示无效文件类型错误 （需要后端验证） 2. 停留在上传页面	Fail	(需添加验证)
FT-017	图片检测	成功通过 URL 检测图片	1. 用户登录 2. 访问图片检测页面 3. 切换到 URL 输入 4. 输入有效图片 URL 5. 点击检测	1. 显示加载动画 2. 跳转到结果页 3. 显示原图、结果图、统计数据 4. 历史记录新增	Pass
FT-018	图片检测	输入无效 URL 检测失败	1. 用户登录 2. 访问图片检测页面 3. 切换到 URL 输入 4. 输入无效 URL 5. 点击检测	1. 提示无效 URL 或下载失败错误 2. 停留在上传页面	Pass
FT-019	图片检测	检测包含多个标志的图片	1. 用户登录 2. 访问图片检测页面 3. 上传包含多个交通标志的图片 4. 点击检测	1. 结果图中正确标注所有可识别标志 2. 统计数据正确 3. 详情列表正确	Pass	(依赖模型)
FT-020	图片检测	检测不包含标志的图片	1. 用户登录 2. 访问图片检测页面 3. 上传不含交通标志的图片 4. 点击检测	1. 结果图无标注 2. 提示未检测到标志 3. 统计数据为 0	Pass
FT-021	视频检测	成功上传视频并检测	1. 用户登录 2. 访问视频检测页面 3. 选择有效视频文件上传 4. 点击检测按钮	1. 显示加载动画 2. 跳转到结果页 3. 显示原视频链接、结果视频、统计 4. 历史新增	Pass
FT-022	实时检测	成功启动和停止实时检测	1. 用户登录 2. 访问实时检测页面 3. 点击启动按钮 4. 查看实时画面 5. 点击停止	1. 启动后实时画面显示 2. 停止后提示成功，显示结果视频链接和统计 3. 历史新增	Pass
FT-023	实时检测	实时画面显示检测结果	1. 用户登录 2. 启动实时检测 3. 将交通标志置于摄像头前	1. 实时画面中标志被正确框出并标注	Pass	(依赖模型)
FT-024	管理员后台	管理员成功访问系统看板	1. 管理员登录 2. 访问系统看板 URL	1. 成功进入系统看板页面，显示统计和用户管理	Pass
FT-025	管理员后台	普通用户访问系统看板失败	1. 普通用户登录 2. 尝试访问系统看板 URL	1. 提示无权限错误 2. 重定向到首页或其他页面	Pass
FT-026	管理员后台	查看系统统计数据	1. 管理员登录 2. 访问系统看板	1. 各项统计数据（用户、检测次数等）正确显示	Pass
FT-027	管理员后台	查看用户列表与分页	1. 管理员登录 2. 访问系统看板 3. 查看用户列表 4. 点击分页按钮	1. 显示正确的用户列表 2. 分页功能正常	Pass
FT-028	管理员后台	搜索/筛选用户	1. 管理员登录 2. 访问系统看板 3. 输入搜索词或点击筛选按钮	1. 用户列表根据条件正确过滤显示	Pass
FT-029	管理员后台	成功添加新用户（普通/管理员）	1. 管理员登录 2. 点击添加用户按钮 3. 在模态框输入信息 4. 点击添加	1. 提示添加成功 2. 新用户出现在列表中 3. 数据库新增用户及Profile	Pass
FT-030	管理员后台	添加已存在用户名/邮箱失败	1. 管理员登录 2. 点击添加用户按钮 3. 输入已存在的用户名或邮箱 4. 点击添加	1. 提示用户名或邮箱已存在错误 2. 模态框保持打开	Pass
FT-031	管理员后台	成功编辑用户信息	1. 管理员登录 2. 点击某用户的编辑按钮 3. 在模态框修改信息 4. 点击保存	1. 提示更新成功 2. 用户列表信息更新 3. 数据库信息更新	Pass
FT-032	管理员后台	成功删除普通用户	1. 管理员登录 2. 点击某普通用户的删除按钮 3. 确认删除	1. 提示删除成功 2. 用户从列表消失 3. 数据库用户及相关记录删除	Pass
FT-033	管理员后台	删除管理员用户失败	1. 管理员登录 2. 尝试删除自己或其他管理员账号（如果界面允许）	1. 提示无法删除管理员错误 （或按钮不可见/禁用）	Pass	(需后端验证)

6.2.2 性能测试

性能测试关注系统在不同负载下的响应时间和资源消耗。

• 图片检测时间:
  • 测试不同尺寸（如 640x480, 1920x1080, 4K）和格式（JPG, PNG）的图片。
  • 记录从用户点击检测到结果页面完全加载的总时间。
  • 记录 detector.py 中 detect_image 函数本身的执行时间（后端处理时间）。
  • 在 CPU 和 GPU 环境下分别测试（如果条件允许）。
• 视频检测时间:
  • 测试不同时长（如 10秒, 30秒, 1分钟）、分辨率（720p, 1080p）和编码格式（MP4 H.264）的视频。
  • 记录从用户点击检测到结果页面显示结果视频链接的总时间。
  • 记录 detector.py 中 detect_video 函数本身的执行时间。
• 实时检测帧率 (FPS):
  • 在实时检测页面，观察视频流的流畅度。
  • （可选）在后端 gen_frames 中计算并记录实际处理的帧率。
• 页面加载时间:
  • 使用浏览器开发者工具测量主要页面（首页、检测页、历史页、看板）的加载时间。
• 并发用户测试（可选）:
  • 使用压力测试工具（如 ApacheBench, Locust）模拟多个用户同时访问系统或进行检测操作，观察系统的响应时间和稳定性。对于本科项目，此项通常简化或省略。

6.2.3 易用性测试

易用性测试关注用户在使用系统时的体验。

• 导航清晰度: 用户能否轻松找到所需功能？导航栏和页面链接是否明确？
• 操作流程: 注册、登录、上传、检测、查看结果、管理历史等流程是否顺畅、符合用户习惯？
• 界面布局: 页面布局是否合理？信息展示是否清晰？在不同分辨率下是否正常显示（响应式）？
• 反馈及时性: 系统是否对用户操作给出及时、明确的反馈（如加载提示、成功/错误消息）？
• 学习成本: 新用户是否需要大量指导才能使用系统？

易用性测试可以通过邀请少量目标用户（如同学）试用系统并收集反馈来进行。

6.3 测试结果与分析

（注意: 此处需要根据实际测试情况填写。以下为示例性描述。）

经过上述测试用例的执行，系统在功能方面表现基本稳定，核心功能如用户认证、图片/视频/实时检测、历史记录管理、管理员后台等均能按预期工作。测试过程中发现并修复了以下问题：

• 问题1 (FT-016): 图片上传时未对文件类型进行严格的后端验证，导致上传非图片文件可能引发后端错误。修复: 在 detection/views.py 中添加了对上传文件 MIME 类型或扩展名的验证逻辑。
• 问题2 (FT-033): 管理员后台删除用户时，未在后端严格禁止删除管理员账号。修复: 在 users/views.py 的 delete_user 视图中添加了对 user.profile.is_admin 的判断，阻止删除管理员。
• 问题3: 忘记密码功能使用了 @csrf_exempt，存在安全隐患。说明: 此为简化实现，生产环境应采用标准 CSRF 令牌传递机制（例如，在前端 JS 中正确获取并发送）。
• 问题4: detector.py 中加载中文字体时，如果指定路径字体不存在，未提供明确的回退或提示。修复: 添加了字体加载的 try-except 块，并在字体加载失败时打印警告信息，使用默认字体。同时修正了代码中可能的字体路径错误。
• 问题5: 中文名称映射 sign_name_mapping 依赖于硬编码的英文名称，可能因模型输出的微小变化（如大小写、特殊字符）导致匹配失败。修复: 在 get_chinese_name 中增加了对输入名称进行小写转换和去除首尾空格的处理，并优先尝试精确匹配，然后进行模糊匹配，提高了匹配的鲁棒性。添加了未找到匹配时的日志输出。

性能方面：

• 在测试硬件（例如 Intel Core i7, 16GB RAM, NVIDIA GTX 1660 Ti）上，1080p 图片的检测时间（后端）通常在 1-3 秒内完成，整体响应时间（包括网络和前端渲染）在 5 秒以内。
• 1分钟 1080p 视频的处理时间约为 1-2 分钟（GPU 加速）。
• 实时检测在 640x480 分辨率下，可以达到 15-25 FPS，画面基本流畅。
• 页面加载速度良好，主要页面均可在 2 秒内完成加载。

易用性方面：

• 用户反馈界面设计美观，科技感强，导航清晰。
• 操作流程符合一般 Web 应用习惯，易于上手。
• 加载提示和操作反馈及时。
• 建议：视频检测处理时间较长，可以在前端增加更明确的进度提示或采用后台任务队列处理。

测试结论:

系统核心功能完整，运行稳定，基本满足设计需求。性能在测试环境下表现良好，能够满足一般应用场景。易用性较高。部分细节（如文件类型验证、CSRF 处理）和性能优化（如长视频处理）有待进一步完善。

7. 结论

7.1 工作总结

本项目成功设计并实现了一个基于 YOLOv8 目标检测算法和 Django Web 框架的智能交通标志识别系统。主要完成了以下工作：

1. 系统构建: 搭建了完整的 Web 应用系统，集成了用户管理、多模式交通标志检测（图片、视频、实时）、历史记录管理和管理员后台等功能模块。
2. 核心检测实现: 利用 ultralytics 库集成了先进的 YOLOv8 模型，并结合 OpenCV 实现了对图像、视频和实时摄像头的交通标志检测与识别逻辑，包括边界框绘制和中文标签显示。
3. 后端开发: 基于 Django 框架，采用 MVT 模式，实现了用户认证、数据模型（User, Profile, DetectionHistory）定义与交互、URL 路由、视图逻辑处理、表单验证、API（用于密码重置）等后端功能。
4. 前端开发: 使用 HTML/CSS/JavaScript，结合 Bootstrap、jQuery、Particles.js 等技术，构建了响应式、交互友好、具有科技感视觉风格的用户界面，实现了文件上传（包括拖放）、URL 输入、实时视频流展示、结果可视化、动态效果和 AJAX 交互。
5. 管理员功能: 开发了系统看板，提供了系统运行状态的统计概览和便捷的用户管理功能（增删改查、搜索筛选）。
6. 测试与评估: 对系统进行了功能、性能和易用性测试，验证了系统的可行性和稳定性，并找出了部分可改进之处。

该系统整合了前沿的深度学习目标检测技术和成熟的 Web 开发框架，提供了一个功能相对完善、易于使用的交通标志识别平台，验证了将 YOLOv8 应用于实际 Web 项目的可行性。

7.2 系统特点与不足

系统特点：

• 先进的检测核心: 采用了高性能的 YOLOv8 算法，保证了较好的检测精度和速度。
• 多模式检测: 支持图片、视频、实时摄像头三种输入方式，满足不同应用场景的需求。
• 用户友好: 提供了现代化的 Web 界面，操作直观，反馈及时，并加入了粒子动画等视觉效果。
• 功能完整: 涵盖了用户管理、检测任务、历史记录、管理员后台等常用功能模块。
• 易于扩展: 基于 Django 框架和模块化设计，便于后续的功能扩展和模型升级。
• 中文支持: 特别处理了中文字体和标签显示，符合中文用户使用习惯。

系统不足：

• 模型依赖: 检测性能高度依赖于所使用的 YOLOv8 模型 (best.pt) 的训练质量和泛化能力。对于训练数据集中未包含或罕见的交通标志，识别效果可能不佳。
• 安全性有待加强: 忘记密码功能使用了 @csrf_exempt，这在生产环境中存在安全风险，应改为标准的 CSRF 防护机制。文件上传的类型和大小限制也需要进一步完善。
• 性能瓶颈: 对于大尺寸视频文件或高并发实时检测，当前实现可能存在性能瓶颈，尤其是在 CPU 环境下。视频检测为同步处理，用户需要等待较长时间。
• 错误处理: 虽然进行了一些异常处理，但可以进一步细化，对各种可能的错误（如模型加载失败、文件损坏、网络问题等）提供更具体的反馈。
• 部署复杂性: 相较于纯前端或简单后端应用，包含深度学习模型的 Web 应用部署相对复杂，需要考虑 Python 环境、依赖库、模型文件以及可能的 GPU 支持。
• 密码重置流程简化: 当前的忘记密码流程直接允许用户通过用户名重置，缺少邮箱或手机验证环节，安全性较低。

7.3 未来工作展望

针对当前系统的不足和未来的发展趋势，可以从以下几个方面进行改进和展望：

1. 模型优化与提升:
   • 模型微调: 收集更具针对性的交通标志数据集（尤其是中国交通标志），对 YOLOv8 模型进行微调（Fine-tuning），以提高对特定区域、特定类型或小目标标志的识别精度和鲁棒性。
   • 模型蒸馏/量化: 研究模型压缩技术，生成更轻量级的模型，以提高在 CPU 或资源受限设备上的推理速度。
   • 集成最新模型: 持续关注目标检测领域的最新进展，适时引入更先进的模型或技术。
2. 系统性能优化:
   • 异步任务处理: 对于耗时的视频检测任务，引入 Celery 等异步任务队列进行处理，用户提交任务后即可离开页面，处理完成后通过通知或页面刷新获取结果，改善用户体验。
   • 缓存机制: 对常用的数据（如统计数据）或计算结果应用缓存，减少数据库查询和重复计算。
   • 代码优化: 分析性能瓶颈（如图像预处理、后处理、数据库查询），进行针对性优化。
3. 功能增强:
   • 详细统计分析: 在管理员后台增加更丰富的统计图表和分析功能，如用户活跃度分析、常见标志统计、检测准确率评估（需引入标注数据）等。
   • 结果导出: 提供将检测结果（如统计数据、标注信息）导出为 CSV 或其他格式的功能。
   • API 接口: 提供标准的 RESTful API 接口，方便其他系统或应用集成交通标志识别功能。
   • 多目标跟踪: 在视频和实时检测中，引入目标跟踪算法（如 DeepSORT, ByteTrack），对同一标志进行持续跟踪和编号。
4. 安全性强化:
   • 移除 @csrf_exempt: 规范 AJAX 请求的 CSRF 处理。
   • 增强密码重置: 加入邮箱或短信验证码环节。
   • 输入验证: 对所有用户输入（包括 URL、文件）进行更严格的合法性和安全性校验。
   • 权限细化: 对管理员权限进行更细粒度的划分（如果需要）。
5. 部署与集成:
   • 容器化部署: 使用 Docker 和 Docker Compose 对应用进行容器化，简化部署和环境管理。
   • 云平台集成: 将系统部署到云平台，利用云服务的弹性伸缩、负载均衡、GPU 实例等优势。
   • 移动端适配/应用: 开发移动端友好的界面或独立的移动应用程序。

总之，本项目构建的智能交通标志识别系统是一个有价值的起点。通过持续的优化、功能增强和技术迭代，有望在智能交通、驾驶辅助等领域发挥更大的作用。

参考文献

（此处应列出您在研究和开发过程中参考的相关论文、技术文档、书籍、网站等。格式请遵循学校要求的参考文献格式规范。例如：）

[1] Redmon J, Divvala S, Girshick R, Farhadi A. You Only Look Once: Unified, Real-Time Object Detection[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2016: 779-788.
[2] Bochkovskiy A, Wang C Y, Liao H Y M. YOLOv4: Optimal Speed and Accuracy of Object Detection[J]. arXiv preprint arXiv:2004.10934, 2020.
[3] Jocher G, Chaurasia A, Stärk J, et al. Ultralytics YOLOv8 [DB/OL]. https://github.com/ultralytics/ultralytics, 2023.
[4] Django Software Foundation. Django Documentation[EB/OL]. https://docs.djangoproject.com/en/4.2/, 2023.
[5] Bradski G, Kaehler A. Learning OpenCV: Computer vision with the OpenCV library[M]. O’reilly Media, Inc., 2008.
[6] Stallkamp J, Schlipsing M, Salmen J, Igel C. The German traffic sign recognition benchmark: a multi-class classification competition[C]//The 2011 international joint conference on neural networks. IEEE, 2011: 1453-1460.
[7] … (其他相关文献) …

致谢

（在此处感谢在论文写作和项目开发过程中提供指导和帮助的老师、同学、以及开源社区等。）