基于深度学习的茶叶病害检测系统（YOLOv8+YOLO数据集+UI界面+Python项目源码+模型）

一、项目介绍

摘要

本项目基于先进的YOLOv8深度学习算法，开发了一套高精度、高效率的茶叶病害智能检测系统。系统能够准确识别和分类8种茶叶常见病害及虫害，包括：茶黑腐病（Black rot of tea）、茶褐斑病（Brown blight of tea）、茶锈病（Leaf rust of tea）、红蜘蛛侵害叶（Red Spider infested tea leaf）、茶蚊虫侵害叶（Tea Mosquito bug infested leaf）、健康茶叶（Tea leaf）、茶白斑病（White spot of tea）以及其他病害（disease）。项目采用专业构建的茶叶病害数据集进行训练和验证，其中训练集4736张、验证集273张、测试集406张，确保模型在不同光照条件、拍摄角度和病害严重程度下均具有优异的泛化能力。

本系统可部署于移动终端（如智能手机）、无人机巡检设备或固定式茶园监测站，实现茶叶病害的实时、自动化检测，帮助茶农快速发现病害并采取针对性防治措施。相较于传统依赖人工经验的目视检查方式，该系统显著提高了检测效率和准确性，可广泛应用于大型茶园、有机茶种植基地及农业科研机构，为茶叶产业的智能化、精准化管理提供技术支持。

项目意义

1. 提升茶叶种植科学化管理水平

• 早期病害识别：许多茶叶病害在初期症状不明显，但本系统能检测微小病变，帮助茶农在病害扩散前及时干预，减少经济损失。

• 精准施药指导：通过准确识别病害类型，可优化农药使用，避免盲目喷洒，既降低成本，又减少环境污染，符合绿色农业发展趋势。

• 减少经验依赖：传统病害诊断依赖农技人员经验，而AI系统可标准化检测流程，使普通茶农也能获得专业级诊断能力。

2. 提高茶叶品质与产量

• 降低病害损失：病害可导致茶叶减产，甚至影响多年生长。智能检测可大幅减少因病害造成的经济损失。

• 保障茶叶安全：红蜘蛛、茶蚊虫等虫害可能影响茶叶食用安全，系统可及时发现并预警，确保茶叶符合质量标准。

• 优化种植决策：长期病害数据积累可帮助分析病害流行规律，指导茶园布局、品种选择等决策。

3. 推动智慧农业发展

• 适配智慧农业设备：系统可集成至农业无人机、智能巡检机器人等设备，实现茶园全天候监测，构建"数字茶园"。

• 促进农业AI普及：本项目为其他高价值经济作物（如咖啡、柑橘）的病害检测提供了技术参考，助力农业全面智能化。

• 数据驱动农业研究：构建的茶叶病害数据集填补了该领域的空白，可为后续研究（如病害预测模型）提供支持。

4. 显著的社会经济效益

• 增加农民收入：及时有效的病害防治可提升茶叶等级和产量，直接增加茶农收益。

• 减少农药滥用：精准施药可降低农药使用量，既节约成本，又提升茶叶安全性，增强市场竞争力。

• 助力乡村振兴：为传统茶产业注入智能技术，提升产业附加值，特别适合帮助山区小农户实现产业升级。

5. 技术创新与扩展价值

• 多病害同时检测：相比传统单病害检测系统，本方案可一次性识别多种病害，效率提升显著。

• 轻量化部署：YOLOv8的优化使系统可在手机APP、边缘计算设备上流畅运行，适合基础设施较差的农村地区。

• 持续学习能力：系统支持后续添加新病害类别，适应不断变化的种植环境。

未来展望

1. 多模态数据融合：结合高光谱成像、气象数据等，提升早期病害识别率，实现病害预警。

2. 病害发展预测：基于时间序列图像分析，预测病害扩散趋势，提供最佳防治时间窗口。

3. 区块链溯源：将检测结果上链，构建从茶园到茶杯的全流程品质追溯系统。

4. 农业知识图谱：整合病害防治知识库，为茶农提供"检测-诊断-防治"一站式服务。

5. 全球推广应用：适应不同地区茶树品种和病害类型，服务全球主要产茶国。

本项目不仅为茶叶种植提供了创新的AI解决方案，更探索了人工智能与传统农业深度融合的可行路径，对推动我国农业现代化进程具有重要的示范意义。随着系统不断完善，预计可在3-5年内覆盖全国主要茶区，惠及数百万茶农，创造显著的经济和社会价值。

目录

一、项目介绍

摘要

项目意义

二、项目功能展示

系统功能

图片检测

视频检测

摄像头实时检测

三、数据集介绍

数据集配置文件data.yaml

数据集制作流程

四、项目环境配置

创建虚拟环境

pycharm中配置anaconda

安装所需要库

五、模型训练

训练代码

训练结果

六、核心代码

七、项目源码(视频简介内)

---

基于深度学习的茶叶病害检测系统（YOLOv8+YOLO数据集+UI界面+Python项目源码+模型）_哔哩哔哩_bilibili

基于深度学习的茶叶病害检测系统（YOLOv8+YOLO数据集+UI界面+Python项目源码+模型）

二、项目功能展示

系统功能

✅ 图片检测：可对单张图片进行检测，返回检测框及类别信息。
✅ 批量图片检测：支持文件夹输入，一次性检测多张图片，生成批量检测结果。
✅ 视频检测：支持视频文件输入，检测视频中每一帧的情况。
✅ 摄像头实时检测：连接USB 摄像头，实现实时监测，

• 图片检测

        该功能允许用户通过单张图片进行目标检测。输入一张图片后，YOLO模型会实时分析图像，识别出其中的目标，并在图像中框出检测到的目标，输出带有目标框的图像。批量图片检测

        用户可以一次性上传多个图片进行批量处理。该功能支持对多个图像文件进行并行处理，并返回每张图像的目标检测结果，适用于需要大规模处理图像数据的应用场景。

• 视频检测

        视频检测功能允许用户将视频文件作为输入。YOLO模型将逐帧分析视频，并在每一帧中标记出检测到的目标。最终结果可以是带有目标框的视频文件或实时展示，适用于视频监控和分析等场景。

• 摄像头实时检测

        该功能支持通过连接摄像头进行实时目标检测。YOLO模型能够在摄像头拍摄的实时视频流中进行目标检测，实时识别并显示检测结果。此功能非常适用于安防监控、无人驾驶、智能交通等应用，提供即时反馈。

核心特点：

• 高精度：基于YOLO模型，提供精确的目标检测能力，适用于不同类型的图像和视频。
• 实时性：特别优化的算法使得实时目标检测成为可能，无论是在视频还是摄像头实时检测中，响应速度都非常快。
• 批量处理：支持高效的批量图像和视频处理，适合大规模数据分析。

三、数据集介绍

 

数据集名称: 茶叶病害检测数据集

数据集内容:

• 类别数量 (nc): 8类

  • 类别名称: ['Black rot of tea', 'Brown blight of tea', 'Leaf rust of tea', 'Red Spider infested tea leaf', 'Tea Mosquito bug infested leaf', 'Tea leaf', 'White spot of tea', 'disease']

    • Black rot of tea: 茶黑腐病

    • Brown blight of tea: 茶褐斑病

    • Leaf rust of tea: 茶锈病

    • Red Spider infested tea leaf: 红蜘蛛侵害茶叶

    • Tea Mosquito bug infested leaf: 茶蚊虫侵害茶叶

    • Tea leaf: 健康茶叶

    • White spot of tea: 茶白斑病

    • disease: 其他病害

• 数据集规模:

  • 训练集: 4736张图像

  • 验证集: 273张图像

  • 测试集: 406张图像

数据来源:

• 数据集通过实地拍摄茶园中的茶叶图像构建，涵盖了不同光照条件、茶叶品种和病害形态，以确保模型的泛化能力。

数据标注:

• 每张图像中的茶叶病害均使用边界框（Bounding Box）标注，并标注对应的病害类别。

• 标注格式为YOLO格式（class_id, x_center, y_center, width, height），便于直接用于YOLOv8模型的训练。

数据增强:

• 为提高模型的鲁棒性，数据集进行了以下增强处理：

  • 随机旋转

  • 亮度调整

  • 对比度调整

  • 水平翻转

  • 添加噪声

数据集特点:

• 多样性: 数据集包含不同病害类型的茶叶图像，覆盖了多种场景和光照条件。

• 高质量: 图像分辨率高，标注精确，适合深度学习模型的训练。

• 平衡性: 八类样本数量分布相对均衡，避免了类别不平衡问题。

数据集配置文件data.yaml

train: .\datasets\images\train
val: .\datasets\images\val
test: .\datasets\images\test


nc: 8
names: ['Black rot of tea', 'Brown blight of tea', 'Leaf rust of tea', 'Red Spider infested tea leaf', 'Tea Mosquito bug infested leaf', 'Tea leaf', 'White spot of tea', 'disease']

数据集制作流程

• 标注数据：使用标注工具（如LabelImg、CVAT等）对图像中的目标进行标注。每个目标需要标出边界框，并且标注类别。

• 转换格式：将标注的数据转换为YOLO格式。YOLO标注格式为每行：<object-class> <x_center> <y_center> <width> <height>，这些坐标是相对于图像尺寸的比例。

• 分割数据集：将数据集分为训练集、验证集和测试集，通常的比例是80%训练集、10%验证集和10%测试集。

• 准备标签文件：为每张图片生成一个对应的标签文件，确保标签文件与图片的命名一致。

• 调整图像尺寸：根据YOLO网络要求，统一调整所有图像的尺寸（如416x416或608x608）。

四、项目环境配置

创建虚拟环境

首先新建一个Anaconda环境，每个项目用不同的环境，这样项目中所用的依赖包互不干扰。

终端输入

conda create -n yolov8 python==3.9

激活虚拟环境

conda activate yolov8
 

安装cpu版本pytorch

pip install torch torchvision torchaudio

pycharm中配置anaconda

安装所需要库

pip install -r requirements.txt

五、模型训练

训练代码

from ultralytics import YOLO

model_path = 'yolov8s.pt'
data_path = 'datasets/data.yaml'

if __name__ == '__main__':
    model = YOLO(model_path)
    results = model.train(data=data_path,
                          epochs=500,
                          batch=64,
                          device='0',
                          workers=0,
                          project='runs/detect',
                          name='exp',
                          )

根据实际情况更换模型
yolov8n.yaml (nano)：轻量化模型，适合嵌入式设备，速度快但精度略低。
yolov8s.yaml (small)：小模型，适合实时任务。
yolov8m.yaml (medium)：中等大小模型，兼顾速度和精度。
yolov8b.yaml (base)：基本版模型，适合大部分应用场景。
yolov8l.yaml (large)：大型模型，适合对精度要求高的任务。

• --batch 64：每批次64张图像。
• --epochs 500：训练500轮。
• --datasets/data.yaml：数据集配置文件。
• --weights yolov8s.pt：初始化模型权重，yolov8s.pt 是预训练的轻量级YOLO模型。

训练结果

六、核心代码

# -*- coding: utf-8 -*-
import os
import sys
import time
import cv2
import numpy as np
from PIL import ImageFont
from PyQt5.QtCore import Qt, QTimer, QThread, pyqtSignal, QCoreApplication
from PyQt5.QtWidgets import (QApplication, QMainWindow, QFileDialog,
                             QMessageBox, QWidget, QHeaderView,
                             QTableWidgetItem, QAbstractItemView)
from ultralytics import YOLO

# 自定义模块导入
sys.path.append('UIProgram')
from UIProgram.UiMain import Ui_MainWindow
from UIProgram.QssLoader import QSSLoader
from UIProgram.precess_bar import ProgressBar
import detect_tools as tools
import Config


class DetectionApp(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # 初始化应用
        self._setup_ui()
        self._connect_signals()
        self._load_stylesheet()

        # 模型和资源初始化
        self._init_detection_resources()

    def _setup_ui(self):
        """初始化UI界面设置"""
        self.display_width = 700
        self.display_height = 500
        self.source_path = None
        self.camera_active = False
        self.video_capture = None

        # 配置表格控件
        table = self.ui.tableWidget
        table.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
        table.verticalHeader().setDefaultSectionSize(40)
        table.setColumnWidth(0, 80)  # ID列
        table.setColumnWidth(1, 200)  # 路径列
        table.setColumnWidth(2, 150)  # 类别列
        table.setColumnWidth(3, 90)  # 置信度列
        table.setColumnWidth(4, 230)  # 位置列
        table.setSelectionBehavior(QAbstractItemView.SelectRows)
        table.verticalHeader().setVisible(False)
        table.setAlternatingRowColors(True)

    def _connect_signals(self):
        """连接按钮信号与槽函数"""
        self.ui.PicBtn.clicked.connect(self._handle_image_input)
        self.ui.comboBox.activated.connect(self._update_selection)
        self.ui.VideoBtn.clicked.connect(self._handle_video_input)
        self.ui.CapBtn.clicked.connect(self._toggle_camera)
        self.ui.SaveBtn.clicked.connect(self._save_results)
        self.ui.ExitBtn.clicked.connect(QCoreApplication.quit)
        self.ui.FilesBtn.clicked.connect(self._process_image_batch)

    def _load_stylesheet(self):
        """加载CSS样式表"""
        style_file = 'UIProgram/style.css'
        qss = QSSLoader.read_qss_file(style_file)
        self.setStyleSheet(qss)

    def _init_detection_resources(self):
        """初始化检测相关资源"""
        # 加载YOLOv8模型
        self.detector = YOLO('runs/detect/exp/weights/best.pt', task='detect')
        self.detector(np.zeros((48, 48, 3)))  # 预热模型

        # 初始化字体和颜色
        self.detection_font = ImageFont.truetype("Font/platech.ttf", 25, 0)
        self.color_palette = tools.Colors()

        # 初始化定时器
        self.frame_timer = QTimer()
        self.save_timer = QTimer()

    def _handle_image_input(self):
        """处理单张图片输入"""
        self._stop_video_capture()

        file_path, _ = QFileDialog.getOpenFileName(
            self, '选择图片', './', "图片文件 (*.jpg *.jpeg *.png)")
        if not file_path:
            return

        self._process_single_image(file_path)

    def _process_single_image(self, image_path):
        """处理并显示单张图片的检测结果"""
        self.source_path = image_path
        self.ui.comboBox.setEnabled(True)

        # 读取并检测图片
        start_time = time.time()
        detection_results = self.detector(image_path)[0]
        processing_time = time.time() - start_time

        # 解析检测结果
        boxes = detection_results.boxes.xyxy.tolist()
        self.detection_boxes = [list(map(int, box)) for box in boxes]
        self.detection_classes = detection_results.boxes.cls.int().tolist()
        confidences = detection_results.boxes.conf.tolist()
        self.confidence_scores = [f'{score * 100:.2f}%' for score in confidences]

        # 更新UI显示
        self._update_detection_display(detection_results, processing_time)
        self._update_object_selection()
        self._show_detection_details()
        self._display_results_table(image_path)

    def _update_detection_display(self, results, process_time):
        """更新检测结果显示"""
        # 显示处理时间
        self.ui.time_lb.setText(f'{process_time:.3f} s')

        # 获取带标注的图像
        annotated_img = results.plot()
        self.current_result = annotated_img

        # 调整并显示图像
        width, height = self._calculate_display_size(annotated_img)
        resized_img = cv2.resize(annotated_img, (width, height))
        qimage = tools.cvimg_to_qpiximg(resized_img)

        self.ui.label_show.setPixmap(qimage)
        self.ui.label_show.setAlignment(Qt.AlignCenter)
        self.ui.PiclineEdit.setText(self.source_path)

        # 更新检测数量
        self.ui.label_nums.setText(str(len(self.detection_classes)))

    def _calculate_display_size(self, image):
        """计算适合显示的图像尺寸"""
        img_height, img_width = image.shape[:2]
        aspect_ratio = img_width / img_height

        if aspect_ratio >= self.display_width / self.display_height:
            width = self.display_width
            height = int(width / aspect_ratio)
        else:
            height = self.display_height
            width = int(height * aspect_ratio)

        return width, height

    def _update_object_selection(self):
        """更新目标选择下拉框"""
        options = ['全部']
        target_labels = [
            f'{Config.names[cls_id]}_{idx}'
            for idx, cls_id in enumerate(self.detection_classes)
        ]
        options.extend(target_labels)

        self.ui.comboBox.clear()
        self.ui.comboBox.addItems(options)

    def _show_detection_details(self, index=0):
        """显示检测目标的详细信息"""
        if not self.detection_boxes:
            self._clear_detection_details()
            return

        box = self.detection_boxes[index]
        self.ui.type_lb.setText(Config.CH_names[self.detection_classes[index]])
        self.ui.label_conf.setText(self.confidence_scores[index])
        self.ui.label_xmin.setText(str(box[0]))
        self.ui.label_ymin.setText(str(box[1]))
        self.ui.label_xmax.setText(str(box[2]))
        self.ui.label_ymax.setText(str(box[3]))

    def _clear_detection_details(self):
        """清空检测详情显示"""
        self.ui.type_lb.setText('')
        self.ui.label_conf.setText('')
        self.ui.label_xmin.setText('')
        self.ui.label_ymin.setText('')
        self.ui.label_xmax.setText('')
        self.ui.label_ymax.setText('')

    def _display_results_table(self, source_path):
        """在表格中显示检测结果"""
        table = self.ui.tableWidget
        table.setRowCount(0)
        table.clearContents()

        for idx, (box, cls_id, conf) in enumerate(zip(
                self.detection_boxes, self.detection_classes, self.confidence_scores)):

            row = table.rowCount()
            table.insertRow(row)

            # 添加表格项
            items = [
                QTableWidgetItem(str(row + 1)),  # ID
                QTableWidgetItem(source_path),  # 路径
                QTableWidgetItem(Config.CH_names[cls_id]),  # 类别
                QTableWidgetItem(conf),  # 置信度
                QTableWidgetItem(str(box))  # 位置坐标
            ]

            # 设置文本居中
            for item in [items[0], items[2], items[3]]:
                item.setTextAlignment(Qt.AlignCenter)

            # 添加到表格
            for col, item in enumerate(items):
                table.setItem(row, col, item)

        table.scrollToBottom()

    def _process_image_batch(self):
        """批量处理图片"""
        self._stop_video_capture()

        folder = QFileDialog.getExistingDirectory(self, "选择图片文件夹", "./")
        if not folder:
            return

        self.source_path = folder
        valid_extensions = {'jpg', 'png', 'jpeg', 'bmp'}

        for filename in os.listdir(folder):
            filepath = os.path.join(folder, filename)
            if (os.path.isfile(filepath) and
                    filename.split('.')[-1].lower() in valid_extensions):
                self._process_single_image(filepath)
                QApplication.processEvents()  # 保持UI响应

    def _update_selection(self):
        """更新用户选择的检测目标显示"""
        selection = self.ui.comboBox.currentText()

        if selection == '全部':
            boxes = self.detection_boxes
            display_img = self.current_result
            self._show_detection_details(0)
        else:
            idx = int(selection.split('_')[-1])
            boxes = [self.detection_boxes[idx]]
            display_img = self.detector(self.source_path)[0][idx].plot()
            self._show_detection_details(idx)

        # 更新显示
        width, height = self._calculate_display_size(display_img)
        resized_img = cv2.resize(display_img, (width, height))
        qimage = tools.cvimg_to_qpiximg(resized_img)

        self.ui.label_show.clear()
        self.ui.label_show.setPixmap(qimage)
        self.ui.label_show.setAlignment(Qt.AlignCenter)

    def _handle_video_input(self):
        """处理视频输入"""
        if self.camera_active:
            self._toggle_camera()

        video_path = self._get_video_path()
        if not video_path:
            return

        self._start_video_processing(video_path)
        self.ui.comboBox.setEnabled(False)

    def _get_video_path(self):
        """获取视频文件路径"""
        path, _ = QFileDialog.getOpenFileName(
            self, '选择视频', './', "视频文件 (*.avi *.mp4)")

        if path:
            self.source_path = path
            self.ui.VideolineEdit.setText(path)
            return path
        return None

    def _start_video_processing(self, video_path):
        """开始处理视频流"""
        self.video_capture = cv2.VideoCapture(video_path)
        self.frame_timer.start(1)
        self.frame_timer.timeout.connect(self._process_video_frame)

    def _stop_video_capture(self):
        """停止视频捕获"""
        if self.video_capture:
            self.video_capture.release()
            self.frame_timer.stop()
            self.camera_active = False
            self.ui.CaplineEdit.setText('摄像头未开启')
            self.video_capture = None

    def _process_video_frame(self):
        """处理视频帧"""
        ret, frame = self.video_capture.read()
        if not ret:
            self._stop_video_capture()
            return

        # 执行目标检测
        start_time = time.time()
        results = self.detector(frame)[0]
        processing_time = time.time() - start_time

        # 解析结果
        self.detection_boxes = results.boxes.xyxy.int().tolist()
        self.detection_classes = results.boxes.cls.int().tolist()
        self.confidence_scores = [f'{conf * 100:.2f}%' for conf in results.boxes.conf.tolist()]

        # 更新显示
        self._update_detection_display(results, processing_time)
        self._update_object_selection()
        self._show_detection_details()
        self._display_results_table(self.source_path)

    def _toggle_camera(self):
        """切换摄像头状态"""
        self.camera_active = not self.camera_active

        if self.camera_active:
            self.ui.CaplineEdit.setText('摄像头开启')
            self.video_capture = cv2.VideoCapture(0)
            self._start_video_processing(0)
            self.ui.comboBox.setEnabled(False)
        else:
            self.ui.CaplineEdit.setText('摄像头未开启')
            self.ui.label_show.clear()
            self._stop_video_capture()

    def _save_results(self):
        """保存检测结果"""
        if not self.video_capture and not self.source_path:
            QMessageBox.information(self, '提示', '没有可保存的内容，请先打开图片或视频！')
            return

        if self.camera_active:
            QMessageBox.information(self, '提示', '无法保存摄像头实时视频！')
            return

        if self.video_capture:
            self._save_video_result()
        else:
            self._save_image_result()

    def _save_video_result(self):
        """保存视频检测结果"""
        confirm = QMessageBox.question(
            self, '确认',
            '保存视频可能需要较长时间，确定继续吗？',
            QMessageBox.Yes | QMessageBox.No)

        if confirm == QMessageBox.No:
            return

        self._stop_video_capture()
        saver = VideoSaverThread(
            self.source_path, self.detector,
            self.ui.comboBox.currentText())
        saver.start()
        saver.update_ui_signal.connect(self._update_progress)

    def _save_image_result(self):
        """保存图片检测结果"""
        if os.path.isfile(self.source_path):
            # 处理单张图片
            filename = os.path.basename(self.source_path)
            name, ext = filename.rsplit(".", 1)
            save_name = f"{name}_detect_result.{ext}"
            save_path = os.path.join(Config.save_path, save_name)

            cv2.imwrite(save_path, self.current_result)
            QMessageBox.information(
                self, '完成',
                f'图片已保存至: {save_path}')
        else:
            # 处理文件夹中的图片
            valid_exts = {'jpg', 'png', 'jpeg', 'bmp'}
            for filename in os.listdir(self.source_path):
                if filename.split('.')[-1].lower() in valid_exts:
                    filepath = os.path.join(self.source_path, filename)
                    name, ext = filename.rsplit(".", 1)
                    save_name = f"{name}_detect_result.{ext}"
                    save_path = os.path.join(Config.save_path, save_name)

                    results = self.detector(filepath)[0]
                    cv2.imwrite(save_path, results.plot())

            QMessageBox.information(
                self, '完成',
                f'所有图片已保存至: {Config.save_path}')

    def _update_progress(self, current, total):
        """更新保存进度"""
        if current == 1:
            self.progress_dialog = ProgressBar(self)
            self.progress_dialog.show()

        if current >= total:
            self.progress_dialog.close()
            QMessageBox.information(
                self, '完成',
                f'视频已保存至: {Config.save_path}')
            return

        if not self.progress_dialog.isVisible():
            return

        percent = int(current / total * 100)
        self.progress_dialog.setValue(current, total, percent)
        QApplication.processEvents()


class VideoSaverThread(QThread):
    """视频保存线程"""
    update_ui_signal = pyqtSignal(int, int)

    def __init__(self, video_path, model, selection):
        super().__init__()
        self.video_path = video_path
        self.detector = model
        self.selection = selection
        self.active = True
        self.colors = tools.Colors()

    def run(self):
        """执行视频保存"""
        cap = cv2.VideoCapture(self.video_path)
        fourcc = cv2.VideoWriter_fourcc(*'XVID')
        fps = cap.get(cv2.CAP_PROP_FPS)
        size = (
            int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
            int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))

        filename = os.path.basename(self.video_path)
        name, _ = filename.split('.')
        save_path = os.path.join(
            Config.save_path,
            f"{name}_detect_result.avi")

        writer = cv2.VideoWriter(save_path, fourcc, fps, size)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        current_frame = 0

        while cap.isOpened() and self.active:
            current_frame += 1
            ret, frame = cap.read()

            if not ret:
                break

            # 执行检测
            results = self.detector(frame)[0]
            frame = results.plot()
            writer.write(frame)
            self.update_ui_signal.emit(current_frame, total_frames)

        # 释放资源
        cap.release()
        writer.release()

    def stop(self):
        """停止保存过程"""
        self.active = False


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = DetectionApp()
    window.show()
    sys.exit(app.exec_())

七、项目源码(视频简介内)

        完整全部资源文件（包括测试图片、视频，py文件，训练数据集、训练代码、界面代码等），这里已打包上传至博主的面包多平台，见可参考博客与视频，已将所有涉及的文件同时打包到里面，点击即可运行，完整文件截图如下：

演示与介绍视频：

基于深度学习的茶叶病害检测系统（YOLOv8+YOLO数据集+UI界面+Python项目源码+模型）_哔哩哔哩_bilibili

基于深度学习的茶叶病害检测系统（YOLOv8+YOLO数据集+UI界面+Python项目源码+模型）