基于YOLO26的燃气灶具安全检测系统（Python源码+数据集+Pyside6界面）

重复模块m (n次迭代):
┌─────────────────────────────────────────────────────────┐
│                                                         │
│  如果 attn=True:                                        │
│    Sequential(                                          │
│        Bottleneck(self.c, self.c),                     │  ←─ 先特征提取
│        PSABlock(self.c, attn_ratio=0.5, num_heads=...) │  ←─ 后注意力增强
│    )                                                    │
│                                                         │
│  否则如果 c3k=True:                                     │
│    C3k(self.c, self.c, 2)                             │  ←─ 同YOLOv11
│                                                         │
│  否则:                                                  │
│    Bottleneck(self.c, self.c)                         │  ←─ 同YOLOv11
│                                                         │
└─────────────────────────────────────────────────────────┘

class BboxLoss(nn.Module):
    """Criterion class for computing training losses for bounding boxes."""

    def __init__(self, reg_max: int = 16):
        """Initialize the BboxLoss module with regularization maximum and DFL settings."""
        super().__init__()
        self.dfl_loss = DFLoss(reg_max) if reg_max > 1 else None

# Dataset unificado a partir de Final_dataset.
path: D:/YOLO26data/Microscopy

train: images/train
val: images/val
test: images/test

nc: 1

names:
  - Mycobacterium

import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO

if __name__ == '__main__':
    model = YOLO('ultralytics/cfg/models/26/yolo26.yaml')
    model.train(data='data/Microscopy.yaml',
                cache=False,
                imgsz=640,
                epochs=200,
                batch=8,
                close_mosaic=10,
                device='0',
                optimizer='SGD', # using SGD
                project='runs/train',
                name='exp',
                )

YOLO26 summary (fused): 122 layers, 2,375,616 parameters, 0 gradients, 5.3 GFLOPs
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 24/24 3.2it/s 7.5s
                   all        753       1038      0.925      0.889      0.937      0.707
                person        141        255       0.95      0.887      0.957      0.746
                 flame        288        288      0.942      0.906      0.961      0.706
                  knob         92        207      0.834      0.816      0.855      0.593
                hazard        227        288      0.973      0.944      0.974      0.784

# -*- coding: utf-8 -*-
"""
================================================================================
 基于 YOLO26 的燃气灶具安全检测系统  —— 整体伪代码（单文件版）
================================================================================
 说明：
   1. 本文件为"伪代码"，用近似 Python 的语法描述整个系统的骨架与调用关系，
      关键函数体用中文注释说明，不能直接运行。
   2. 整体分为 6 层：
        L1 配置层 Config
        L2 数据层 DatasetBuilder      (采集 / 标注 / 增强 / data.yaml)
        L3 训练层 Trainer             (YOLO26 训练 / 验证 / 导出)
        L4 推理层 Detector            (加载模型 / 单帧推理 / 跟踪)
        L5 业务层 SafetyAnalyzer      (燃气灶安全规则状态机)
        L6 界面层 MainWindow          (PySide6 界面 + 视频线程 + 告警)
   3. 目标类别（建议 6 类）：
        0 stove       燃气灶台
        1 flame       火焰
        2 pot         锅具
        3 person      人
        4 smoke       烟雾
        5 spill       溢锅/溢液
================================================================================
"""

# =============================================================================
# L1  配置层
# =============================================================================
import os
import time
import json
import yaml
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple

import cv2
import numpy as np


@dataclass
class Config:
    # ---------- 路径 ----------
    ROOT_DIR: str = os.path.dirname(os.path.abspath(__file__))
    DATASET_DIR: str = os.path.join(ROOT_DIR, "datasets", "gas_stove")
    IMAGES_TRAIN: str = os.path.join(DATASET_DIR, "images", "train")
    IMAGES_VAL: str = os.path.join(DATASET_DIR, "images", "val")
    LABELS_TRAIN: str = os.path.join(DATASET_DIR, "labels", "train")
    LABELS_VAL: str = os.path.join(DATASET_DIR, "labels", "val")
    DATA_YAML: str = os.path.join(DATASET_DIR, "data.yaml")
    WEIGHT_DIR: str = os.path.join(ROOT_DIR, "weights")
    MODEL_PATH: str = os.path.join(WEIGHT_DIR, "yolo26_gas_stove.pt")
    LOG_DIR: str = os.path.join(ROOT_DIR, "logs")

    # ---------- 类别 ----------
    CLASS_NAMES: List[str] = field(default_factory=lambda: [
        "stove", "flame", "pot", "person", "smoke", "spill"
    ])
    NUM_CLASSES: int = 6

    # ---------- 训练超参 ----------
    MODEL_BASE: str = "yolo26n.pt"   # YOLO26 主干（n/s/m/l/x 可选）
    EPOCHS: int = 150
    BATCH: int = 16
    IMG_SIZE: int = 640
    LR0: float = 0.01
    DEVICE: str = "0"                # "0" 表示 GPU0，"cpu" 表示 CPU
    WORKERS: int = 8
    PATIENCE: int = 30               # 早停

    # ---------- 推理参数 ----------
    CONF_THRES: float = 0.45
    IOU_THRES: float = 0.50
    MAX_DET: int = 100
    USE_HALF: bool = True            # FP16 半精度加速

    # ---------- 安全业务规则（单位：秒 / 像素比例） ----------
    UNATTENDED_TIMEOUT: float = 60.0   # 有火无人 持续多少秒 → 报警
    NO_POT_TIMEOUT: float = 20.0       # 有火无锅 持续多少秒 → 报警
    FLAME_LOST_TIMEOUT: float = 5.0    # 火意外熄灭（灶台在、无火）持续多久 → 报警
    SMOKE_ALARM_CONF: float = 0.55     # 烟雾报警置信度
    SPILL_ALARM_CONF: float = 0.50     # 溢锅报警置信度
    FRAME_SKIP: int = 1                # 隔帧推理（性能不足时增大）
    ALARM_COOLDOWN: float = 15.0       # 同一告警冷却时间，避免刷屏

    # ---------- 界面 ----------
    WINDOW_TITLE: str = "基于 YOLO26 的燃气灶具安全检测系统"
    WINDOW_SIZE: Tuple[int, int] = (1280, 800)
    VIDEO_SOURCE: str = "0"            # "0"=本地摄像头，或 rtsp://... 或 视频文件路径


CFG = Config()


# =============================================================================
# L2  数据层：数据集构建
# =============================================================================
class DatasetBuilder:
    """
    职责：
      1) 采集原始视频 → 抽帧
      2) 组织 LabelImg / Roboflow 标注结果（YOLO txt 格式）
      3) 数据增强（离线扩充）
      4) 生成 data.yaml
    """
    def __init__(self, cfg: Config = CFG):
        self.cfg = cfg

    # ---------- 2.1 视频抽帧 ----------
    def extract_frames(self, video_path: str, out_dir: str, fps_step: int = 10):
        """按固定帧间隔从视频中抽帧，保存为 jpg，用于人工标注。"""
        cap = cv2.VideoCapture(video_path)
        idx, saved = 0, 0
        WHILE cap.isOpened():
            ok, frame = cap.read()
            IF NOT ok: BREAK
            IF idx % fps_step == 0:
                cv2.imwrite(os.path.join(out_dir, f"frame_{saved:06d}.jpg"), frame)
                saved += 1
            idx += 1
        cap.release()
        RETURN saved

    # ---------- 2.2 划分训练/验证集 ----------
    def split_train_val(self, all_images: List[str], val_ratio: float = 0.2):
        """按比例随机划分 images/labels 到 train/val 目录。"""
        random.shuffle(all_images)
        n_val = int(len(all_images) * val_ratio)
        val_set, train_set = all_images[:n_val], all_images[n_val:]
        FOR img IN train_set: copy_image_and_label(img → IMAGES_TRAIN / LABELS_TRAIN)
        FOR img IN val_set:   copy_image_and_label(img → IMAGES_VAL   / LABELS_VAL)
        RETURN train_set, val_set

    # ---------- 2.3 离线数据增强 ----------
    def augment(self, image_dir: str, label_dir: str, times: int = 3):
        """
        对每张图做随机增强并同步变换标注框：
          - 亮度/对比度扰动（不改变框）
          - 水平翻转（x_center → 1 - x_center）
          - 随机缩放裁剪 + 框裁剪修正
          - 高斯噪声 / 运动模糊
        注意：燃气场景慎用垂直翻转、大角度旋转（火焰方向有物理意义）。
        """
        FOR img, lbl IN zip(image_dir, label_dir):
            FOR k IN range(times):
                aug_img, aug_lbl = random_augment(img, lbl)
                save(aug_img, aug_lbl)
        PASS

    # ---------- 2.4 生成 data.yaml ----------
    def build_data_yaml(self):
        data = {
            "path": self.cfg.DATASET_DIR,
            "train": "images/train",
            "val": "images/val",
            "nc": self.cfg.NUM_CLASSES,
            "names": self.cfg.CLASS_NAMES,
        }
        WITH open(self.cfg.DATA_YAML, "w", encoding="utf-8") as f:
            yaml.safe_dump(data, f, allow_unicode=True)
        RETURN self.cfg.DATA_YAML


# =============================================================================
# L3  训练层：YOLO26 训练 / 验证 / 导出
# =============================================================================
class Trainer:
    def __init__(self, cfg: Config = CFG):
        self.cfg = cfg
        from ultralytics import YOLO      # 伪代码：实际依赖 ultralytics
        self.model = YOLO(cfg.MODEL_BASE)

    def train(self):
        """调用 YOLO26 训练接口。"""
        results = self.model.train(
            data=self.cfg.DATA_YAML,
            epochs=self.cfg.EPOCHS,
            batch=self.cfg.BATCH,
            imgsz=self.cfg.IMG_SIZE,
            lr0=self.cfg.LR0,
            device=self.cfg.DEVICE,
            workers=self.cfg.WORKERS,
            patience=self.cfg.PATIENCE,
            project=os.path.join(self.cfg.ROOT_DIR, "runs"),
            name="yolo26_gas_stove",
            pretrained=True,
            # YOLO26 特性：端到端无 NMS 推理、DFL 移除、更轻量回归头
            end2end=True,
            close_mosaic=10,          # 最后 10 轮关闭 mosaic，稳定收敛
            plots=True,
        )
        RETURN results

    def validate(self, weight_path: str):
        """在验证集上评估 mAP50 / mAP50-95 / 各类别 P-R。"""
        m = YOLO(weight_path)
        metrics = m.val(data=self.cfg.DATA_YAML, imgsz=self.cfg.IMG_SIZE,
                        conf=0.001, iou=0.6, device=self.cfg.DEVICE)
        RETURN metrics

    def export(self, weight_path: str, fmt: str = "onnx"):
        """导出为 ONNX / TensorRT，便于部署到边缘盒子。"""
        m = YOLO(weight_path)
        RETURN m.export(format=fmt, imgsz=self.cfg.IMG_SIZE, half=self.cfg.USE_HALF)


# =============================================================================
# L4  推理层：检测引擎
# =============================================================================
@dataclass
class Detection:
    """单条检测结果。"""
    cls_id: int
    cls_name: str
    conf: float
    xyxy: Tuple[float, float, float, float]

    @property
    def center(self) -> Tuple[float, float]:
        x1, y1, x2, y2 = self.xyxy
        RETURN ((x1 + x2) / 2, (y1 + y2) / 2)

    @property
    def area(self) -> float:
        x1, y1, x2, y2 = self.xyxy
        RETURN max(0.0, x2 - x1) * max(0.0, y2 - y1)


class Detector:
    """
    职责：封装 YOLO26 推理，输出统一结构的 Detection 列表。
    支持：图片 / 视频帧 / 摄像头流；可选 ByteTrack 目标跟踪（保持 person ID 稳定）。
    """
    def __init__(self, cfg: Config = CFG, model_path: Optional[str] = None):
        self.cfg = cfg
        from ultralytics import YOLO
        self.model = YOLO(model_path or cfg.MODEL_PATH)
        self.names = self.model.names

    def infer(self, frame: np.ndarray, use_track: bool = False) -> List[Detection]:
        IF use_track:
            results = self.model.track(frame, persist=True,
                                       conf=self.cfg.CONF_THRES,
                                       iou=self.cfg.IOU_THRES,
                                       imgsz=self.cfg.IMG_SIZE,
                                       half=self.cfg.USE_HALF,
                                       tracker="bytetrack.yaml", verbose=False)
        ELSE:
            results = self.model.predict(frame,
                                         conf=self.cfg.CONF_THRES,
                                         iou=self.cfg.IOU_THRES,
                                         imgsz=self.cfg.IMG_SIZE,
                                         half=self.cfg.USE_HALF,
                                         max_det=self.cfg.MAX_DET,
                                         verbose=False)
        dets = []
        FOR r IN results:
            FOR box IN r.boxes:
                dets.append(Detection(
                    cls_id=int(box.cls),
                    cls_name=self.names[int(box.cls)],
                    conf=float(box.conf),
                    xyxy=tuple(box.xyxy[0].tolist()),
                ))
        RETURN dets

    @staticmethod
    def draw(frame: np.ndarray, dets: List[Detection], alarms: List[str]) -> np.ndarray:
        """在画面上绘制检测框、类别、置信度与当前告警文本。"""
        FOR d IN dets:
            color = COLOR_MAP.get(d.cls_name, (0, 255, 0))
            cv2.rectangle(frame, d.xyxy[:2], d.xyxy[2:], color, 2)
            cv2.putText(frame, f"{d.cls_name} {d.conf:.2f}",
                        (d.xyxy[0], d.xyxy[1] - 6), FONT, 0.6, color, 2)
        FOR i, msg IN enumerate(alarms):
            cv2.putText(frame, msg, (20, 40 + i * 32), FONT, 0.8, (0, 0, 255), 2)
        RETURN frame


# =============================================================================
# L5  业务层：燃气灶安全规则状态机
# =============================================================================
class SafetyAnalyzer:
    """
    核心业务：把"检测框"翻译成"安全结论"。

    空间关系判定（基于检测框几何）：
      - is_flame_on   : 存在 flame 且其中心落在某个 stove 框内（或下方距离阈值内）
      - has_pot       : 存在 pot 且其框与火焰框 IoU/包含关系成立
      - has_person    : 存在 person 且距灶台水平距离 < SAFE_DISTANCE_RATIO * 画幅宽
      - has_smoke     : smoke 置信度 > SMOKE_ALARM_CONF
      - has_spill     : spill 置信度 > SPILL_ALARM_CONF

    时间维度判定（状态机）：
      - 每个"异常条件"配一个计时器，条件持续成立超过阈值才真正报警；
      - 条件消失则计时器清零；
      - 报警后进入冷却期，避免逐帧重复弹窗。
    """
    def __init__(self, cfg: Config = CFG):
        self.cfg = cfg
        # 计时器：key = 告警类型, value = 条件首次成立的时间戳
        self.timers: Dict[str, float] = {}
        # 冷却：key = 告警类型, value = 上次报警时间
        self.last_alarm: Dict[str, float] = {}
        self.active_alarms: List[str] = []

    # ---------- 5.1 几何工具 ----------
    @staticmethod
    def _contains(outer: Tuple, inner: Tuple) -> bool:
        """inner 框中心是否落在 outer 框内。"""
        cx, cy = ((inner[0] + inner[2]) / 2, (inner[1] + inner[3]) / 2)
        RETURN outer[0] <= cx <= outer[2] and outer[1] <= cy <= outer[3]

    @staticmethod
    def _iou(a: Tuple, b: Tuple) -> float:
        """标准 IoU 计算。"""
        ...

    # ---------- 5.2 场景解析 ----------
    def parse_scene(self, dets: List[Detection], frame_shape) -> Dict:
        """把检测结果解析成场景语义字典。"""
        scene = {
            "stoves":  [d for d in dets if d.cls_name == "stove"],
            "flames":  [d for d in dets if d.cls_name == "flame"],
            "pots":    [d for d in dets if d.cls_name == "pot"],
            "persons": [d for d in dets if d.cls_name == "person"],
            "smokes":  [d for d in dets if d.cls_name == "smoke" and d.conf >= self.cfg.SMOKE_ALARM_CONF],
            "spills":  [d for d in dets if d.cls_name == "spill" and d.conf >= self.cfg.SPILL_ALARM_CONF],
        }
        h, w = frame_shape[:2]
        # 火焰是否在灶台上
        scene["flame_on_stove"] = [
            f for f in scene["flames"]
            IF any(self._contains(s.xyxy, f.xyxy) for s IN scene["stoves"])
        ]
        scene["is_cooking"] = len(scene["flame_on_stove"]) > 0
        # 锅具是否在火焰上
        scene["pot_on_fire"] = [
            p for p IN scene["pots"]
            IF any(self._contains(f.xyxy, p.xyxy) for f IN scene["flame_on_stove"])
        ]
        # 灶台附近是否有人（水平距离阈值）
        safe_dist = 0.5 * w
        scene["person_near"] = [
            p for p IN scene["persons"]
            IF any(abs(p.center[0] - s.center[0]) < safe_dist for s IN scene["stoves"])
        ]
        RETURN scene

    # ---------- 5.3 状态机主逻辑 ----------
    def _check_timer(self, key: str, condition: bool, timeout: float, now: float) -> bool:
        """
        通用计时器：
          condition=True  → 记录/延续计时，超过 timeout 返回 True（触发报警）
          condition=False → 清除计时，返回 False
        """
        IF NOT condition:
            self.timers.pop(key, None)
            RETURN False
        IF key NOT IN self.timers:
            self.timers[key] = now
        RETURN (now - self.timers[key]) >= timeout

    def analyze(self, dets: List[Detection], frame_shape) -> List[str]:
        """
        返回当前应触发的告警列表，元素示例：
            "【高危】灶台开火但长时间无人看管（>60s）"
            "【高危】灶台开火但未放置锅具（>20s，空烧风险）"
            "【警告】检测到烟雾，请立即检查"
            "【警告】检测到溢锅/液体溢出"
        """
        now = time.time()
        scene = self.parse_scene(dets, frame_shape)
        alarms: List[str] = []

        # 规则 1：开火 + 无人看管
        IF scene["is_cooking"]:
            IF self._check_timer("unattended",
                                 condition=(len(scene["person_near"]) == 0),
                                 timeout=self.cfg.UNATTENDED_TIMEOUT,
                                 now=now):
                alarms.append(f"【高危】灶台开火但无人看管（>{int(self.cfg.UNATTENDED_TIMEOUT)}s）")

            # 规则 2：开火 + 无锅（空烧）
            IF self._check_timer("no_pot",
                                 condition=(len(scene["pot_on_fire"]) == 0),
                                 timeout=self.cfg.NO_POT_TIMEOUT,
                                 now=now):
                alarms.append(f"【高危】灶台开火但未放置锅具（>{int(self.cfg.NO_POT_TIMEOUT)}s，空烧风险）")
        ELSE:
            self.timers.pop("unattended", None)
            self.timers.pop("no_pot", None)

        # 规则 3：有灶台但火焰意外熄灭（可能是溢锅灭火 / 燃气泄漏前兆）
        IF len(scene["stoves"]) > 0 AND len(scene["flames"]) == 0:
            IF self._check_timer("flame_lost", True, self.cfg.FLAME_LOST_TIMEOUT, now):
                alarms.append("【提示】检测到灶台但未检测到火焰，请确认是否意外熄火")
        ELSE:
            self.timers.pop("flame_lost", None)

        # 规则 4：烟雾
        IF len(scene["smokes"]) > 0:
            alarms.append("【警告】检测到烟雾，请立即检查")

        # 规则 5：溢锅
        IF len(scene["spills"]) > 0:
            alarms.append("【警告】检测到溢锅/液体溢出")

        # 冷却过滤
        filtered = []
        FOR a IN alarms:
            key = a[:6]   # 用前缀做冷却 key
            IF now - self.last_alarm.get(key, 0) >= self.cfg.ALARM_COOLDOWN:
                self.last_alarm[key] = now
                filtered.append(a)
        self.active_alarms = filtered
        RETURN filtered


# =============================================================================
# L6  界面层：PySide6 主窗口 + 视频线程 + 告警
# =============================================================================
from PySide6.QtCore import QThread, Signal, Qt, QTimer
from PySide6.QtGui import QImage, QPixmap, QFont
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QLabel, QPushButton, QVBoxLayout,
    QHBoxLayout, QListWidget, QFileDialog, QMessageBox, QGroupBox, QComboBox
)


class VideoThread(QThread):
    """
    视频采集 + 推理线程（避免阻塞 UI）。
    信号：
      frame_ready(QImage)          —— 已绘制检测框的画面
      detections_ready(list)       —— 检测结果（供统计面板）
      alarms_ready(list[str])      —— 本次触发的告警
      fps_ready(float)             —— 实时帧率
    """
    frame_ready = Signal(QImage)
    detections_ready = Signal(list)
    alarms_ready = Signal(list)
    fps_ready = Signal(float)

    def __init__(self, source: str, detector: Detector, analyzer: SafetyAnalyzer):
        super().__init__()
        self.source = source
        self.detector = detector
        self.analyzer = analyzer
        self.running = False

    def run(self):
        cap = cv2.VideoCapture(int(self.source) if self.source.isdigit() else self.source)
        self.running = True
        frame_idx, t0, fps = 0, time.time(), 0.0
        WHILE self.running AND cap.isOpened():
            ok, frame = cap.read()
            IF NOT ok: BREAK

            # 隔帧推理，降低算力占用
            IF frame_idx % CFG.FRAME_SKIP == 0:
                dets = self.detector.infer(frame, use_track=True)
                alarms = self.analyzer.analyze(dets, frame.shape)
                frame = Detector.draw(frame, dets, alarms)
                self.detections_ready.emit(dets)
                self.alarms_ready.emit(alarms)

            # 计算 FPS
            frame_idx += 1
            IF frame_idx % 10 == 0:
                fps = 10.0 / (time.time() - t0 + 1e-6)
                t0 = time.time()
                self.fps_ready.emit(fps)

            # ndarray(BGR) → QImage(RGB)
            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            h, w, _ = rgb.shape
            qimg = QImage(rgb.data, w, h, w * 3, QImage.Format_RGB888).copy()
            self.frame_ready.emit(qimg)

        cap.release()

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


class MainWindow(QMainWindow):
    """
    界面布局：
      ┌──────────────────────────────────────────────────────┐
      │ 顶部工具栏：模型选择 | 视频源 | 开始/暂停 | 截图        │
      ├───────────────────────────────┬──────────────────────┤
      │                               │  实时检测结果列表      │
      │        视频显示区              │  ─────────────────   │
      │        (QLabel)               │  告警日志列表          │
      │                               │  ─────────────────   │
      │                               │  统计：FPS / 各类计数   │
      ├───────────────────────────────┴──────────────────────┤
      │ 状态栏：模型信息 / 检测状态                             │
      └──────────────────────────────────────────────────────┘
    """
    def __init__(self):
        super().__init__()
        self.setWindowTitle(CFG.WINDOW_TITLE)
        self.resize(*CFG.WINDOW_SIZE)

        self.detector: Optional[Detector] = None
        self.analyzer = SafetyAnalyzer(CFG)
        self.video_thread: Optional[VideoThread] = None
        self.is_running = False

        self._build_ui()
        self._bind_signals()
        self._load_model(CFG.MODEL_PATH)

    # ---------- 6.1 构建界面 ----------
    def _build_ui(self):
        central = QWidget()
        self.setCentralWidget(central)

        # --- 视频显示 ---
        self.video_label = QLabel("视频未加载")
        self.video_label.setAlignment(Qt.AlignCenter)
        self.video_label.setMinimumSize(880, 620)
        self.video_label.setStyleSheet("background:#111; color:#888; font-size:18px;")

        # --- 顶部工具栏 ---
        self.btn_start   = QPushButton("开始检测")
        self.btn_stop    = QPushButton("停止")
        self.btn_open    = QPushButton("选择视频/摄像头")
        self.btn_snapshot= QPushButton("截图保存")
        self.combo_source= QComboBox(); self.combo_source.addItems(["摄像头 0", "摄像头 1", "本地视频"])
        self.combo_model = QComboBox(); self.combo_model.addItems(["yolo26n", "yolo26s", "yolo26m"])

        top_bar = QHBoxLayout()
        FOR w IN [self.combo_model, self.combo_source, self.btn_open,
                  self.btn_start, self.btn_stop, self.btn_snapshot]:
            top_bar.addWidget(w)

        # --- 右侧信息面板 ---
        box_det  = QGroupBox("实时检测结果")
        self.list_det = QListWidget()
        QVBoxLayout(box_det).addWidget(self.list_det)

        box_alarm = QGroupBox("安全告警日志")
        self.list_alarm = QListWidget()
        self.list_alarm.setStyleSheet("QListWidget{color:#c00; font-weight:bold;}")
        QVBoxLayout(box_alarm).addWidget(self.list_alarm)

        self.lbl_stat = QLabel("FPS: --\n目标数: --")
        self.lbl_stat.setFont(QFont("Consolas", 11))

        right = QVBoxLayout()
        right.addWidget(box_det, 3)
        right.addWidget(box_alarm, 3)
        right.addWidget(self.lbl_stat, 1)

        # --- 整体布局 ---
        body = QHBoxLayout()
        body.addWidget(self.video_label, 7)
        body.addLayout(right, 3)

        main_layout = QVBoxLayout(central)
        main_layout.addLayout(top_bar)
        main_layout.addLayout(body)

        self.statusBar().showMessage("就绪")

    # ---------- 6.2 信号绑定 ----------
    def _bind_signals(self):
        self.btn_open.clicked.connect(self.on_open_source)
        self.btn_start.clicked.connect(self.on_start)
        self.btn_stop.clicked.connect(self.on_stop)
        self.btn_snapshot.clicked.connect(self.on_snapshot)

    # ---------- 6.3 加载模型 ----------
    def _load_model(self, path: str):
        TRY:
            self.detector = Detector(CFG, path)
            self.statusBar().showMessage(f"模型已加载：{path}")
        EXCEPT Exception as e:
            QMessageBox.critical(self, "模型加载失败", str(e))
            self.detector = None

    # ---------- 6.4 选择视频源 ----------
    def on_open_source(self):
        IF self.combo_source.currentText().startswith("摄像头"):
            CFG.VIDEO_SOURCE = self.combo_source.currentText().split()[-1]
        ELSE:
            path, _ = QFileDialog.getOpenFileName(
                self, "选择视频文件", "", "视频文件 (*.mp4 *.avi *.mkv *.mov)")
            IF path: CFG.VIDEO_SOURCE = path
        self.statusBar().showMessage(f"视频源：{CFG.VIDEO_SOURCE}")

    # ---------- 6.5 开始 / 停止 ----------
    def on_start(self):
        IF self.is_running: RETURN
        IF self.detector IS None:
            QMessageBox.warning(self, "提示", "请先加载模型权重"); RETURN

        self.video_thread = VideoThread(CFG.VIDEO_SOURCE, self.detector, self.analyzer)
        self.video_thread.frame_ready.connect(self.update_frame)
        self.video_thread.detections_ready.connect(self.update_detections)
        self.video_thread.alarms_ready.connect(self.update_alarms)
        self.video_thread.fps_ready.connect(self.update_fps)
        self.video_thread.start()

        self.is_running = True
        self.statusBar().showMessage("检测中…")

    def on_stop(self):
        IF self.video_thread:
            self.video_thread.stop()
        self.is_running = False
        self.statusBar().showMessage("已停止")

    # ---------- 6.6 槽函数 ----------
    def update_frame(self, qimg: QImage):
        """刷新画面。"""
        pix = QPixmap.fromImage(qimg).scaled(
            self.video_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
        self.video_label.setPixmap(pix)

    def update_detections(self, dets: List[Detection]):
        """刷新检测列表与统计。"""
        self.list_det.clear()
        counter: Dict[str, int] = {}
        FOR d IN dets:
            counter[d.cls_name] = counter.get(d.cls_name, 0) + 1
            self.list_det.addItem(f"{d.cls_name:<8s} conf={d.conf:.2f}  "
                                  f"xyxy={tuple(round(v) for v in d.xyxy)}")
        stat_text = "\n".join(f"{k}: {v}" for k, v in counter.items()) or "无目标"
        self.lbl_stat.setText(f"{self.lbl_stat.text().splitlines()[0]}\n{stat_text}")

    def update_alarms(self, alarms: List[str]):
        """刷新告警列表 + 弹窗 + 声音提示。"""
        FOR a IN alarms:
            ts = time.strftime("%H:%M:%S")
            self.list_alarm.insertItem(0, f"[{ts}] {a}")
            self._popup_alarm(a)
            self._play_beep()

    def update_fps(self, fps: float):
        lines = self.lbl_stat.text().splitlines()
        lines[0] = f"FPS: {fps:.1f}"
        self.lbl_stat.setText("\n".join(lines))

    # ---------- 6.7 告警提示 ----------
    def _popup_alarm(self, msg: str):
        """高危告警弹窗（非模态，避免阻塞视频线程）。"""
        IF "高危" IN msg:
            box = QMessageBox(self)
            box.setIcon(QMessageBox.Warning)
            box.setWindowTitle("安全告警")
            box.setText(msg)
            box.setStandardButtons(QMessageBox.Ok)
            box.setModal(False)
            box.show()

    def _play_beep(self):
        """调用系统蜂鸣 / 播放 wav 告警音。"""
        TRY:
            import winsound
            winsound.Beep(1000, 300)     # Windows
        EXCEPT:
            print("\a")                  # 跨平台兜底

    # ---------- 6.8 截图 ----------
    def on_snapshot(self):
        IF self.video_label.pixmap() IS None: RETURN
        path, _ = QFileDialog.getSaveFileName(
            self, "保存截图", f"snapshot_{int(time.time())}.jpg", "图片 (*.jpg *.png)")
        IF path:
            self.video_label.pixmap().save(path)
            self.statusBar().showMessage(f"已保存：{path}")

    # ---------- 6.9 关闭事件 ----------
    def closeEvent(self, event):
        self.on_stop()
        event.accept()


# =============================================================================
# 主入口
# =============================================================================
def main():
    """
    运行模式：
       python main.py train      → 训练模型
       python main.py val        → 验证模型
       python main.py export     → 导出 ONNX
       python main.py            → 启动 GUI 检测系统
    """
    import sys
    mode = sys.argv[1] if len(sys.argv) > 1 else "gui"

    IF mode == "train":
        Trainer(CFG).train()
    ELIF mode == "val":
        Trainer(CFG).validate(CFG.MODEL_PATH)
    ELIF mode == "export":
        Trainer(CFG).export(CFG.MODEL_PATH, fmt="onnx")
    ELIF mode == "dataset":
        DatasetBuilder(CFG).build_data_yaml()
    ELSE:
        app = QApplication(sys.argv)
        win = MainWindow()
        win.show()
        sys.exit(app.exec())


IF __name__ == "__main__":
    main()


# =============================================================================
# 附：完整工程目录结构建议
# =============================================================================
"""
gas_stove_safety/
├── main.py                     # 本文件（入口 + 伪代码全流程）
├── config.py                   # Config 拆分出去
├── dataset_builder.py          # DatasetBuilder
├── trainer.py                  # Trainer
├── detector.py                 # Detector + Detection
├── safety_analyzer.py          # SafetyAnalyzer（规则状态机）
├── ui/
│   ├── main_window.py          # MainWindow
│   ├── video_thread.py         # VideoThread
│   └── resources/              # 图标、告警音
├── datasets/gas_stove/
│   ├── images/{train,val}/
│   ├── labels/{train,val}/
│   └── data.yaml
├── weights/yolo26_gas_stove.pt
├── runs/                       # 训练输出
├── logs/                       # 告警日志（jsonl）
└── requirements.txt            # ultralytics, torch, opencv-python, PySide6, pyyaml
"""

pip install --upgrade pip
pip install pyside6 -i https://mirror.baidu.com/pypi/simple

​pip install --upgrade pip
pip install pyside6 -i https://mirror.baidu.com/pypi/simple