dsh/dual_camera_system/panorama_camera.py

"""
全景摄像头模块
负责获取视频流和物体检测
"""

import os
# 必须在导入cv2之前设置，防止FFmpeg多线程解码崩溃
# pthread_frame.c:167 async_lock assertion
os.environ['OPENCV_FFMPEG_CAPTURE_OPTIONS'] = 'rtsp_transport;tcp|threads;1'

import cv2
import numpy as np
import threading
import queue
import time
import logging
from datetime import datetime
from typing import Optional, List, Tuple, Dict, Any
from dataclasses import dataclass
from pathlib import Path

from config import PANORAMA_CAMERA, DETECTION_CONFIG
from config.camera import parse_resolution
from dahua_sdk import DahuaSDK, PTZCommand
from video_lock import safe_read, safe_is_opened
from inference_backend import nms

logger = logging.getLogger(__name__)


@dataclass
class DetectedObject:
    """检测到的物体"""
    class_name: str          # 类别名称
    confidence: float        # 置信度
    bbox: Tuple[int, int, int, int]  # 边界框 (x, y, width, height)
    center: Tuple[int, int]  # 中心点坐标
    track_id: Optional[int] = None  # 跟踪ID


class PanoramaCamera:
    """全景摄像头类"""
    
    def __init__(self, sdk: DahuaSDK, camera_config: Dict = None):
        """
        初始化全景摄像头
        Args:
            sdk: 大华SDK实例
            camera_config: 摄像头配置
        """
        self.sdk = sdk
        self.config = camera_config or PANORAMA_CAMERA

        # 解析期望分辨率
        self.frame_width, self.frame_height = parse_resolution(self.config.get('resolution'))

        # 摄像头品牌 / SDK 使用策略
        # brand: 'dahua' | 'hikvision' | 'uniview' | 'auto'
        # use_sdk: True 时使用大华 SDK 登录；False 时仅使用 RTSP 取流
        self.brand = self.config.get('brand', 'auto').lower()
        self.use_sdk = self.config.get('use_sdk', self.brand != 'hikvision')
        if self.brand == 'hikvision':
            self.use_sdk = False

        self.login_handle = None
        self.play_handle = None
        self.connected = False

        # 视频流
        self.frame_queue = queue.Queue(maxsize=10)
        self.current_frame = None
        self.frame_lock = threading.Lock()
        self.rtsp_cap = None  # RTSP视频捕获
        self._camera_id = 'panorama'  # 用于per-camera锁

        # 检测器
        self.detector = None

        # 控制标志
        self.running = False
        self.stream_thread = None

        # 断线重连
        self.auto_reconnect = True
        self.reconnect_interval = 5.0  # 重连间隔(秒)
        self.max_reconnect_attempts = 3  # 最大重连次数
    
    def connect(self) -> bool:
        """
        连接摄像头
        Returns:
            是否成功
        """
        if not self.use_sdk:
            print(f"[PanoramaCamera] {self.config.get('ip')} 配置为 RTSP-only 模式，跳过 SDK 登录")
            self.connected = True
            return True

        login_handle, error = self.sdk.login(
            self.config['ip'],
            self.config['port'],
            self.config['username'],
            self.config['password']
        )

        if login_handle is None:
            print(f"连接全景摄像头失败: IP={self.config['ip']}, 错误码={error}")
            return False

        self.login_handle = login_handle
        self.connected = True
        print(f"成功连接全景摄像头: {self.config['ip']}")
        return True

    def disconnect(self):
        """断开连接"""
        self.stop_stream()
        if self.use_sdk and self.login_handle:
            self.sdk.logout(self.login_handle)
            self.login_handle = None
        self.connected = False

    def is_connected(self) -> bool:
        """是否已连接"""
        return self.connected

    def start_stream(self) -> bool:
        """
        开始视频流 (SDK 模式，仅 Dahua 等品牌支持)
        Returns:
            是否成功
        """
        if not self.connected:
            return False

        if not self.use_sdk:
            print("[PanoramaCamera] 当前为 RTSP-only 模式，跳过 SDK 视频流")
            return False

        self.play_handle = self.sdk.real_play(
            self.login_handle,
            self.config['channel']
        )

        if self.play_handle is None:
            print("启动视频流失败")
            return False

        self.running = True
        self.stream_thread = threading.Thread(target=self._stream_worker, daemon=True)
        self.stream_thread.start()

        print("视频流已启动")
        return True
    
    def start_stream_rtsp(self, rtsp_url: str = None) -> bool:
        if rtsp_url is None:
            rtsp_url = self.config.get('rtsp_url') or f"rtsp://{self.config['username']}:{self.config['password']}@{self.config['ip']}:{self.config.get('rtsp_port', 554)}/h264/ch{self.config['channel']}/main/av_stream"
        
        try:
            # 先尝试FFmpeg后端
            self.rtsp_cap = cv2.VideoCapture(rtsp_url, cv2.CAP_FFMPEG)
            if not self.rtsp_cap.isOpened():
                # FFmpeg失败，尝试GStreamer后端
                print(f"FFmpeg后端无法打开RTSP流，尝试GStreamer后端...")
                try:
                    gst_cap = cv2.VideoCapture(rtsp_url, cv2.CAP_GSTREAMER)
                    if gst_cap.isOpened():
                        self.rtsp_cap = gst_cap
                        print(f"使用GStreamer后端打开RTSP流成功")
                    else:
                        print(f"无法打开RTSP流: {rtsp_url}")
                        return False
                except Exception as ge:
                    print(f"GStreamer后端也不可用: {ge}")
                    return False
            
            self.rtsp_cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)

            self.running = True
            self.stream_thread = threading.Thread(target=self._rtsp_stream_worker, daemon=True)
            self.stream_thread.start()
            print(f"RTSP视频流已启动: {rtsp_url} (期望分辨率 {self.frame_width}x{self.frame_height})")
            return True
        except Exception as e:
            print(f"RTSP流启动失败: {e}")
            return False
    
    def _stream_worker(self):
        """视频流工作线程 (SDK模式)"""
        retry_count = 0
        max_retries = 10
        
        while self.running:
            try:
                # 尝试从 SDK 帧缓冲区获取帧 (如果可用)
                frame_buffer = self.sdk.get_video_frame_buffer(self.config['channel'])
                
                if frame_buffer:
                    frame_info = frame_buffer.get(timeout=0.1)
                    if frame_info and frame_info.get('data'):
                        # 解码帧数据 (如果需要)
                        # 注意: SDK回调返回的是编码数据，需要解码
                        # 这里暂时跳过，因为解码需要额外处理
                        pass
                
                # RTSP 模式获取帧 (推荐方式)
                if self.rtsp_cap is not None and safe_is_opened(self.rtsp_cap, self._camera_id):
                    ret, frame = safe_read(self.rtsp_cap, self._camera_id)
                    if ret and frame is not None:
                        with self.frame_lock:
                            self.current_frame = frame.copy()
                        
                        try:
                            self.frame_queue.put(frame.copy(), block=False)
                        except queue.Full:
                            pass
                        
                        retry_count = 0  # 重置重试计数
                        time.sleep(0.001)  # 减少CPU占用
                        continue
                
                # 如果 RTSP 不可用，尝试自动连接
                if retry_count < max_retries:
                    rtsp_url = self._build_rtsp_url()
                    try:
                        if self.rtsp_cap is None:
                            self.rtsp_cap = cv2.VideoCapture(rtsp_url, cv2.CAP_FFMPEG)
                            self.rtsp_cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # 减少缓冲延迟
                        
                        if safe_is_opened(self.rtsp_cap, self._camera_id):
                            retry_count = 0
                            continue
                    except Exception as e:
                        pass
                    
                    retry_count += 1
                    time.sleep(1.0)  # 重试间隔
                else:
                    # 超过最大重试次数，使用与配置分辨率一致的模拟帧
                    frame = np.zeros((self.frame_height, self.frame_width, 3), dtype=np.uint8)

                    with self.frame_lock:
                        self.current_frame = frame

                    try:
                        self.frame_queue.put(frame, block=False)
                    except queue.Full:
                        pass

                    time.sleep(0.1)
                
            except Exception as e:
                err_str = str(e)
                if 'async_lock' in err_str or 'Assertion' in err_str:
                    print(f"视频流FFmpeg内部错误，重建连接: {e}")
                    self._reconnect_rtsp()
                else:
                    print(f"视频流错误: {e}")
                time.sleep(0.5)
    
    def _build_rtsp_url(self) -> str:
        return self.config.get('rtsp_url') or f"rtsp://{self.config['username']}:{self.config['password']}@{self.config['ip']}:{self.config.get('rtsp_port', 554)}/h264/ch{self.config['channel']}/main/av_stream"
    
    def _rtsp_stream_worker(self):
        """RTSP视频流工作线程"""
        import signal
        # 屏蔽SIGINT在此线程，由主线程处理
        if hasattr(signal, 'pthread_sigmask'):
            try:
                signal.pthread_sigmask(signal.SIG_BLOCK, {signal.SIGINT})
            except (AttributeError, OSError):
                pass
        
        max_consecutive_errors = 50
        error_count = 0
        
        while self.running:
            try:
                if self.rtsp_cap is None or not safe_is_opened(self.rtsp_cap, self._camera_id):
                    time.sleep(0.1)
                    continue
                
                ret, frame = safe_read(self.rtsp_cap, self._camera_id)
                if not ret or frame is None:
                    error_count += 1
                    if error_count > max_consecutive_errors:
                        print(f"全景RTSP流连续{max_consecutive_errors}次读取失败，尝试重连...")
                        self._reconnect_rtsp()
                        error_count = 0
                    time.sleep(0.01)
                    continue
                
                error_count = 0

                # 记录实际分辨率，仅做校验与提示（不做拉伸缩放，避免丢精度）
                actual_h, actual_w = frame.shape[:2]
                if not getattr(self, '_resolution_logged', False):
                    print(f"全景摄像头实际分辨率: {actual_w}x{actual_h}，期望分辨率: "
                          f"{self.frame_width}x{self.frame_height}")
                    self._resolution_logged = True
                if (actual_w, actual_h) != (self.frame_width, self.frame_height):
                    if not getattr(self, '_resolution_warned', False):
                        logger.warning(
                            f"全景摄像头分辨率 {actual_w}x{actual_h} 与期望分辨率 "
                            f"{self.frame_width}x{self.frame_height} 不一致，"
                            f"模型推理时将使用 letterbox 灰度填充保持比例"
                        )
                        self._resolution_warned = True

                with self.frame_lock:
                    self.current_frame = frame.copy()

                try:
                    self.frame_queue.put(frame, block=False)
                except queue.Full:
                    pass
                    
            except Exception as e:
                err_str = str(e)
                if 'async_lock' in err_str or 'Assertion' in err_str:
                    print(f"全景RTSP流FFmpeg内部错误，3秒后重建连接: {e}")
                    time.sleep(3)
                    self._reconnect_rtsp()
                else:
                    print(f"全景RTSP视频流错误: {e}")
                    time.sleep(0.5)
    
    def _reconnect_rtsp(self):
        """重建RTSP连接"""
        rtsp_url = self._build_rtsp_url()
        if self.rtsp_cap is not None:
            try:
                self.rtsp_cap.release()
            except Exception:
                pass
            self.rtsp_cap = None
        
        time.sleep(1)
        
        try:
            self.rtsp_cap = cv2.VideoCapture(rtsp_url, cv2.CAP_FFMPEG)
            if safe_is_opened(self.rtsp_cap, self._camera_id):
                self.rtsp_cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
                print("全景RTSP流重连成功")
            else:
                print("全景RTSP流重连失败")
                self.rtsp_cap = None
        except Exception as e:
            print(f"全景RTSP流重连异常: {e}")
            self.rtsp_cap = None
    
    def stop_stream(self):
        """停止视频流"""
        self.running = False
        if self.stream_thread:
            self.stream_thread.join(timeout=2)
        if self.play_handle:
            self.sdk.stop_real_play(self.play_handle)
            self.play_handle = None
        if self.rtsp_cap:
            self.rtsp_cap.release()
            self.rtsp_cap = None
    
    def get_frame(self) -> Optional[np.ndarray]:
        """
        获取当前帧
        Returns:
            当前帧图像
        """
        with self.frame_lock:
            return self.current_frame.copy() if self.current_frame is not None else None
    
    def get_frame_from_queue(self, timeout: float = 0.1) -> Optional[np.ndarray]:
        """
        从帧队列获取帧 (用于批量处理)
        Args:
            timeout: 等待超时时间
        Returns:
            帧图像或None
        """
        try:
            return self.frame_queue.get(timeout=timeout)
        except:
            return None
    
    def get_frame_buffer(self, count: int = 5) -> List[np.ndarray]:
        """
        获取帧缓冲 (用于运动检测等需要多帧的场景)
        Args:
            count: 获取帧数
        Returns:
            帧列表
        """
        frames = []
        while len(frames) < count:
            frame = self.get_frame_from_queue(timeout=0.05)
            if frame is not None:
                frames.append(frame)
            else:
                break
        return frames
    
    def set_detector(self, detector):
        """设置物体检测器"""
        self.detector = detector
    
    def detect_objects(self, frame: np.ndarray = None) -> List[DetectedObject]:
        """
        检测物体
        Args:
            frame: 输入帧,如果为None则使用当前帧
        Returns:
            检测到的物体列表
        """
        if frame is None:
            frame = self.get_frame()
        
        if frame is None or self.detector is None:
            return []
        
        return self.detector.detect(frame)
    
    def get_detection_position(self, obj: DetectedObject, 
                               frame_size: Tuple[int, int]) -> Tuple[float, float]:
        """
        获取检测物体在画面中的相对位置
        Args:
            obj: 检测到的物体
            frame_size: 画面尺寸 (width, height)
        Returns:
            相对位置 (x_ratio, y_ratio) 范围0-1
        """
        width, height = frame_size
        x_ratio = obj.center[0] / width
        y_ratio = obj.center[1] / height
        return (x_ratio, y_ratio)


class ObjectDetector:
    """
    物体检测器
    使用YOLO11模型进行人体检测
    支持 YOLO (.pt), RKNN (.rknn), ONNX (.onnx) 模型
    """
    
    def __init__(self, model_path: str = None, use_gpu: bool = True, model_size: str = 'n',
                 model_type: str = 'auto'):
        """
        初始化检测器
        Args:
            model_path: 模型路径 (支持 .pt, .rknn, .onnx)
            use_gpu: 是否使用GPU
            model_size: 模型尺寸 ('n', 's', 'm', 'l', 'x') - 仅 YOLO 模型有效
            model_type: 模型类型 ('auto', 'yolo', 'rknn', 'onnx')
        """
        self.model = None
        self.rknn_detector = None
        self.model_path = model_path
        self.use_gpu = use_gpu
        self.model_size = model_size
        self.model_type = model_type
        self.is_end2end = False
        self.config = DETECTION_CONFIG
        self.device = 'cuda:0' if use_gpu else 'cpu'
        
        # 检测图片保存配置
        self._save_image_enabled = self.config.get('save_detection_image', False)
        self._image_save_dir = Path(self.config.get('detection_image_dir', './detection_images'))
        self._image_max_count = self.config.get('detection_image_max_count', 1000)
        self._last_save_time = 0
        # 保存间隔：优先使用配置值，否则基于检测帧率计算（检测间隔的1.5倍）
        detection_fps = self.config.get('detection_fps', 2)
        self._save_interval = self.config.get('save_interval', 1.5 / detection_fps)
        
        # 创建保存目录
        if self._save_image_enabled:
            self._ensure_save_dir()
        
        # 根据扩展名自动判断模型类型
        if model_path:
            ext = os.path.splitext(model_path)[1].lower()
            if ext == '.rknn':
                self.model_type = 'rknn'
            elif ext == '.onnx':
                self.model_type = 'onnx'
            elif ext == '.pt':
                self.model_type = 'yolo'
            # end2end 模型（内置NMS），输出格式 (N, 6) = (x1,y1,x2,y2,conf,cls)
            if 'end2end' in os.path.basename(model_path).lower():
                self.is_end2end = True
        
        self._load_model()
    
    def _load_model(self):
        """加载检测模型"""
        if self.model_type == 'rknn':
            self._load_rknn_model()
        elif self.model_type == 'onnx':
            self._load_onnx_model()
        else:
            self._load_yolo_model()
    
    def _load_rknn_model(self):
        """加载 RKNN 模型"""
        if not self.model_path:
            raise ValueError("RKNN 模型需要指定 model_path")
        
        try:
            from rknnlite.api import RKNNLite
            
            self.rknn = RKNNLite()
            ret = self.rknn.load_rknn(self.model_path)
            if ret != 0:
                raise RuntimeError(f"加载 RKNN 模型失败: {self.model_path}")
            
            ret = self.rknn.init_runtime(core_mask=RKNNLite.NPU_CORE_0_1_2)
            if ret != 0:
                raise RuntimeError(f"初始化 RKNN 运行时失败")
            
            print(f"RKNN 模型加载成功: {self.model_path}")
        except ImportError:
            raise ImportError("未安装 rknnlite，请运行: pip install rknnlite2")
    
    def _load_onnx_model(self):
        """加载 ONNX 模型"""
        if not self.model_path:
            raise ValueError("ONNX 模型需要指定 model_path")
        
        try:
            import onnxruntime as ort
            self.session = ort.InferenceSession(self.model_path)
            self.input_name = self.session.get_inputs()[0].name
            self.output_names = [o.name for o in self.session.get_outputs()]
            print(f"ONNX 模型加载成功: {self.model_path}, 输出数量={len(self.output_names)}")
        except ImportError:
            raise ImportError("未安装 onnxruntime，请运行: pip install onnxruntime")
    
    def _load_yolo_model(self):
        """加载YOLO11检测模型"""
        try:
            from ultralytics import YOLO
            
            if self.model_path:
                self.model = YOLO(self.model_path)
            else:
                model_name = f'yolo11{self.model_size}.pt'
                self.model = YOLO(model_name)
            
            dummy = np.zeros((640, 640, 3), dtype=np.uint8)
            self.model(dummy, device=self.device, verbose=False)
            
            print(f"成功加载YOLO11检测模型 (device={self.device})")
        except ImportError:
            print("未安装ultralytics,请运行: pip install ultralytics")
            self._load_opencv_model()
        except Exception as e:
            print(f"加载YOLO11模型失败: {e}")
            self._load_opencv_model()
    
    def _load_opencv_model(self):
        """使用OpenCV加载模型"""
        pass
    
    def _ensure_save_dir(self):
        """确保保存目录存在"""
        try:
            self._image_save_dir.mkdir(parents=True, exist_ok=True)
            logger.info(f"检测图片保存目录: {self._image_save_dir}")
        except Exception as e:
            logger.error(f"创建检测图片目录失败: {e}")
            self._save_image_enabled = False
    
    def _cleanup_old_images(self):
        """清理旧图片，保持目录下图片数量不超过上限"""
        try:
            image_files = list(self._image_save_dir.glob("*.jpg"))
            if len(image_files) > self._image_max_count:
                # 按修改时间排序，删除最旧的
                image_files.sort(key=lambda x: x.stat().st_mtime)
                to_delete = image_files[:len(image_files) - self._image_max_count]
                for f in to_delete:
                    f.unlink()
                logger.info(f"已清理 {len(to_delete)} 张旧检测图片")
        except Exception as e:
            logger.error(f"清理旧图片失败: {e}")
    
    def _save_detection_image(self, frame: np.ndarray, detections: List[DetectedObject]):
        """
        保存带有检测标记的图片（只标记达到置信度阈值的人）
        Args:
            frame: 原始图像
            detections: 检测结果列表
        """
        if not self._save_image_enabled or not detections:
            return
        
        # 检查保存间隔
        current_time = time.time()
        if current_time - self._last_save_time < self._save_interval:
            return
        
        try:
            # 复制图像避免修改原图
            marked_frame = frame.copy()
            
            # 置信度阈值（人员检测用更高阈值）
            person_threshold = self.config.get('person_threshold', 0.8)
            
            # 只标记达到阈值的人
            person_count = 0
            
            for det in detections:
                # 只处理人且达到阈值
                is_person = det.class_name in ['person']
                if not is_person:
                    continue
                
                # 未达阈值的不标记
                if det.confidence < person_threshold:
                    continue
                
                x, y, w, h = det.bbox
                
                # 绘制边界框（绿色）
                cv2.rectangle(marked_frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
                
                # 绘制序号标签
                label = f"person_{person_count}"
                person_count += 1
                
                (label_w, label_h), baseline = cv2.getTextSize(
                    label, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2
                )
                cv2.rectangle(
                    marked_frame, 
                    (x, y - label_h - 8),
                    (x + label_w, y),
                    (0, 255, 0), 
                    -1
                )
                
                # 绘制标签文字（黑色）
                cv2.putText(
                    marked_frame, label,
                    (x, y - 4),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.8,
                    (0, 0, 0), 2
                )
            
            
            # 无有效目标则不保存
            if person_count == 0:
                return
            
            
            # 生成文件名（时间戳+有效人数）
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
            filename = f"panorama_{timestamp}_n{person_count}.png"
            filepath = self._image_save_dir / filename
            
            # 保存图片（PNG无损格式，不压缩）
            cv2.imwrite(str(filepath), marked_frame)
            self._last_save_time = current_time
            
            logger.info(f"[全景] 已保存检测图片: {filepath}，有效人数 {person_count} (阈值={person_threshold})")
            
            # 定期清理旧图片
            self._cleanup_old_images()
            
        except Exception as e:
            logger.error(f"[全景] 保存检测图片失败: {e}")
    
    def _letterbox(self, image, size=(640, 640)):
        """Letterbox 预处理"""
        h0, w0 = image.shape[:2]
        ih, iw = size
        scale = min(iw / w0, ih / h0)
        new_w, new_h = int(w0 * scale), int(h0 * scale)
        pad_w = (iw - new_w) // 2
        pad_h = (ih - new_h) // 2
        resized = cv2.resize(image, (new_w, new_h))
        canvas = np.full((ih, iw, 3), 114, dtype=np.uint8)
        canvas[pad_h:pad_h+new_h, pad_w:pad_w+new_w] = resized
        return canvas, scale, pad_w, pad_h, h0, w0
    
    @staticmethod
    def _make_grid(h: int, w: int):
        """生成特征图网格坐标"""
        yv, xv = np.meshgrid(np.arange(h), np.arange(w), indexing='ij')
        return np.stack([xv, yv], axis=-1).reshape(-1, 2)

    @staticmethod
    def _pseudo_person_confidence(bboxes: np.ndarray, orig_h: int, orig_w: int) -> np.ndarray:
        """
        当 RKNN 模型 cls 输出恒定时，根据 bbox 形状生成伪置信度。
        bboxes: (N, 4) [x1, y1, x2, y2] 原始图像坐标
        """
        x1, y1, x2, y2 = bboxes[:, 0], bboxes[:, 1], bboxes[:, 2], bboxes[:, 3]
        w = np.maximum(1.0, x2 - x1)
        h = np.maximum(1.0, y2 - y1)
        aspect = h / w

        # 人体宽高比通常在 1.5 ~ 4.0 之间，以 2.5 为最佳
        aspect_score = np.exp(-0.5 * ((aspect - 2.5) / 1.0) ** 2)

        # 面积占画面比例，过大/过小都降权
        area = w * h
        img_area = orig_w * orig_h
        area_ratio = area / img_area
        size_score = np.clip(area_ratio * 80, 0.0, 1.0)  # 占画面 1.25% 以上得满分

        # 综合伪置信度，范围 0.55 ~ 0.95
        conf = 0.55 + 0.30 * aspect_score + 0.10 * size_score
        return conf

    def _decode_yolo11_outputs(self, outputs: list, canvas_size: tuple,
                                scale: float, pad_w: int, pad_h: int,
                                orig_h: int, orig_w: int,
                                conf_threshold: float = 0.5,
                                iou_threshold: float = 0.45) -> list:
        """
        解码 YOLO11 RKNN 多输出格式 (DFL bbox + cls + mask，每尺度 3 个输出)

        outputs: [bbox_80x80, cls_80x80, mask_80x80, bbox_40x40, cls_40x40, ...]
        返回: [[x1, y1, x2, y2, score, class_id], ...] （原始图像坐标）
        """
        strides = [8, 16, 32]
        reg_max = 16
        dets = []
        # 记录 cls 输出是否异常（常量），用于后续 fallback
        cls_constant = True

        for scale_idx, stride in enumerate(strides):
            bbox_out = outputs[scale_idx * 3]
            cls_out = outputs[scale_idx * 3 + 1]

            # 检测 cls 是否为常量（量化/导出异常导致）
            if np.ptp(cls_out) > 1e-4:
                cls_constant = False

            _, _, h, w = bbox_out.shape
            # (64, H, W) -> (H*W, 4, 16)
            bbox = bbox_out[0].transpose(1, 2, 0).reshape(h * w, 4, reg_max)
            # (80, H, W) -> (H*W, 80)
            cls = cls_out[0].transpose(1, 2, 0).reshape(h * w, 80)

            # DFL 解码
            prob = np.exp(bbox - np.max(bbox, axis=-1, keepdims=True))
            prob = prob / np.sum(prob, axis=-1, keepdims=True)
            bins = np.arange(reg_max).reshape(1, 1, reg_max)
            decoded = np.sum(prob * bins, axis=-1)  # (H*W, 4)

            # 网格中心
            grid = self._make_grid(h, w) + 0.5  # (H*W, 2)

            l, t, r, b = decoded[:, 0], decoded[:, 1], decoded[:, 2], decoded[:, 3]
            x1 = (grid[:, 0] - l) * stride
            y1 = (grid[:, 1] - t) * stride
            x2 = (grid[:, 0] + r) * stride
            y2 = (grid[:, 1] + b) * stride

            # cls sigmoid
            cls = 1.0 / (1.0 + np.exp(-cls))
            scores = np.max(cls, axis=1)
            labels = np.argmax(cls, axis=1)

            for i in range(len(scores)):
                if scores[i] < conf_threshold:
                    continue
                dets.append([x1[i], y1[i], x2[i], y2[i], scores[i], labels[i]])

        if not dets:
            return []

        dets = np.array(dets)

        # 从 canvas(640x640) 坐标映射回原始图像坐标：去 padding -> 除以 scale
        dets[:, [0, 2]] = (dets[:, [0, 2]] - pad_w) / scale
        dets[:, [1, 3]] = (dets[:, [1, 3]] - pad_h) / scale

        # clip
        dets[:, [0, 2]] = np.clip(dets[:, [0, 2]], 0, orig_w)
        dets[:, [1, 3]] = np.clip(dets[:, [1, 3]], 0, orig_h)

        # 若 cls 输出异常常量，用伪置信度替代，帮助 NMS 和后续过滤
        if cls_constant:
            pseudo_scores = self._pseudo_person_confidence(dets[:, :4], orig_h, orig_w)
            dets[:, 4] = pseudo_scores
            dets[:, 5] = 0  # 强制为 person 类别

        # NMS
        x1, y1, x2, y2 = dets[:, 0], dets[:, 1], dets[:, 2], dets[:, 3]
        scores = dets[:, 4]
        areas = (x2 - x1) * (y2 - y1)
        order = scores.argsort()[::-1]

        keep = []
        while order.size > 0:
            i = order[0]
            keep.append(i)

            xx1 = np.maximum(x1[i], x1[order[1:]])
            yy1 = np.maximum(y1[i], y1[order[1:]])
            xx2 = np.minimum(x2[i], x2[order[1:]])
            yy2 = np.minimum(y2[i], y2[order[1:]])

            w = np.maximum(0.0, xx2 - xx1)
            h = np.maximum(0.0, yy2 - yy1)
            inter = w * h
            iou = inter / (areas[i] + areas[order[1:]] - inter + 1e-6)

            inds = np.where(iou <= iou_threshold)[0]
            order = order[inds + 1]

        return dets[keep].tolist()

    def _detect_rknn(self, frame: np.ndarray) -> List[DetectedObject]:
        """使用 RKNN/ONNX 模型检测"""
        results = []
        h0, w0 = frame.shape[:2]

        # 宽幅图(宽高比>2.5)使用分区域检测，避免letterbox后人太小
        if w0 / h0 > 2.5:
            return self._detect_rknn_tiled(frame)

        try:
            conf_threshold = self.config['confidence_threshold']
            class_map = self.config.get('class_map', {0: 'person'})

            # -------------------------------------------------------
            # end2end 模型（内置NMS）：letterbox + NHWC 预处理
            # 输出格式 (N, max_det, 6) = (x1,y1,x2,y2,conf,cls) 在 letterbox 空间
            # -------------------------------------------------------
            if self.is_end2end:
                canvas, scale, pad_w, pad_h, h0, w0 = self._letterbox(frame)
                img = canvas[..., ::-1].astype(np.float32) / 255.0
                blob = img[None, ...]  # NHWC

                if hasattr(self, 'rknn'):
                    outputs = self.rknn.inference(inputs=[blob])
                else:
                    # ONNX 通常期望 NCHW，需转置
                    nchw = blob.transpose(0, 3, 1, 2)
                    outputs = self.session.run(None, {self.input_name: nchw})

                output = outputs[0]
                if len(output.shape) == 3:
                    output = output[0]

                for i in range(output.shape[0]):
                    x1_lb, y1_lb, x2_lb, y2_lb, conf, cls_id = output[i]
                    if conf < conf_threshold:
                        continue
                    cls_name = class_map.get(int(cls_id), str(int(cls_id)))
                    if cls_name not in self.config['target_classes']:
                        continue

                    # 从 letterbox 空间映射回原图
                    x1 = int((x1_lb - pad_w) / scale)
                    y1 = int((y1_lb - pad_h) / scale)
                    x2 = int((x2_lb - pad_w) / scale)
                    y2 = int((y2_lb - pad_h) / scale)
                    x1 = max(0, min(w0, x1))
                    y1 = max(0, min(h0, y1))
                    x2 = max(0, min(w0, x2))
                    y2 = max(0, min(h0, y2))

                    if x2 - x1 < 10 or y2 - y1 < 10:
                        continue

                    results.append(DetectedObject(
                        class_name=cls_name,
                        confidence=float(conf),
                        bbox=(x1, y1, x2 - x1, y2 - y1),
                        center=((x1 + x2) // 2, (y1 + y2) // 2)
                    ))
                return results

            # -------------------------------------------------------
            # 非 end2end 模型：letterbox + NHWC 预处理
            # -------------------------------------------------------
            canvas, scale, pad_w, pad_h, h0, w0 = self._letterbox(frame)

            if hasattr(self, 'rknn'):
                # RKNN
                img = canvas[..., ::-1].astype(np.float32) / 255.0
                blob = img[None, ...]
                outputs = self.rknn.inference(inputs=[blob])
            else:
                # ONNX
                img = canvas[..., ::-1].astype(np.float32) / 255.0
                img = img.transpose(2, 0, 1)
                blob = img[None, ...]
                outputs = self.session.run(None, {self.input_name: blob})

            # 根据输出数量判断格式：YOLO11 DFL 为 9 个输出（3 scales x 3 branches）
            if len(outputs) == 9:
                dets = self._decode_yolo11_outputs(
                    outputs, (640, 640), scale, pad_w, pad_h, h0, w0,
                    conf_threshold=conf_threshold
                )
                for x1, y1, x2, y2, score, cls_id in dets:
                    cls_name = class_map.get(int(cls_id), str(int(cls_id)))
                    if cls_name not in self.config['target_classes']:
                        continue
                    if x2 - x1 < 10 or y2 - y1 < 10:
                        continue
                    obj = DetectedObject(
                        class_name=cls_name,
                        confidence=float(score),
                        bbox=(int(x1), int(y1), int(x2 - x1), int(y2 - y1)),
                        center=(int((x1 + x2) / 2), int((y1 + y2) / 2))
                    )
                    results.append(obj)
            else:
                # 标准 (84, 8400) 格式（ONNX 或新 RKNN）
                output = outputs[0]
                if len(output.shape) == 3:
                    output = output[0]

                num_boxes = output.shape[1]
                candidates = []
                for i in range(num_boxes):
                    x_center = float(output[0, i])
                    y_center = float(output[1, i])
                    width = float(output[2, i])
                    height = float(output[3, i])

                    class_probs = output[4:, i]
                    best_class = int(np.argmax(class_probs))
                    confidence = float(class_probs[best_class])

                    if confidence < conf_threshold:
                        continue

                    x1 = int(((x_center - width / 2) - pad_w) / scale)
                    y1 = int(((y_center - height / 2) - pad_h) / scale)
                    x2 = int(((x_center + width / 2) - pad_w) / scale)
                    y2 = int(((y_center + height / 2) - pad_h) / scale)

                    x1 = max(0, min(w0, x1))
                    y1 = max(0, min(h0, y1))
                    x2 = max(0, min(w0, x2))
                    y2 = max(0, min(h0, y2))

                    if x2 - x1 < 10 or y2 - y1 < 10:
                        continue

                    cls_name = class_map.get(best_class, str(best_class))
                    if cls_name not in self.config['target_classes']:
                        continue

                    obj = DetectedObject(
                        class_name=cls_name,
                        confidence=confidence,
                        bbox=(x1, y1, x2 - x1, y2 - y1),
                        center=((x1 + x2) // 2, (y1 + y2) // 2)
                    )
                    candidates.append(obj)

                results = nms(candidates, iou_threshold=0.45)

        except Exception as e:
            logger.error(f"RKNN/ONNX 检测错误: {e}")
            import traceback
            logger.error(traceback.format_exc())

        return results

    def _detect_rknn_tiled(self, frame: np.ndarray) -> List[DetectedObject]:
        """分区域检测 - 将宽幅全景图分成多个重叠区域分别检测，提高远处目标识别率"""
        results = []
        h0, w0 = frame.shape[:2]
        conf_threshold = self.config['confidence_threshold']
        class_map = self.config.get('class_map', {0: 'person'})

        # 分3个重叠区域
        overlap = int(h0 * 0.2)
        regions = [
            (0, w0 // 3 + overlap),
            (w0 // 3 - overlap // 2, 2 * w0 // 3 + overlap // 2),
            (2 * w0 // 3 - overlap, w0),
        ]

        seen_centers = []

        for x_start, x_end in regions:
            crop = frame[:, x_start:x_end]
            ch, cw = crop.shape[:2]

            # end2end 模型：resize + NCHW
            if self.is_end2end:
                img = cv2.resize(crop, (640, 640))
                img = img.astype(np.float32) / 255.0
                if hasattr(self, 'rknn'):
                    outputs = self.rknn.inference(inputs=[img.transpose(2, 0, 1)[None, ...]])
                else:
                    outputs = self.session.run(None, {self.input_name: img.transpose(2, 0, 1)[None, ...]})
                output = outputs[0]
                if len(output.shape) == 3:
                    output = output[0]
                dets = []
                for i in range(output.shape[0]):
                    x1, y1, x2, y2, conf, cls_id = output[i]
                    if conf < conf_threshold:
                        continue
                    cls_name = class_map.get(int(cls_id), str(int(cls_id)))
                    if cls_name not in self.config['target_classes']:
                        continue
                    _x1 = int(x1 * cw / 640)
                    _y1 = int(y1 * ch / 640)
                    _x2 = int(x2 * cw / 640)
                    _y2 = int(y2 * ch / 640)
                    dets.append([_x1, _y1, _x2, _y2, float(conf), int(cls_id)])
            else:
                canvas, scale, pad_w, pad_h, ch, cw = self._letterbox(crop)

                if hasattr(self, 'rknn'):
                    img = canvas[..., ::-1].astype(np.float32) / 255.0
                    outputs = self.rknn.inference(inputs=[img[None, ...]])
                else:
                    img = canvas[..., ::-1].astype(np.float32) / 255.0
                    img = img.transpose(2, 0, 1)
                    outputs = self.session.run(None, {self.input_name: img[None, ...]})

                if len(outputs) == 9:
                    dets = self._decode_yolo11_outputs(
                        outputs, (640, 640), scale, pad_w, pad_h, ch, cw,
                        conf_threshold=conf_threshold
                    )
                else:
                    # 标准 (84, 8400) 格式
                    output = outputs[0]
                    if len(output.shape) == 3:
                        output = output[0]
                    dets = []
                    for i in range(output.shape[1]):
                        class_probs = output[4:, i]
                        best_class = int(np.argmax(class_probs))
                        confidence = float(class_probs[best_class])
                        if confidence < conf_threshold:
                            continue
                        x1 = output[0, i] - output[2, i] / 2
                        y1 = output[1, i] - output[3, i] / 2
                        x2 = output[0, i] + output[2, i] / 2
                        y2 = output[1, i] + output[3, i] / 2
                        dets.append([x1, y1, x2, y2, confidence, best_class])

                    # 从 canvas 坐标映射回 crop 坐标
                    dets = np.array(dets) if dets else np.zeros((0, 6))
                    dets[:, [0, 2]] = (dets[:, [0, 2]] - pad_w) / scale
                    dets[:, [1, 3]] = (dets[:, [1, 3]] - pad_h) / scale
                    dets = dets.tolist()

            for x1, y1, x2, y2, confidence, best_class in dets:
                cls_name = class_map.get(int(best_class), str(int(best_class)))
                if cls_name not in self.config['target_classes']:
                    continue

                # 转换到原图坐标（加上区域偏移）
                x1 = int(x1) + x_start
                y1 = int(y1)
                x2 = int(x2) + x_start
                y2 = int(y2)

                x1 = max(0, min(w0, x1))
                y1 = max(0, min(h0, y1))
                x2 = max(0, min(w0, x2))
                y2 = max(0, min(h0, y2))

                if x2 - x1 < 10 or y2 - y1 < 10:
                    continue

                # 去重：同一目标可能被相邻区域重复检测
                cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
                if any(abs(cx - sx) < 50 and abs(cy - sy) < 50 for sx, sy in seen_centers):
                    continue
                seen_centers.append((cx, cy))

                obj = DetectedObject(
                    class_name=cls_name,
                    confidence=float(confidence),
                    bbox=(x1, y1, x2 - x1, y2 - y1),
                    center=(cx, cy)
                )
                results.append(obj)

        return results
    
    def detect(self, frame: np.ndarray) -> List[DetectedObject]:
        """检测物体返回所有类别结果"""
        if frame is None:
            return []
    
        if hasattr(self, 'rknn') and self.rknn is not None:
            results = self._detect_rknn(frame)
            if results:
                self._log_detections("RKNN", results, frame)
                self._save_detection_image(frame, results)
            return results
        elif hasattr(self, 'session') and self.session is not None:
            results = self._detect_rknn(frame)
            if results:
                self._log_detections("ONNX", results, frame)
                self._save_detection_image(frame, results)
            return results
        elif self.model is not None:
            results = self._detect_yolo(frame)
            if results:
                self._log_detections("YOLO", results, frame)
                self._save_detection_image(frame, results)
            return results
        else:
            logger.error("[YOLO] 没有可用的检测模型")
            return []
    
    def _log_detections(self, model_type: str, results: List[DetectedObject], frame: np.ndarray):
        if not results:
            return
        class_counts = {}
        for r in results:
            class_counts[r.class_name] = class_counts.get(r.class_name, 0) + 1
        h, w = frame.shape[:2]
        logger.info(f"[YOLO] {model_type}: {len(results)}个目标 {class_counts} (帧尺寸={w}x{h})")
    
    def _detect_yolo(self, frame: np.ndarray) -> List[DetectedObject]:
        """使用 YOLO 模型检测"""
        results = []
        
        try:
            detections = self.model(
                frame, 
                device=self.device, 
                verbose=False,
                conf=self.config['confidence_threshold']
            )
            
            for det in detections:
                boxes = det.boxes
                if boxes is None:
                    continue
                    
                for i in range(len(boxes)):
                    cls_id = int(boxes.cls[i])
                    cls_name = det.names[cls_id]
                    
                    if cls_name not in self.config['target_classes']:
                        continue
                    
                    conf = float(boxes.conf[i])
                    
                    xyxy = boxes.xyxy[i].cpu().numpy()
                    x1, y1, x2, y2 = map(int, xyxy)
                    width = x2 - x1
                    height = y2 - y1
                    
                    if width < 10 or height < 10:
                        continue
                    
                    center_x = x1 + width // 2
                    center_y = y1 + height // 2
                    
                    obj = DetectedObject(
                        class_name=cls_name,
                        confidence=conf,
                        bbox=(x1, y1, width, height),
                        center=(center_x, center_y)
                    )
                    results.append(obj)
                    
        except Exception as e:
            logger.error(f"YOLO11检测错误: {e}")
        
        return results
    
    def detect_with_keypoints(self, frame: np.ndarray) -> List[DetectedObject]:
        """
        使用YOLO11-pose检测人体并返回关键点
        Args:
            frame: 输入图像
        Returns:
            带关键点的检测结果列表
        """
        return self.detect(frame)
    
    def detect_persons(self, frame: np.ndarray) -> List[DetectedObject]:
        """检测人体（支持中英文类别名）"""
        all_detections = self.detect(frame)
        person_classes = {'person', '人'}
        return [obj for obj in all_detections if obj.class_name in person_classes]
    
    def release(self):
        """释放模型资源"""
        if hasattr(self, 'rknn') and self.rknn:
            self.rknn.release()
            self.rknn = None
        self.model = None
        self.session = None