hookvision-rk/hookvision/main_window.py

import os
import sys
import time
import re
import logging
import threading
import queue
import subprocess
from concurrent.futures import ThreadPoolExecutor
from collections import defaultdict
from PySide6.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
                               QPushButton, QLabel, QGridLayout, QScrollArea,
                               QToolButton, QFrame, QApplication, QCheckBox,
                               QMessageBox, QSlider)
from PySide6.QtCore import Qt, QTimer, QSize, Signal
from PySide6.QtGui import QIcon, QPixmap, QResizeEvent, QKeyEvent, QCloseEvent
from .models import *
from .rtsp_player import RTSPPlayer
from .rfid_client import RFIDClient
from .modbus_client import ModbusClient
from .mqtt_client import MQTTClient

logger = logging.getLogger(__name__)

class MainWindow(QMainWindow):
    # 防抖阈值（连续相同状态次数）
    STATE_THRESHOLD = 3
    # 放包判断位移阈值（像素）
    RELEASE_DELTA_THRESHOLD = 5
    # 轨迹阶段判断阈值（像素）
    RELEASE_TRAJ_Y = 8
    ASCEND_TRAJ_Y = 6
    SEPARATE_TRAJ_DIST = 15
    ENGAGE_DIST = 40
    # 命中放包/分离后屏蔽语音的顺延秒数
    SUPPRESS_SECONDS = 8
    # 上升 ready 补全：连续命中帧数防抖 + 命中后锁存秒数
    ASCEND_DEBOUNCE = 2
    ASCEND_LATCH_SECS = 3.0
    # READY 粘滞：失去信号后保持绿色的秒数（防红绿来回跳）
    READY_HOLD_SECS = 2.0
    # 轨迹窗口：保留最近 2 秒 / 最多 30 帧
    TRAJ_WINDOW_SECS = 2.0
    TRAJ_MAX_FRAMES = 30
    # MQTT 消息超时（秒）后清除残留画框
    MQTT_CLEAR_TIMEOUT = 1
    APPTITLE = "HookVision"

    # 跨线程信号
    rfid_tag_signal = Signal(object)
    rfid_state_signal = Signal(object)
    modbus_data_signal = Signal(object)
    mqtt_message_signal = Signal(str, object)
    voice_signal = Signal(str)
    camera_signal_signal = Signal(dict)

    def __init__(self, config: Config, config_path: str = ""):
        super().__init__()
        self.config = config
        self._config_path = config_path
        self.buckets = config.buckets
        self.active_bucket: BucketModel = None
        self.switch_mode = SwitchMode.AUTO
        self._subscribed_topics: set = set()
        self._current_ai_module_id: Optional[int] = None

        self.left_player: RTSPPlayer = None
        self.right_player: RTSPPlayer = None

        self.rfid_client = None
        self.modbus_client = None
        self.mqtt_client = None
        self._last_rfid_tag: Optional[str] = None

        self.video_aspect_ratio = 16 / 9
        self._ratio_16_9 = config.video.ratio_16_9
        self.left_label = None
        self.right_label = None

        # 挂钩状态相关
        self.hook_state = HookState.IDLE
        self.prev_state = HookState.IDLE
        self.state_counter = 0

        # 存储左右画面最近检测对象
        self.left_objects = []
        self.right_objects = []
        # 前一帧 hook/lug 中心位置（用于轨迹判断）
        self.prev_left_hook = None
        self.prev_right_hook = None
        self.prev_left_lug = None
        self.prev_right_lug = None

        # 配对轨迹（每侧：{t, hook_cx, hook_cy, lug_cx, lug_cy, dist}），用于放包/分离检测与画线
        self._pair_traj: dict = {"left": [], "right": []}
        # 放包/分离期间屏蔽 挂包中/挂包成功 语音的截止时间
        self._voice_suppress_until: float = 0.0
        # 当前叠加显示的阶段（放包/分离/空）
        self._trace_phase: str = ""
        # 上升 ready 补全的防抖计数与锁存截止
        self._ascend_frames: int = 0
        self._ascend_latch_until: float = 0.0
        # READY 粘滞保持截止（信号短暂丢失时保持绿色）
        self._ready_hold_until: float = 0.0
        self.debug_trace = getattr(config.ai, 'debug_trace', True)
        # MQTT 消息超时后是否已清除画框（防重复清空）
        self._overlay_cleared = False

        # 语音引擎（在工作线程内初始化）
        self.last_voice_state = None
        self._last_hooking_voice_time = 0.0
        self._ready_traces: dict = {}  # track_id → [(cx, cy, time), ...]
        self.voice_enabled = True
        self._voice_volume = 100
        self.ai_enabled = True
        self._last_left_draw: list = []
        self._last_right_draw: list = []
        self._voice_queue = queue.Queue(maxsize=32)
        self._voice_thread = threading.Thread(target=self._voice_worker, daemon=True)
        self._voice_thread.start()
        self._voices_dir = self._get_voices_dir()
        self._use_tts = self.config.ai.tts_enabled

        # RTSP 退避重连
        self._rtsp_retry_left: Optional[QTimer] = None
        self._rtsp_retry_right: Optional[QTimer] = None
        self._rtsp_retry_delay_left: int = 1
        self._rtsp_retry_delay_right: int = 1
        self._last_mqtt_connect_attempt: float = 0.0
        self._last_mqtt_process: float = 0.0

        # 摄像头信号监控
        self._camera_signal: dict = {}  # ip → 延迟(ms), -1=不可达
        self._bucket_signal_labels: dict = {}  # bucket.id → QLabel
        self._last_signal_check: float = 0.0
        self._signal_check_thread: threading.Thread = None
        self._offline_reported: set = set()  # 已播报离线的 IP

        # 连接跨线程信号到主线程槽
        self.rfid_tag_signal.connect(self._on_rfid_tag_impl)
        self.rfid_state_signal.connect(self._on_rfid_state_impl)
        self.modbus_data_signal.connect(self._on_modbus_data_impl)
        self.mqtt_message_signal.connect(self._on_mqtt_message_impl)
        self.voice_signal.connect(self._speak_impl)
        self.camera_signal_signal.connect(self._on_camera_signal)

        self.setWindowTitle(config.app_name)
        logo_path = os.path.join(os.path.dirname(__file__), "..", "assets", "logo.png")
        if os.path.exists(logo_path):
            self.setWindowIcon(QIcon(logo_path))

        screen = QApplication.primaryScreen()
        screen_geometry = screen.availableGeometry()
        screen_width = screen_geometry.width()
        screen_height = screen_geometry.height()
        window_width = int(screen_width * 0.9)
        window_height = int(screen_height * 0.85)
        x = (screen_width - window_width) // 2
        y = (screen_height - window_height) // 2
        self.setGeometry(x, y, window_width, window_height)
        self.setMinimumSize(800, 600)

        self.setup_ui()

        self.showFullScreen()
        self.update_video_size()
        self.init_hardware()
        self._started = True

        self.timer = QTimer()
        self.timer.timeout.connect(self.check_idle)
        self.timer.start(1000)

    def setup_ui(self):
        central = QWidget()
        self.setCentralWidget(central)
        main_layout = QVBoxLayout(central)
        main_layout.setContentsMargins(10, 10, 10, 10)
        main_layout.setSpacing(10)

        # 标题栏
        title_widget = QWidget()
        title_layout = QHBoxLayout(title_widget)
        title_layout.setContentsMargins(0, 0, 0, 0)
        logo_path = os.path.join(os.path.dirname(__file__), "..", "assets", "logo.png")
        if os.path.exists(logo_path):
            logo_label = QLabel()
            logo_pixmap = QPixmap(logo_path).scaled(28, 28, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            logo_label.setPixmap(logo_pixmap)
            logo_label.setFixedSize(28, 28)
            title_layout.addWidget(logo_label)
        self.title_label = QLabel(self.config.app_name)
        self.title_label.setStyleSheet("font-size: 22px; font-weight: bold; padding: 5px;")
        title_layout.addWidget(self.title_label)
        title_layout.addStretch()

        btn_style = """
            QPushButton {
                background-color: transparent;
                border: none;
                font-size: 18px;
                padding: 6px 12px;
                border-radius: 5px;
            }
            QPushButton:hover {
                background-color: rgba(255, 255, 255, 0.1);
            }
        """
        self.min_btn = QPushButton("—")
        self.min_btn.setStyleSheet(btn_style)
        self.min_btn.clicked.connect(self.showMinimized)
        self.fullscreen_btn = QPushButton("⛶")
        self.fullscreen_btn.setStyleSheet(btn_style)
        self.fullscreen_btn.setToolTip("全屏 / 还原")
        self.fullscreen_btn.clicked.connect(self._toggle_fullscreen)
        self.close_btn = QPushButton("✕")
        self.close_btn.setStyleSheet(btn_style)
        self.close_btn.clicked.connect(self.close)

        title_layout.addWidget(self.min_btn)
        title_layout.addWidget(self.fullscreen_btn)
        title_layout.addWidget(self.close_btn)
        main_layout.addWidget(title_widget)

        # 工位区域
        bucket_group = QFrame()
        bucket_group.setStyleSheet("QFrame { border-radius: 8px; padding: 8px; }")
        bucket_layout = QVBoxLayout(bucket_group)

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setFrameShape(QFrame.NoFrame)
        scroll_area.setStyleSheet("QScrollArea { background: transparent; border: none; }")

        self.bucket_container = QWidget()
        self.bucket_grid = QGridLayout(self.bucket_container)
        self.bucket_grid.setSpacing(15)
        self.bucket_grid.setContentsMargins(10, 10, 10, 10)
        self.bucket_grid.setAlignment(Qt.AlignLeft | Qt.AlignTop)

        # 按 code_x 分组纵向排列
        groups = defaultdict(list)
        for bucket in self.buckets:
            groups[bucket.code_x].append(bucket)

        sorted_keys = sorted(groups.keys())
        self.bucket_buttons = []

        col = 0
        for key in sorted_keys:
            buckets_in_group = groups[key]
            for row, bucket in enumerate(buckets_in_group):
                cell = QWidget()
                cell_layout = QVBoxLayout(cell)
                cell_layout.setContentsMargins(0, 0, 0, 0)
                cell_layout.setSpacing(2)

                btn = QToolButton()
                btn.setFixedSize(100, 100)
                btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
                btn.setText(bucket.description)
                btn.setIcon(self.get_bucket_icon(bucket.is_active))
                btn.setIconSize(QSize(64, 64))
                btn.setStyleSheet("""
                    QToolButton {
                        border-radius: 12px;
                        font-size: 14px;
                        font-weight: bold;
                    }
                """)
                btn.clicked.connect(lambda checked, b=bucket: self.on_bucket_clicked(b))
                cell_layout.addWidget(btn)

                # 摄像头信号指示条（左右两段）
                bar = QWidget()
                bar.setFixedHeight(8)
                bar_layout = QHBoxLayout(bar)
                bar_layout.setContentsMargins(0, 0, 0, 0)
                bar_layout.setSpacing(2)
                left_bar = QFrame()
                right_bar = QFrame()
                for fb in (left_bar, right_bar):
                    fb.setFixedHeight(8)
                    fb.setStyleSheet("background-color: #dcdfe6; border-radius: 2px;")
                bar_layout.addWidget(left_bar)
                bar_layout.addWidget(right_bar)
                cell_layout.addWidget(bar)
                self._bucket_signal_labels[bucket.id] = (left_bar, right_bar)

                self.bucket_grid.addWidget(cell, row, col)
                self.bucket_buttons.append((btn, bucket))
            col += 1

        self.bucket_container.setLayout(self.bucket_grid)
        scroll_area.setWidget(self.bucket_container)
        bucket_layout.addWidget(scroll_area)
        main_layout.addWidget(bucket_group)

        # 视频区域（仅保留边框）
        video_container = QWidget()
        video_layout = QHBoxLayout(video_container)
        video_layout.setSpacing(15)
        video_layout.setContentsMargins(0, 0, 0, 0)

        self.left_label = QLabel("左侧画面")
        self.left_label.setScaledContents(False)
        self.left_label.setAlignment(Qt.AlignCenter)
        self.left_label.setStyleSheet("""
            QLabel {
                border: 2px solid #dcdfe6;
                border-radius: 8px;
                background-color: black;
            }
        """)
        self.right_label = QLabel("右侧画面")
        self.right_label.setScaledContents(False)
        self.right_label.setAlignment(Qt.AlignCenter)
        self.right_label.setStyleSheet("""
            QLabel {
                border: 2px solid #dcdfe6;
                border-radius: 8px;
                background-color: black;
            }
        """)

        video_layout.addWidget(self.left_label)
        video_layout.addWidget(self.right_label)
        main_layout.addWidget(video_container, 1)

        # 状态栏
        status_widget = QWidget()
        status_layout = QHBoxLayout(status_widget)
        status_layout.setContentsMargins(5, 5, 15, 5)

        self.module_status = QLabel("通讯状态: 初始化")
        self.module_status.setStyleSheet("color: #606266; font-weight: bold;")
        self.rfid_tag_label = QLabel("当前卡号: 无")
        self.rfid_tag_label.setStyleSheet("color: #409eff; font-weight: bold; margin-left: 20px;")

        self.hook_status_label = QLabel("挂钩状态: 空闲")
        self.hook_status_label.setStyleSheet("color: #ffa500; font-weight: bold; margin-left: 20px;")

        self.voice_checkbox = QCheckBox("语音播报")
        self.voice_checkbox.setChecked(True)
        self.voice_checkbox.setStyleSheet("color: #606266; font-weight: bold;")
        self.voice_checkbox.stateChanged.connect(self.on_voice_toggle)

        self.tts_checkbox = QCheckBox("TTS语音")
        self.tts_checkbox.setChecked(self._use_tts)
        self.tts_checkbox.setStyleSheet("color: #606266; font-weight: bold;")
        self.tts_checkbox.toggled.connect(self._on_tts_toggle)

        self.volume_btn = QPushButton(f"音量 {self._voice_volume}%")
        self.volume_btn.setFixedWidth(80)
        self.volume_btn.setStyleSheet("""
            QPushButton {
                color: #606266; font-weight: bold; font-size: 12px;
                border: 1px solid #dcdfe6; border-radius: 4px;
                padding: 2px 6px; background: transparent;
            }
            QPushButton:hover { border-color: #409eff; color: #409eff; }
        """)
        self.volume_btn.clicked.connect(self._show_volume_popup)

        self.ai_checkbox = QCheckBox("AI启用")
        self.ai_checkbox.setChecked(True)
        self.ai_checkbox.setStyleSheet("color: #606266; font-weight: bold;")
        self.ai_checkbox.stateChanged.connect(self.on_ai_toggle)

        self.auto_switch_btn = QCheckBox("自动模式")
        self.auto_switch_btn.setChecked(True)
        self.auto_switch_btn.setStyleSheet("color: #606266; font-weight: bold;")
        self.auto_switch_btn.clicked.connect(self.toggle_switch_mode)

        self.autostart_checkbox = QCheckBox("开机自启")
        self.autostart_checkbox.setChecked(self._read_autostart_flag())
        self.autostart_checkbox.setStyleSheet("color: #606266; font-weight: bold; margin-left: 10px;")
        self.autostart_checkbox.stateChanged.connect(self._on_autostart_toggle)

        status_layout.addWidget(self.module_status)
        status_layout.addWidget(self.rfid_tag_label)
        status_layout.addWidget(self.hook_status_label)
        status_layout.addStretch()
        status_layout.addWidget(self.voice_checkbox)
        status_layout.addWidget(self.tts_checkbox)
        status_layout.addWidget(self.volume_btn)
        status_layout.addWidget(self.ai_checkbox)
        status_layout.addWidget(self.auto_switch_btn)
        status_layout.addWidget(self.autostart_checkbox)
        self.ratio_btn = QPushButton("16:9" if self._ratio_16_9 else "4:3")
        self.ratio_btn.setStyleSheet("background:transparent; border:none; color:#606266; font-weight:bold; padding:4px 8px;")
        self.ratio_btn.setToolTip("切换画面比例 16:9 / 4:3")
        self.ratio_btn.clicked.connect(self._toggle_aspect_ratio)
        status_layout.addWidget(self.ratio_btn)
        main_layout.addWidget(status_widget)

        self.update_video_size()

    # ---------- 事件与资源管理 ----------
    def closeEvent(self, event: QCloseEvent):
        self._cancel_rtsp_retry("left")
        self._cancel_rtsp_retry("right")
        if self.rfid_client:
            self.rfid_client.disconnect()
        if self.modbus_client:
            self.modbus_client.disconnect()
        if self.mqtt_client:
            self.mqtt_client.disconnect()
        if self.left_player:
            self.left_player.stop()
        if self.right_player:
            self.right_player.stop()
        event.accept()

    # ---------- 语音控制 ----------
    def on_voice_toggle(self, state):
        self.voice_enabled = (state == Qt.Checked)

    def _on_tts_toggle(self):
        self._use_tts = self.tts_checkbox.isChecked()
        self.config.ai.tts_enabled = self._use_tts
        try:
            self._save_config()
        except Exception as e:
            logger.warning(f"保存 TTS 设置失败: {e}")

    def _on_volume_changed(self, value: int):
        self._voice_volume = value
        self.volume_btn.setText(f"音量 {value}%")

    def _preview_volume(self, vol: int):
        self._voice_volume = vol
        self.volume_btn.setText(f"音量 {vol}%")
        if not hasattr(self, '_preview_timer'):
            self._preview_timer = QTimer()
            self._preview_timer.setSingleShot(True)
            self._preview_timer.timeout.connect(lambda: self._speak("挂包中"))
        self._preview_timer.start(300)

    def _show_volume_popup(self):
        from PySide6.QtWidgets import QDialog, QVBoxLayout
        from PySide6.QtCore import Qt
        dlg = QDialog(self)
        dlg.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint)
        dlg.setStyleSheet("background: #2c2c2c; border: 1px solid #555; border-radius: 6px;")
        layout = QVBoxLayout(dlg)
        layout.setContentsMargins(12, 8, 12, 8)
        slider = QSlider(Qt.Horizontal)
        slider.setRange(0, 100)
        slider.setValue(self._voice_volume)
        slider.setFixedWidth(160)
        slider.setStyleSheet("""
            QSlider::groove:horizontal { height: 4px; background: #555; border-radius: 2px; }
            QSlider::handle:horizontal { width: 14px; margin: -5px 0; border-radius: 7px; background: #409eff; }
            QSlider::sub-page:horizontal { background: #409eff; border-radius: 2px; }
        """)
        slider.valueChanged.connect(self._preview_volume)
        layout.addWidget(slider)
        dlg.adjustSize()
        btn_global = self.volume_btn.mapToGlobal(self.volume_btn.rect().topLeft())
        dlg.move(btn_global.x(), btn_global.y() - dlg.height() - 4)
        dlg.exec()

    def on_ai_toggle(self, state):
        enabled = (state == Qt.Checked)
        if enabled == self.ai_enabled:
            return
        self.ai_enabled = enabled
        if enabled and not self.mqtt_client:
            self.mqtt_client = MQTTClient(self.on_mqtt_message)
            self._connect_current_ai()
        elif not enabled and self.mqtt_client:
            self.mqtt_client.disconnect()
            self.mqtt_client = None
            self._subscribed_topics.clear()
            self._current_ai_module_id = None
        if not enabled:
            self.hook_state = HookState.IDLE
            self.prev_state = HookState.IDLE
            self.state_counter = 0
            self.left_objects = []
            self.right_objects = []
            self.prev_left_hook = None
            self.prev_right_hook = None
            self.prev_left_lug = None
            self.prev_right_lug = None
            self._pair_traj = {"left": [], "right": []}
            self._voice_suppress_until = 0.0
            self._trace_phase = ""
            self._ascend_frames = 0
            self._ascend_latch_until = 0.0
            self._ready_hold_until = 0.0
            self.update_ui_for_state(HookState.IDLE)
        self._last_left_draw = []
        self._last_right_draw = []
        if self.left_player:
            self.left_player.set_ai_objects([])
        if self.right_player:
            self.right_player.set_ai_objects([])
        else:
            if self.left_player and self._last_left_draw:
                self.left_player.set_ai_objects(self._last_left_draw)
            if self.right_player and self._last_right_draw:
                self.right_player.set_ai_objects(self._last_right_draw)

    def _speak(self, msg: str):
        self.voice_signal.emit(msg)

    def _speak_impl(self, msg: str):
        try:
            self._voice_queue.put_nowait(msg)
        except queue.Full:
            pass

    @staticmethod
    def _get_voices_dir() -> str:
        if getattr(sys, 'frozen', False):
            base = sys._MEIPASS
        else:
            base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        return os.path.join(base, "assets", "voices")

    def _voice_msg_to_path(self, msg: str) -> str:
        mapping = {"挂包中": "hooking", "挂包成功": "ready", "放包中": "releasing",
                   "读卡器离线": "offline_reader", "左侧摄像头离线": "offline_cam_left",
                   "右侧摄像头离线": "offline_cam_right"}
        if msg in mapping:
            return os.path.join(self._voices_dir, f"{mapping[msg]}.wav")
        m = re.search(r'到达(\d+)号工位', msg)
        if m:
            return os.path.join(self._voices_dir, f"arrive_{m.group(1)}.wav")
        return ""

    def _voice_worker(self):
        try:
            import pythoncom
            pythoncom.CoInitialize()
        except Exception:
            pass
        speaker = None
        try:
            import win32com.client as _win32com
            speaker = _win32com.Dispatch("SAPI.SpVoice")
            speaker.Rate = 2
        except Exception:
            logging.warning("SAPI 不可用，仅可使用 WAV 语音")
        while True:
            msg = self._voice_queue.get()
            if msg is None:
                break
            try:
                if self._use_tts and speaker is not None:
                    speaker.Volume = self._voice_volume
                    speaker.Speak(msg)
                else:
                    self._play_wav(msg)
            except Exception as e:
                logging.warning(f"语音播报失败: {e}")
            self._voice_queue.task_done()

    def _play_wav(self, msg: str):
        path = self._voice_msg_to_path(msg)
        if not path:
            return
        import struct, wave, io, winsound
        try:
            with wave.open(path, 'rb') as wf:
                params = wf.getparams()
                raw = bytearray(wf.readframes(wf.getnframes()))
            gain = self._voice_volume / 100.0
            if params.sampwidth == 2:
                fmt = '<' + 'h' * (len(raw) // 2)
                samples = list(struct.unpack_from(fmt, bytes(raw)))
                samples = [max(-32768, min(32767, int(s * gain))) for s in samples]
                raw = bytearray(struct.pack(fmt, *samples))
            elif params.sampwidth == 1:
                samples = list(raw)
                samples = [max(0, min(255, int((s - 128) * gain) + 128)) for s in samples]
                raw = bytearray(samples)
            buf = io.BytesIO()
            with wave.open(buf, 'wb') as wf:
                wf.setparams(params)
                wf.writeframes(bytes(raw))
            winsound.PlaySound(buf.getvalue(), winsound.SND_MEMORY)
        except Exception:
            winsound.PlaySound(path, winsound.SND_FILENAME | winsound.SND_ASYNC)

    # ---------- 工位图标 ----------
    def get_bucket_icon(self, is_active):
        icon_dir = os.path.join(os.path.dirname(__file__), "..", "assets")
        if not os.path.exists(icon_dir):
            os.makedirs(icon_dir, exist_ok=True)
            return QIcon()
        if is_active:
            icon_path = os.path.join(icon_dir, "bucket_active.svg")
        else:
            icon_path = os.path.join(icon_dir, "bucket_normal.svg")
        if os.path.exists(icon_path):
            return QIcon(icon_path)
        else:
            pixmap = QPixmap(64, 64)
            pixmap.fill(Qt.green if is_active else Qt.gray)
            return QIcon(pixmap)

    def refresh_bucket_icons(self):
        for btn, bucket in self.bucket_buttons:
            icon = self.get_bucket_icon(bucket.is_active)
            btn.setIcon(icon)
            if bucket.is_active:
                btn.setStyleSheet("""
                    QToolButton {
                        background-color: #e1f3d8;
                        border: 2px solid #67c23a;
                        border-radius: 12px;
                        font-size: 14px;
                        font-weight: bold;
                        color: #1f2d3d;
                    }
                """)
            else:
                btn.setStyleSheet("""
                    QToolButton {
                        background-color: transparent;
                        border: 2px solid #d0d7de;
                        border-radius: 12px;
                        font-size: 14px;
                        font-weight: bold;
                        color: #1f2d3d;
                    }
                    QToolButton:hover {
                        background-color: rgba(0, 0, 0, 0.05);
                        border-color: #409eff;
                    }
                """)

    # ---------- 视频尺寸自适应 ----------
    def update_video_size(self):
        if not self.left_label or not self.right_label:
            return
        container = self.left_label.parentWidget()
        if not container:
            return
        available_width = container.width() - 15
        single_width = available_width // 2
        target_height = int(single_width / (16/9 if self._ratio_16_9 else 4/3))
        if target_height > container.height():
            target_height = container.height()
        self.left_label.setFixedSize(single_width, target_height)
        self.right_label.setFixedSize(single_width, target_height)

    def update_players_target_size(self):
        if self.left_player:
            self.left_player.set_target_size(self.left_label.width(), self.left_label.height())
        if self.right_player:
            self.right_player.set_target_size(self.right_label.width(), self.right_label.height())

    def resizeEvent(self, event: QResizeEvent):
        self.update_video_size()
        self.update_players_target_size()
        super().resizeEvent(event)

    def keyPressEvent(self, event: QKeyEvent):
        if event.key() == Qt.Key_Escape and self.isFullScreen():
            self.showNormal()
        elif event.key() == Qt.Key_F11:
            if self.isFullScreen():
                self.showNormal()
            else:
                self.showFullScreen()
        else:
            super().keyPressEvent(event)

    def _toggle_fullscreen(self):
        if self.isFullScreen():
            self.showNormal()
        else:
            self.showFullScreen()

    def _toggle_aspect_ratio(self):
        self._ratio_16_9 = not self._ratio_16_9
        self.ratio_btn.setText("16:9" if self._ratio_16_9 else "4:3")
        self.update_video_size()
        self.update_players_target_size()
        self._save_config()

    # ---------- 加载动画和超时 ----------
    def show_loading_on_label(self, label: QLabel):
        label.setText("加载中...")
        label.setAlignment(Qt.AlignCenter)
        label.setStyleSheet(label.styleSheet() + "color: white; font-size: 20px;")

    def hide_loading_on_label(self, label: QLabel):
        label.setText("")
        label.setStyleSheet("""
            QLabel {
                border: 2px solid #dcdfe6;
                border-radius: 8px;
                background-color: black;
            }
        """)

    def show_timeout_on_label(self, label: QLabel):
        label.setText("连接超时")
        label.setAlignment(Qt.AlignCenter)
        label.setStyleSheet(label.styleSheet() + "color: red; font-size: 20px;")

    def on_player_timeout(self, label: QLabel, player_ref, side: str):
        self.show_timeout_on_label(label)
        # 只停止当前活动的播放器（防止旧信号误杀新播放器）
        if side == "left" and self.left_player is player_ref:
            self.left_player.stop()
            self.left_player = None
        elif side == "right" and self.right_player is player_ref:
            self.right_player.stop()
            self.right_player = None
        self._start_rtsp_retry(side)

    def _cancel_rtsp_retry(self, side: str):
        timer = self._rtsp_retry_left if side == "left" else self._rtsp_retry_right
        if timer:
            timer.stop()
            timer.deleteLater()
        if side == "left":
            self._rtsp_retry_left = None
            self._rtsp_retry_delay_left = 1
        else:
            self._rtsp_retry_right = None
            self._rtsp_retry_delay_right = 1

    def _start_rtsp_retry(self, side: str):
        if not self.active_bucket:
            return
        cam = next((c for c in self.active_bucket.cameras if c.position == (CameraPosition.LEFT if side == "left" else CameraPosition.RIGHT)), None)
        if not cam:
            return
        if not self._is_camera_online(cam):
            return
        label = self.left_label if side == "left" else self.right_label
        delay = self._rtsp_retry_delay_left if side == "left" else self._rtsp_retry_delay_right
        label.setText(f"正在重连({delay}s)...")
        label.setAlignment(Qt.AlignCenter)
        label.setStyleSheet(label.styleSheet() + "color: orange; font-size: 20px;")
        timer = QTimer(self)
        timer.setSingleShot(True)
        timer.timeout.connect(lambda: self._retry_rtsp(side))
        timer.start(delay * 1000)
        if side == "left":
            self._rtsp_retry_left = timer
        else:
            self._rtsp_retry_right = timer

    def _retry_rtsp(self, side: str):
        if not self.active_bucket:
            return
        cam = next((c for c in self.active_bucket.cameras if c.position == (CameraPosition.LEFT if side == "left" else CameraPosition.RIGHT)), None)
        if not cam:
            return
        label = self.left_label if side == "left" else self.right_label
        if not self._is_camera_online(cam):
            self.show_timeout_on_label(label)
            self._cancel_rtsp_retry(side)
            return
        self.show_loading_on_label(label)
        w, h = label.width(), label.height()
        timeout = self.config.video.rtsp_timeout
        player = RTSPPlayer(cam.rtsp_url, w, h, timeout_sec=timeout)
        player.frame_ready.connect(label.setPixmap)
        player.first_frame_received.connect(lambda s=side: self._on_rtsp_retry_success(s))
        player.timeout.connect(lambda l=label, p=player, s=side: self.on_player_timeout(l, p, s))
        old = self.left_player if side == "left" else self.right_player
        if old:
            try:
                old.frame_ready.disconnect()
            except TypeError:
                pass
            try:
                old.first_frame_received.disconnect()
            except TypeError:
                pass
            try:
                old.timeout.disconnect()
            except TypeError:
                pass
            old.stop()
        if side == "left":
            self.left_player = player
        else:
            self.right_player = player
        player.start()

    def _on_rtsp_retry_success(self, side: str):
        self.hide_loading_on_label(self.left_label if side == "left" else self.right_label)
        self._cancel_rtsp_retry(side)
        # 重连成功后恢复 AI 对象标注
        if self.active_bucket and self.ai_enabled:
            objects = self._last_left_draw if side == "left" else self._last_right_draw
            player = self.left_player if side == "left" else self.right_player
            if player:
                player.set_ai_objects(objects)

    def _is_camera_online(self, cam) -> bool:
        m = re.search(r'rtsp://(?:[^@]+@)?([^:/]+)', cam.rtsp_url)
        if not m:
            return False
        lat = self._camera_signal.get(m.group(1))
        # 尚未检测过该 IP 时，默认认为在线，先尝试连接
        if lat is None:
            return True
        return lat >= 0
    def on_bucket_clicked(self, bucket: BucketModel):
        if self.switch_mode != SwitchMode.HAND:
            self.switch_mode = SwitchMode.HAND
            self.auto_switch_btn.setChecked(False)
            self.auto_switch_btn.setText("手动模式")
        self.activate_bucket(bucket)

    def on_rfid_state_changed(self, online: bool):
        self.rfid_state_signal.emit(online)

    def _on_rfid_state_impl(self, online: bool):
        if online:
            self.module_status.setText("通讯状态: RFID正常")
        else:
            self.module_status.setText("通讯状态: RFID离线")
            logger.warning("读卡器离线")
            if self.voice_enabled and getattr(self, '_started', False):
                self._speak("读卡器离线")

    # ---------- 硬件初始化 ----------
    def init_hardware(self):
        if self.config.module_type == ModuleType.RFID and self.config.rfid:
            valid_codes = {b.code_x for b in self.buckets if b.code_x}
            self.rfid_client = RFIDClient(
                self.config.rfid,
                self.on_rfid_tag,
                on_state_changed=self.on_rfid_state_changed,
                tag_offset=18,
                tag_length=4,
                hex_output=True,
                valid_codes=valid_codes
            )
            if self.rfid_client.connect():
                self.module_status.setText("通讯状态: RFID正常")
            else:
                self.module_status.setText("通讯状态: RFID离线")

        if self.config.module_type == ModuleType.HD3200 and self.config.modbus:
            self.modbus_client = ModbusClient(self.config.modbus, self.on_modbus_data)
            if self.modbus_client.connect():
                self.module_status.setText("通讯状态: Modbus正常")
            else:
                self.module_status.setText("通讯状态: Modbus离线")
        if self.config.ai.enabled:
            self.mqtt_client = MQTTClient(self.on_mqtt_message)
            self._connect_current_ai()

    def _connect_current_ai(self, bucket=None):
        if bucket is None:
            bucket = self.active_bucket
        idx = None
        if bucket and bucket.ai_module_id is not None:
            idx = bucket.ai_module_id
        elif self.config.ai_modules:
            idx = 0
        if idx is not None and idx < len(self.config.ai_modules):
            target = self.config.ai_modules[idx]
            self.mqtt_client.disconnect()
            self.mqtt_client.connect(target.broker, target.port)
            self._current_ai_module_id = idx
            if bucket:
                topics = [c.topic for c in bucket.cameras if c.topic]
                if topics:
                    self.mqtt_client.subscribe(topics)
                    self._subscribed_topics = set(topics)

    # ---------- 激活工位 ----------
    def activate_bucket(self, bucket: BucketModel):
        if self.active_bucket == bucket:
            return
        self._cancel_rtsp_retry("left")
        self._cancel_rtsp_retry("right")
        if bucket and self.voice_enabled:
            self._speak(f"到达{bucket.description}")
        for player in (self.left_player, self.right_player):
            if player is None:
                continue
            try:
                player.frame_ready.disconnect()
            except TypeError:
                pass
            try:
                player.first_frame_received.disconnect()
            except TypeError:
                pass
            try:
                player.timeout.disconnect()
            except TypeError:
                pass
            player.stop()
        self.left_player = None
        self.right_player = None
        if self.active_bucket:
            self.active_bucket.is_active = False
        self.active_bucket = bucket
        if bucket:
            bucket.is_active = True
        self.refresh_bucket_icons()

        self.show_loading_on_label(self.left_label)
        self.show_loading_on_label(self.right_label)

        # 重置挂钩状态
        self.hook_state = HookState.IDLE
        self.prev_state = HookState.IDLE
        self.state_counter = 0
        self.left_objects = []
        self.right_objects = []
        self.prev_left_hook = None
        self.prev_right_hook = None
        self.prev_left_lug = None
        self.prev_right_lug = None
        self.last_voice_state = None
        self._last_hooking_voice_time = 0.0
        self._ready_traces.clear()
        self._pair_traj = {"left": [], "right": []}
        self._voice_suppress_until = 0.0
        self._trace_phase = ""
        self._ascend_frames = 0
        self._ascend_latch_until = 0.0
        self._ready_hold_until = 0.0
        self.update_ui_for_state(HookState.IDLE)
        self._last_left_draw = []
        self._last_right_draw = []

        # 先切 AI 模块 + 订阅 MQTT topic（非阻塞），再启 RTSP
        if bucket and self.config.ai.enabled and self.mqtt_client:
            if bucket.ai_module_id != self._current_ai_module_id:
                self._unsubscribe_all_topics()
                self._connect_current_ai(bucket)

        if bucket:
            if self.mqtt_client:
                topics = [c.topic for c in bucket.cameras if c.topic]
                stale = self._subscribed_topics - set(topics)
                for t in stale:
                    self.mqtt_client.unsubscribe(t)
                new_t = [t for t in topics if t not in self._subscribed_topics]
                if new_t:
                    self.mqtt_client.subscribe(new_t)
                self._subscribed_topics = set(topics)

            # 再启 RTSP
            left_cam = next((c for c in bucket.cameras if c.position == CameraPosition.LEFT), None)
            right_cam = next((c for c in bucket.cameras if c.position == CameraPosition.RIGHT), None)

            if left_cam and self._is_camera_online(left_cam):
                w = self.left_label.width()
                h = self.left_label.height()
                timeout = self.config.video.rtsp_timeout
                player = RTSPPlayer(left_cam.rtsp_url, w, h, timeout_sec=timeout)
                player.frame_ready.connect(self.left_label.setPixmap)
                player.first_frame_received.connect(lambda p=player: self.hide_loading_on_label(self.left_label))
                player.timeout.connect(lambda p=player: self.on_player_timeout(self.left_label, p, "left"))
                self.left_player = player
                player.start()
            elif left_cam:
                self.show_timeout_on_label(self.left_label)
                if self.voice_enabled:
                    self._speak("左侧摄像头离线")

            if right_cam and self._is_camera_online(right_cam):
                w = self.right_label.width()
                h = self.right_label.height()
                timeout = self.config.video.rtsp_timeout
                player = RTSPPlayer(right_cam.rtsp_url, w, h, timeout_sec=timeout)
                player.frame_ready.connect(self.right_label.setPixmap)
                player.first_frame_received.connect(lambda p=player: self.hide_loading_on_label(self.right_label))
                player.timeout.connect(lambda p=player: self.on_player_timeout(self.right_label, p, "right"))
                self.right_player = player
                player.start()
            elif right_cam:
                self.show_timeout_on_label(self.right_label)
                if self.voice_enabled:
                    self._speak("右侧摄像头离线")
        else:
            self._unsubscribe_all_topics()
            self.left_label.clear()
            self.right_label.clear()
            QApplication.processEvents()
            self.left_label.clear()
            self.right_label.clear()

    def _unsubscribe_all_topics(self):
        if self.mqtt_client and self._subscribed_topics:
            for t in self._subscribed_topics:
                self.mqtt_client.unsubscribe(t)
            self._subscribed_topics.clear()

    # ---------- RFID 标签回调 ----------
    def on_rfid_tag(self, tag: str):
        self.rfid_tag_signal.emit(tag)

    def _on_rfid_tag_impl(self, tag: str):
        self._last_rfid_tag = tag
        if tag:
            self.rfid_tag_label.setText(f"当前卡号: {tag}")
        else:
            self.rfid_tag_label.setText("当前卡号: 无")

        if tag is None:
            if self.switch_mode == SwitchMode.AUTO and self.active_bucket:
                self.activate_bucket(None)
            return
        for bucket in self.buckets:
            if bucket.code_x == tag:
                if self.switch_mode == SwitchMode.AUTO:
                    self.activate_bucket(bucket)
                break

    # ---------- Modbus 数据回调 ----------
    def on_modbus_data(self, bools):
        self.modbus_data_signal.emit(bools)

    def _on_modbus_data_impl(self, bools):
        for bucket in self.buckets:
            try:
                addr_x = int(bucket.code_x)
            except (ValueError, TypeError):
                continue
            if addr_x < 0 or addr_x >= len(bools):
                continue
            if bucket.code_y and bucket.code_y.strip():
                try:
                    addr_y = int(bucket.code_y)
                except (ValueError, TypeError):
                    continue
                if addr_y < 0 or addr_y >= len(bools):
                    continue
                if bools[addr_x] and bools[addr_y]:
                    if self.switch_mode == SwitchMode.AUTO and self.active_bucket != bucket:
                        self.activate_bucket(bucket)
                        break
            else:
                if bools[addr_x]:
                    if self.switch_mode == SwitchMode.AUTO and self.active_bucket != bucket:
                        self.activate_bucket(bucket)
                        break

    # ---------- MQTT 消息处理 ----------
    def parse_ai_objects(self, payload: dict, display_width: int, display_height: int,
                         include_ready: bool = True) -> list:
        if payload is None or not isinstance(payload, dict):
            return []
        orig_width = payload.get("width", 640)
        orig_height = payload.get("height", 360)
        scale_x = display_width / orig_width if orig_width > 0 else 1.0
        scale_y = display_height / orig_height if orig_height > 0 else 1.0
        objects = []
        for obj_str in payload.get("objects", []):
            parts = obj_str.split('|')
            if len(parts) >= 6:
                try:
                    x = int(float(parts[1]) * scale_x)
                    y = int(float(parts[2]) * scale_y)
                    w = int(float(parts[3]) * scale_x)
                    h = int(float(parts[4]) * scale_y)
                    raw_label = parts[5]
                    label = raw_label
                    if 'hoist' in raw_label:
                        label = 'hook'
                    elif 'cup' in raw_label:
                        label = 'lug'
                    if 'hook' in label:
                        color = (0, 0, 255)
                    elif 'lug' in label:
                        color = (255, 0, 0)
                    elif 'ready' in label:
                        if not include_ready:
                            continue
                        color = (0, 255, 255)
                    else:
                        color = (128, 128, 128)
                    objects.append({
                        "track_id": parts[0],
                        "x": x,
                        "y": y,
                        "w": w,
                        "h": h,
                        "label": label,
                        "raw_label": raw_label,
                        "color": color
                    })
                except (ValueError, IndexError):
                    continue
        return objects

    def on_mqtt_message(self, topic: str, payload: dict):
        self.mqtt_message_signal.emit(topic, payload)

    def _on_mqtt_message_impl(self, topic: str, payload: dict):
        if payload is None or not isinstance(payload, dict):
            return
        if not self.active_bucket:
            return
        if not self.ai_enabled:
            return
        now = time.time()
        if now - self._last_mqtt_process < 0.03:
            return
        self._last_mqtt_process = now
        self._overlay_cleared = False
        for cam in self.active_bucket.cameras:
            if cam.topic == topic:
                self.update_video_size()
                if cam.position == CameraPosition.LEFT:
                    display_width = self.left_label.width()
                    display_height = self.left_label.height()
                else:
                    display_width = self.right_label.width()
                    display_height = self.right_label.height()
                if display_width == 0 or display_height == 0:
                    display_width = 640
                    display_height = 360

                all_objects = self.parse_ai_objects(payload, display_width, display_height, include_ready=True)

                # 更新 ready 标签轨迹
                for obj in all_objects:
                    if 'ready' in obj['label']:
                        tid = obj.get('track_id')
                        if tid:
                            cx = obj['x'] + obj['w'] / 2
                            cy = obj['y'] + obj['h'] / 2
                            if tid not in self._ready_traces:
                                self._ready_traces[tid] = []
                            self._ready_traces[tid].append((cx, cy, time.time()))
                            if len(self._ready_traces[tid]) > 20:
                                self._ready_traces[tid].pop(0)

                if cam.position == CameraPosition.LEFT:
                    self.left_objects = all_objects
                else:
                    self.right_objects = all_objects

                self.evaluate_hook_state()

                draw_objects = []
                for obj in all_objects:
                    if 'ready' in obj['label'].lower():
                        continue
                    obj['alpha'] = 0.4
                    draw_objects.append(obj)

                side = "left" if cam.position == CameraPosition.LEFT else "right"
                draw_objects.extend(self._trace_objects(side))
                status = self._trace_status_text()
                if status:
                    color = (0, 0, 255) if self._trace_phase else (0, 200, 255)
                    draw_objects.append({"text": status, "pos": (10, 20), "anchor": "tr", "color": color})

                if cam.position == CameraPosition.LEFT:
                    self._last_left_draw = draw_objects
                    if self.left_player:
                        self.left_player.set_ai_objects(draw_objects)
                else:
                    self._last_right_draw = draw_objects
                    if self.right_player:
                        self.right_player.set_ai_objects(draw_objects)
                break

    # ---------- 挂钩状态评估 ----------
    def evaluate_hook_state(self):
        left_hooks = [o for o in self.left_objects if 'hook' in o['label'].lower()]
        left_lugs = [o for o in self.left_objects if 'lug' in o['label'].lower()]
        right_hooks = [o for o in self.right_objects if 'hook' in o['label'].lower()]
        right_lugs = [o for o in self.right_objects if 'lug' in o['label'].lower()]

        def find_nearest_pair(hooks, lugs):
            if not hooks or not lugs:
                return None
            best_pair = None
            best_dist = float('inf')
            for h in hooks:
                hx = h['x'] + h['w'] / 2
                hy = h['y'] + h['h'] / 2
                for l in lugs:
                    lx = l['x'] + l['w'] / 2
                    ly = l['y'] + l['h'] / 2
                    dist = (hx - lx) ** 2 + (hy - ly) ** 2
                    if dist < best_dist:
                        best_dist = dist
                        best_pair = (h, l)
            return best_pair

        left_pair = find_nearest_pair(left_hooks, left_lugs)
        right_pair = find_nearest_pair(right_hooks, right_lugs)

        self._push_pair_traj("left", left_pair)
        self._push_pair_traj("right", right_pair)
        self._update_suppress_window()

        is_releasing = False

        if left_pair:
            h, l = left_pair
            if self.prev_left_hook and self.prev_left_lug:
                dy_h = (h['y'] + h['h'] / 2) - self.prev_left_hook[1]
                dy_l = (l['y'] + l['h'] / 2) - self.prev_left_lug[1]
                if dy_h > self.RELEASE_DELTA_THRESHOLD and dy_l > self.RELEASE_DELTA_THRESHOLD:
                    is_releasing = True
            self.prev_left_hook = (h['x'] + h['w'] / 2, h['y'] + h['h'] / 2)
            self.prev_left_lug = (l['x'] + l['w'] / 2, l['y'] + l['h'] / 2)
        else:
            self.prev_left_hook = None
            self.prev_left_lug = None

        if right_pair:
            h, l = right_pair
            if self.prev_right_hook and self.prev_right_lug:
                dy_h = (h['y'] + h['h'] / 2) - self.prev_right_hook[1]
                dy_l = (l['y'] + l['h'] / 2) - self.prev_right_lug[1]
                if dy_h > self.RELEASE_DELTA_THRESHOLD and dy_l > self.RELEASE_DELTA_THRESHOLD:
                    is_releasing = True
            self.prev_right_hook = (h['x'] + h['w'] / 2, h['y'] + h['h'] / 2)
            self.prev_right_lug = (l['x'] + l['w'] / 2, l['y'] + l['h'] / 2)
        else:
            self.prev_right_hook = None
            self.prev_right_lug = None

        if is_releasing:
            new_state = HookState.RELEASING
        else:
            any_ready = any('ready' in o['label'].lower() for o in self.left_objects + self.right_objects)
            has_intersecting_pair = self._has_intersecting_pair(left_pair, right_pair)
            ascending = self._is_ascending_together() and not self._is_voice_suppressed()

            if self.hook_state == HookState.READY:
                # READY 粘滞：挂包成功后只有确认下降或挂钩离开才退出，
                # 模型 ready 标签抖动 / 短暂静止不再导致红绿来回跳
                descending = self._is_descending()
                if descending:
                    new_state = HookState.HOOKING
                elif has_intersecting_pair or ascending:
                    new_state = HookState.READY
                    self._ready_hold_until = time.time() + self.READY_HOLD_SECS
                elif time.time() < self._ready_hold_until:
                    new_state = HookState.READY
                else:
                    new_state = HookState.IDLE
            elif ascending:
                new_state = HookState.READY
                self._ready_hold_until = time.time() + self.READY_HOLD_SECS
            elif any_ready and has_intersecting_pair:
                descending = self._is_descending()
                if descending is None:
                    new_state = self.hook_state
                elif descending:
                    new_state = HookState.HOOKING
                else:
                    new_state = HookState.READY
                    self._ready_hold_until = time.time() + self.READY_HOLD_SECS
            elif has_intersecting_pair:
                new_state = HookState.HOOKING
            else:
                new_state = HookState.IDLE

        # 防抖：READY 的粘滞/保持已由 sticky + hold 承担，此处不再特殊放行 15 帧
        threshold = 1 if new_state == HookState.IDLE else self.STATE_THRESHOLD
        if new_state == self.prev_state:
            self.state_counter += 1
        else:
            self.prev_state = new_state
            self.state_counter = 1

        if self.state_counter >= threshold:
            if new_state != self.hook_state:
                self.hook_state = new_state
                self.update_ui_for_state(new_state)
            self.state_counter = 0

        for obj in self.left_objects + self.right_objects:
            obj.pop('paired', None)
        if left_pair:
            left_pair[0]['paired'] = True
            left_pair[1]['paired'] = True
        if right_pair:
            right_pair[0]['paired'] = True
            right_pair[1]['paired'] = True

    def rects_intersect(self, a, b):
        ax1, ay1, ax2, ay2 = a['x'], a['y'], a['x']+a['w'], a['y']+a['h']
        bx1, by1, bx2, by2 = b['x'], b['y'], b['x']+b['w'], b['y']+b['h']
        return not (ax2 < bx1 or bx2 < ax1 or ay2 < by1 or by2 < ay1)

    def _has_intersecting_pair(self, left_pair, right_pair):
        if left_pair:
            h, l = left_pair
            if self.rects_intersect(h, l):
                return True
        if right_pair:
            h, l = right_pair
            if self.rects_intersect(h, l):
                return True
        return False

    def _push_pair_traj(self, side: str, pair):
        """把当前帧配对中心与距离追加进轨迹队列"""
        if not pair:
            self._pair_traj[side] = []
            return
        h, l = pair
        hx, hy = h['x'] + h['w'] / 2, h['y'] + h['h'] / 2
        lx, ly = l['x'] + l['w'] / 2, l['y'] + l['h'] / 2
        dist = ((hx - lx) ** 2 + (hy - ly) ** 2) ** 0.5
        now = time.time()
        traj = self._pair_traj[side]
        traj.append({"t": now, "hook_cx": hx, "hook_cy": hy, "lug_cx": lx, "lug_cy": ly, "dist": dist})
        while len(traj) > self.TRAJ_MAX_FRAMES:
            traj.pop(0)
        if traj[-1]['t'] - traj[0]['t'] > self.TRAJ_WINDOW_SECS:
            traj.pop(0)

    def _window_traj(self, side: str):
        """返回该侧轨迹窗口（最近 TRAJ_WINDOW_SECS）"""
        traj = self._pair_traj[side]
        if not traj:
            return traj
        now = traj[-1]['t']
        return [p for p in traj if now - p['t'] <= self.TRAJ_WINDOW_SECS]

    def _update_suppress_window(self):
        """基于轨迹判定放包/分离阶段，命中则顺延屏蔽语音"""
        now = time.time()
        hit = ""
        for side in ("left", "right"):
            win = self._window_traj(side)
            if len(win) < 5:
                continue
            first, last = win[0], win[-1]
            dy_h = last['hook_cy'] - first['hook_cy']
            dy_l = last['lug_cy'] - first['lug_cy']
            min_dist = min(p['dist'] for p in win)
            max_dist = max(p['dist'] for p in win)
            # 放包：hook 与 lug 同步下移，且距离保持贴合
            if dy_h >= self.RELEASE_TRAJ_Y and dy_l >= self.RELEASE_TRAJ_Y and min_dist < self.ENGAGE_DIST:
                hit = "放包"
            # 分离：距离相离（任意方向），且之前曾贴合
            elif max_dist - min_dist >= self.SEPARATE_TRAJ_DIST and min_dist < self.ENGAGE_DIST:
                hit = "分离"
        if hit:
            self._voice_suppress_until = max(now, self._voice_suppress_until) + self.SUPPRESS_SECONDS
            self._trace_phase = hit
        else:
            self._trace_phase = ""

    def _is_voice_suppressed(self) -> bool:
        return time.time() < self._voice_suppress_until

    def _maybe_clear_stale_overlay(self):
        """MQTT 消息超时后清除残留画框/轨迹，避免画面卡住旧框"""
        now = time.time()
        if not self.ai_enabled or self._overlay_cleared:
            return
        if self._last_mqtt_process > 0 and now - self._last_mqtt_process > self.MQTT_CLEAR_TIMEOUT:
            self._last_left_draw = []
            self._last_right_draw = []
            self._pair_traj = {"left": [], "right": []}
            self._trace_phase = ""
            self._voice_suppress_until = 0.0
            self._ascend_frames = 0
            self._ascend_latch_until = 0.0
            self._ready_hold_until = 0.0
            if self.left_player:
                self.left_player.set_ai_objects([])
            if self.right_player:
                self.right_player.set_ai_objects([])
            self._overlay_cleared = True

    def _trace_objects(self, side: str) -> list:
        """构造叠加对象：挂钩轨迹、吊耳轨迹、挂钩-吊耳连线、阶段文本"""
        if not self.debug_trace:
            return []
        win = self._window_traj(side)
        if len(win) < 2:
            return []
        hook_pts = [(p['hook_cx'], p['hook_cy']) for p in win]
        lug_pts = [(p['lug_cx'], p['lug_cy']) for p in win]
        objs = [
            {"points": hook_pts, "color": (0, 255, 0), "alpha": 0.4, "thickness": 1},
            {"points": lug_pts, "color": (0, 255, 255), "alpha": 0.4, "thickness": 1},
        ]
        hx, hy = win[-1]['hook_cx'], win[-1]['hook_cy']
        lx, ly = win[-1]['lug_cx'], win[-1]['lug_cy']
        color = (0, 0, 255) if self._trace_phase == "分离" else (255, 165, 0)
        objs.append({"points": [(hx, hy), (lx, ly)], "color": color, "alpha": 0.4, "thickness": 1})
        return objs

    def _trace_status_text(self) -> str:
        if not self.debug_trace:
            return ""
        if self._trace_phase:
            remain = max(0.0, self._voice_suppress_until - time.time())
            tag = "RELEASE" if self._trace_phase == "放包" else "SEP"
            return f"{tag} {remain:.1f}s"
        return "OK"

    def _is_ascending_together(self) -> bool:
        """最近 5 帧挂钩与吊耳同步上移且保持贴合 → 视为挂包成功（补 ready 漏检）。
        连续 ASCEND_DEBOUNCE 帧命中后锁存 ASCEND_LATCH_SECS，避免上升结束后
        轨迹窗口滚动导致瞬间回落误判，也抑制单帧抖动触发"""
        detected = False
        for side in ("left", "right"):
            win = self._window_traj(side)
            if len(win) < 5:
                continue
            recent = win[-5:]
            dy_h = recent[-1]['hook_cy'] - recent[0]['hook_cy']
            dy_l = recent[-1]['lug_cy'] - recent[0]['lug_cy']
            if dy_h <= -self.ASCEND_TRAJ_Y and dy_l <= -self.ASCEND_TRAJ_Y:
                if recent[-1]['dist'] < self.ENGAGE_DIST:
                    detected = True
                    break
        if detected:
            self._ascend_frames += 1
        else:
            self._ascend_frames = 0
        if self._ascend_frames >= self.ASCEND_DEBOUNCE:
            self._ascend_latch_until = time.time() + self.ASCEND_LATCH_SECS
        return time.time() < self._ascend_latch_until

    def _is_descending(self) -> Optional[bool]:
        """ready 轨迹下降=返回 True；确认静止=返回 False；最近轨迹不足=返回 None。
        要求窗口净位移与逐步上升帧数同时满足，降低检测框抖动引起的误判"""
        now = time.time()
        confirmed = False
        for tid, trace in self._ready_traces.items():
            if not trace or now - trace[-1][2] > self.TRAJ_WINDOW_SECS:
                continue
            if len(trace) < 5:
                continue
            confirmed = True
            recent = trace[-5:]
            ys = [p[1] for p in recent]
            net = ys[-1] - ys[0]
            rises = sum(1 for i in range(1, len(ys)) if ys[i] > ys[i-1] + 2)
            if net >= 6 and rises >= 4:
                return True
        return None if not confirmed else False

    # def _draw_traces(self, frame, sx=1.0, sy=1.0, x_off=0, y_off=0):
#     import cv2
#     for tid, trace in self._ready_traces.items():
#         if len(trace) < 2:
#             continue
#         pts = [(int((p[0] * sx) + x_off), int((p[1] * sy) + y_off)) for p in trace]
#         for i in range(1, len(pts)):
#             alpha = i / len(pts)
#             color = (0, int(255 * alpha), 255)
#             cv2.line(frame, pts[i-1], pts[i], color, 2)

# def _build_trace_lines(self) -> list:
#     return [[(p[0], p[1]) for p in trace] for trace in self._ready_traces.values()]

    # ---------- UI 更新与语音 ----------
    def update_ui_for_state(self, state):
        if state == HookState.IDLE:
            border_color = "#dcdfe6"
            text = "空闲"
        elif state == HookState.RELEASING:
            border_color = "#ffa500"
            text = "放包中"
        elif state == HookState.HOOKING:
            border_color = "#ff0000"
            text = "挂包中"
        elif state == HookState.READY:
            border_color = "#00ff00"
            text = "挂包成功"
        else:
            border_color = "#dcdfe6"
            text = ""

        self.hook_status_label.setText(f"挂钩状态: {text}")

        style = f"""
            QLabel {{
                border: 4px solid {border_color};
                border-radius: 8px;
                background-color: black;
            }}
        """
        self.left_label.setStyleSheet(style)
        self.right_label.setStyleSheet(style)

        if self.voice_enabled and state in (HookState.HOOKING, HookState.READY):
            now = time.time()
            if self._is_voice_suppressed():
                return
            if state == HookState.HOOKING:
                if state != self.last_voice_state or now - self._last_hooking_voice_time > 15:
                    self._speak("挂包中")
                    self.last_voice_state = state
                    self._last_hooking_voice_time = now
            elif state != self.last_voice_state:
                self._speak("挂包成功")
                self.last_voice_state = state

    # ---------- 定时任务 ----------
    def check_idle(self):
        if self.rfid_client:
            self.rfid_client.check_idle()
        self._maybe_clear_stale_overlay()
        now = time.time()
        if self.config.ai.enabled and self.mqtt_client and not self.mqtt_client.connected:
            if now - self._last_mqtt_connect_attempt > 30:
                self._last_mqtt_connect_attempt = now
                self._connect_current_ai()

        # 每 5 秒检测一次摄像头信号
        if now - self._last_signal_check > 5:
            self._last_signal_check = now
            if not getattr(self, '_signal_check_thread', None) or not self._signal_check_thread.is_alive():
                self._signal_check_thread = threading.Thread(target=self._check_all_cameras, daemon=True)
                self._signal_check_thread.start()

    def _collect_camera_ips(self) -> list:
        ips = set()
        for bucket in self.buckets:
            for cam in bucket.cameras:
                m = re.search(r'rtsp://(?:[^@]+@)?([^:/]+)', cam.rtsp_url)
                if m:
                    ips.add(m.group(1))
        return sorted(ips)

    def _check_all_cameras(self):
        ips = self._collect_camera_ips()
        if not ips:
            return

        def check_one(ip: str) -> tuple:
            try:
                import socket
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.settimeout(2)
                r = s.connect_ex((ip, 554))
                s.close()
                return (ip, 0 if r == 0 else -1)
            except Exception:
                return (ip, -1)

        with ThreadPoolExecutor(max_workers=len(ips)) as pool:
            results = dict(pool.map(check_one, ips))
        self.camera_signal_signal.emit(results)

    def _on_camera_signal(self, results: dict):
        was_offline = {ip for ip, lat in self._camera_signal.items() if lat is not None and lat < 0}
        self._camera_signal.update(results)
        now_online = {ip for ip, lat in results.items() if lat >= 0}
        revived = now_online & was_offline
        went_offline = {ip for ip, lat in results.items() if lat < 0}
        if went_offline and self.active_bucket:
            for cam in self.active_bucket.cameras:
                m = re.search(r'rtsp://(?:[^@]+@)?([^:/]+)', cam.rtsp_url)
                if m and m.group(1) in went_offline:
                    ip = m.group(1)
                    if ip not in self._offline_reported and self.voice_enabled:
                        self._offline_reported.add(ip)
                        side_name = "左" if cam.position == CameraPosition.LEFT else "右"
                        self._speak(f"{side_name}侧摄像头离线")
                        logger.warning(f"摄像头离线: {ip}")
                    side = "left" if cam.position == CameraPosition.LEFT else "right"
                    label = self.left_label if side == "left" else self.right_label
                    cur = self.left_player if side == "left" else self.right_player
                    if cur is not None:
                        cur.stop()
                        if side == "left":
                            self.left_player = None
                        else:
                            self.right_player = None
                    self._cancel_rtsp_retry(side)
                    self.show_timeout_on_label(label)
        if revived and self.active_bucket:
            for cam in self.active_bucket.cameras:
                m = re.search(r'rtsp://(?:[^@]+@)?([^:/]+)', cam.rtsp_url)
                if m and m.group(1) in revived:
                    self._offline_reported.discard(m.group(1))
                    side = "left" if cam.position == CameraPosition.LEFT else "right"
                    cur = self.left_player if side == "left" else self.right_player
                    if cur is None:
                        self._cancel_rtsp_retry(side)
                        self._retry_rtsp(side)
        for bucket in self.buckets:
            bars = self._bucket_signal_labels.get(bucket.id)
            if not bars:
                continue
            left_bar, right_bar = bars
            for bar, cam in zip((left_bar, right_bar), bucket.cameras):
                m = re.search(r'rtsp://(?:[^@]+@)?([^:/]+)', cam.rtsp_url)
                if not m:
                    bar.setStyleSheet("background-color: #dcdfe6; border-radius: 2px;")
                    continue
                ip = m.group(1)
                lat = self._camera_signal.get(ip)
                if lat is None:
                    bar.setStyleSheet("background-color: #dcdfe6; border-radius: 2px;")
                elif lat < 0:
                    bar.setStyleSheet("background-color: #f56c6c; border-radius: 2px;")
                elif lat < 50:
                    bar.setStyleSheet("background-color: #67c23a; border-radius: 2px;")
                elif lat < 200:
                    bar.setStyleSheet("background-color: #e6a23c; border-radius: 2px;")
                else:
                    bar.setStyleSheet("background-color: #f56c6c; border-radius: 2px;")

    def toggle_switch_mode(self, checked: bool):
        if checked:
            self.switch_mode = SwitchMode.AUTO
            self.auto_switch_btn.setText("自动模式")
            if self._last_rfid_tag:
                self._on_rfid_tag_impl(self._last_rfid_tag)
            elif self.active_bucket:
                self.activate_bucket(None)
        else:
            self.switch_mode = SwitchMode.HAND
            self.auto_switch_btn.setText("手动模式")

    # ---------- 开机自启 ----------
    def _save_config(self):
        import configparser
        cfg = configparser.ConfigParser()
        cfg.read(self._config_path, encoding="utf-8")
        if not cfg.has_section("AI"):
            cfg.add_section("AI")
        val = "true" if self.config.ai.tts_enabled else "false"
        cfg.set("AI", "tts_enabled", val)
        if not cfg.has_section("Video"):
            cfg.add_section("Video")
        cfg.set("Video", "ratio_16_9", "true" if self._ratio_16_9 else "false")
        with open(self._config_path, "w", encoding="utf-8") as f:
            cfg.write(f)
        logger.info(f"配置已保存: {self._config_path}")

    @staticmethod
    def _autostart_config_dir():
        if sys.platform == "win32":
            return os.path.join(os.environ.get("APPDATA", os.path.expanduser("~")), "HookVision")
        return os.path.join(os.path.expanduser("~"), ".config", "HookVision")

    @staticmethod
    def _autostart_config_path():
        return os.path.join(MainWindow._autostart_config_dir(), "autostart.txt")   # 改为 txt

    @staticmethod
    def _autostart_desktop_path():
        return os.path.expanduser("~/.config/autostart/HookVision.desktop")

    @staticmethod
    def _read_autostart_flag():
        path = MainWindow._autostart_config_path()
        try:
            with open(path, "r", encoding="utf-8") as f:
                content = f.read().strip().lower()
                return content == "true"
        except:
            return False

    @staticmethod
    def _write_autostart_flag(enabled: bool):
        path = MainWindow._autostart_config_path()
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, "w", encoding="utf-8") as f:
            f.write("true" if enabled else "false")

    @staticmethod
    def _autostart_command():
        if getattr(sys, 'frozen', False):
            return sys.executable
        else:
            main_script = os.path.abspath(sys.argv[0])
            python_exe = sys.executable
            if ' ' in python_exe:
                python_exe = f'"{python_exe}"'
            if ' ' in main_script:
                main_script = f'"{main_script}"'
            if sys.platform == "win32":
                pythonw = python_exe.replace('python.exe', 'pythonw.exe')
                if pythonw != python_exe and os.path.exists(pythonw):
                    python_exe = pythonw
            return f'{python_exe} {main_script}'

    @staticmethod
    def _apply_system_autostart(enabled: bool) -> bool:
        cmd = MainWindow._autostart_command()
        try:
            if sys.platform == "win32":
                import winreg
                key = r"Software\Microsoft\Windows\CurrentVersion\Run"
                with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key, 0, winreg.KEY_SET_VALUE) as rk:
                    if enabled:
                        winreg.SetValueEx(rk, MainWindow.APPTITLE, 0, winreg.REG_SZ, cmd)
                    else:
                        try:
                            winreg.DeleteValue(rk, MainWindow.APPTITLE)
                        except OSError:
                            pass
                return True
            else:
                desktop_path = MainWindow._autostart_desktop_path()
                if enabled:
                    os.makedirs(os.path.dirname(desktop_path), exist_ok=True)
                    with open(desktop_path, "w", encoding="utf-8") as f:
                        f.write(f"""[Desktop Entry]
Type=Application
Name={MainWindow.APPTITLE}
Exec={cmd}
Terminal=false
X-GNOME-Autostart-enabled=true
""")
                else:
                    try:
                        os.remove(desktop_path)
                    except OSError:
                        pass
                return True
        except Exception as e:
            logger.error(f"设置开机自启失败: {e}")
            return False

    def _on_autostart_toggle(self, state):
        enabled = (state == Qt.Checked)
        self._write_autostart_flag(enabled)
        ok = self._apply_system_autostart(enabled)
        if not ok:
            QMessageBox.warning(
                self,
                "设置失败",
                "开机自启动设置失败，请检查权限或手动添加。\n"
                "Windows: 将本程序快捷方式放入 '启动' 文件夹。\n"
                "Linux: 检查 ~/.config/autostart/ 目录权限。"
            )