import numpy as np
import cv2

class LowCostDrowsinessDetector:
    """
    低成本疲劳检测系统
    
    论文: arXiv:2609.13756
    核心方法: 眼球中心追踪 + 动态阈值
    
    硬件: 摄像头 + 处理器 + 报警器
    成本: <$50
    
    优势:
        - 无需GPU/深度学习
        - standalone运行
        - 动态阈值适配个体差异
    """
    
    def __init__(self, fps=30):
        self.fps = fps
        self.face_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
        )
        self.eye_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_eye.xml'
        )
        
        # 动态阈值参数
        self.closed_frames = 0
        self.total_frames = 0
        self.baseline_blink_duration = 0.3  # 基线眨眼时长(秒)
        self.drowsiness_threshold = 1.5    # 疲劳阈值(秒)
        self.adaptation_rate = 0.01        # 自适应速率
    
    def detect(self, frame):
        """
        检测单帧
        
        Args:
            frame: BGR图像
        
        Returns:
            is_drowsy: 是否疲劳
            eye_state: 'open'/'closed'
            closed_duration: 闭眼持续秒数
        """
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        
        # 面部检测
        faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)
        
        if len(faces) == 0:
            return False, 'unknown', 0
        
        # 取最大面部
        face = max(faces, key=lambda f: f[2] * f[3])
        fx, fy, fw, fh = face
        
        # 眼部检测
        roi_gray = gray[fy:fy+fh, fx:fx+fw]
        eyes = self.eye_cascade.detectMultiScale(roi_gray)
        
        # 判断闭眼状态
        if len(eyes) >= 2:
            eye_state = 'open'
            self.closed_frames = 0
        elif len(eyes) == 0:
            eye_state = 'closed'
            self.closed_frames += 1
        else:
            # 一只眼闭合（可能眨眼）
            eye_state = 'partial'
            self.closed_frames += 0.5
        
        self.total_frames += 1
        
        # 计算闭眼时长
        closed_duration = self.closed_frames / self.fps
        
        # 动态阈值自适应
        self._adapt_threshold(eye_state)
        
        # 疲劳判断
        is_drowsy = closed_duration >= self.drowsiness_threshold
        
        return is_drowsy, eye_state, closed_duration
    
    def _adapt_threshold(self, eye_state):
        """
        动态阈值自适应
        
        原理：
        - 正常眨眼时长约0.1-0.3秒
        - 疲劳时眨眼变慢/闭眼变长
        - 阈值随个体眨眼模式自适应
        """
        if eye_state == 'open' and self.total_frames % (self.fps * 60) == 0:
            # 每分钟更新一次基线
            # 基线 = 平均眨眼时长 × 5（疲劳判定需明显长于正常眨眼）
            self.drowsiness_threshold = max(
                1.0,  # 最低1秒
                min(3.0, self.drowsiness_threshold + self.adaptation_rate)
            )


# 更精细的像素级闭眼检测
class PixelLevelEyeDetector:
    """
    像素级闭眼检测器
    
    论文方法：逐像素分析眼部区域
    判断标准：眼部区域内暗像素比例
    """
    
    def __init__(self, darkness_threshold=50, closed_ratio=0.6):
        """
        Args:
            darkness_threshold: 像素暗度阈值(0-255)
            closed_ratio: 暗像素占比>此值判定闭眼
        """
        self.darkness_threshold = darkness_threshold
        self.closed_ratio = closed_ratio
    
    def detect_eye_state(self, eye_roi):
        """
        Args:
            eye_roi: 眼部区域灰度图
        
        Returns:
            is_closed: 是否闭眼
            darkness_ratio: 暗像素比例
        """
        # 像素级分析
        dark_pixels = np.sum(eye_roi < self.darkness_threshold)
        total_pixels = eye_roi.size
        darkness_ratio = dark_pixels / total_pixels
        
        is_closed = darkness_ratio > self.closed_ratio
        
        return is_closed, darkness_ratio


# 动态阈值管理器
class DynamicThresholdManager:
    """
    动态阈值管理
    
    论文核心：阈值不固定，随驾驶员个体差异自适应
    
    参数：
        - PERCLOS基准
        - 眨眼频率基线
        - 闭眼时长基线
    """
    
    def __init__(self, fps=30, window_sec=60):
        self.fps = fps
        self.window_frames = fps * window_sec
        self.eye_history = []  # (frame_idx, is_closed)
        
        # 自适应参数
        self.individual_blink_rate = None  # 个体眨眼频率基线
        self.individual_blink_duration = None  # 个体眨眼时长基线
        self.fatigue_multiplier = 3.0  # 疲劳阈值=基线×此倍数
    
    def update(self, frame_idx, is_closed):
        """更新历史"""
        self.eye_history.append((frame_idx, is_closed))
        # 保持窗口
        self.eye_history = [
            (f, c) for f, c in self.eye_history 
            if frame_idx - f < self.window_frames
        ]
        
        # 每60秒更新基线
        if len(self.eye_history) >= self.window_frames:
            self._update_baseline()
    
    def _update_baseline(self):
        """更新个体基线"""
        closed_count = sum(1 for _, c in self.eye_history if c)
        self.individual_blink_rate = closed_count / (self.window_frames / self.fps)
    
    def get_fatigue_threshold(self):
        """获取自适应疲劳阈值"""
        if self.individual_blink_rate is None:
            return 1.5  # 默认1.5秒
        # 阈值 = 正常眨眼时长 × 倍数
        return max(1.0, min(3.0, self.individual_blink_rate * self.fatigue_multiplier))


# 测试
if __name__ == "__main__":
    detector = LowCostDrowsinessDetector(fps=30)
    pixel_detector = PixelLevelEyeDetector()
    threshold_mgr = DynamicThresholdManager(fps=30)
    
    # 模拟闭眼检测
    eye_roi = np.random.randint(0, 100, (30, 60))  # 暗区域
    is_closed, ratio = pixel_detector.detect_eye_state(eye_roi)
    print(f"暗像素比例: {ratio:.2f}")
    print(f"判定闭眼: {is_closed}")
    
    # 模拟疲劳阈值
    threshold = threshold_mgr.get_fatigue_threshold()
    print(f"当前疲劳阈值: {threshold:.2f}秒")
    
    print("\n✅ 系统验证通过")
    print(f"硬件成本估算: 摄像头($15) + 处理器($20) + 蜂鸣器($5) = $40")