实时眨眼检测系统：100fps高帧率微动监测方案

论文来源： ResearchGate iLid系统
核心指标： 100fps帧率，检测眨眼时长、PERCLOS
发布时间： 2025年8月

---

核心技术

iLid低功耗实时眨眼检测系统，通过高帧率（100fps）捕捉眼部微动，实现眨眼时长和PERCLOS的精确测量。

关键突破：

1. 100fps高帧率（超越传统30fps）
2. 眨眼时长精确检测（误差<10ms）
3. PERCLOS实时计算
4. 低功耗设计（<1W）

---

技术原理

1. 高帧率vs低帧率对比

帧率	眨眼捕捉	时长精度	适用场景
30fps	遗漏快速眨眼	±33ms	静态场景
60fps	捕捉大部分	±16ms	一般驾驶
100fps	完整捕捉	±10ms	微睡眠检测

2. 眨眼参数定义

import numpy as np
from typing import Tuple, List
from dataclasses import dataclass

@dataclass
class BlinkEvent:
    """眨眼事件"""
    start_frame: int
    end_frame: int
    duration_ms: float
    max_closure: float  # 最大闭合度

class HighFrameRateBlinkDetector:
    """高帧率眨眼检测器"""
    
    def __init__(self, fps: int = 100):
        self.fps = fps
        
        # 眨眼参数
        self.min_blink_frames = 3  # 最少帧数（30ms）
        self.max_blink_frames = 40  # 最多帧数（400ms）
        
        # 闭合阈值
        self.closure_threshold = 0.3  # EAR阈值
    
    def detect_blinks(self, 
                      ear_sequence: np.ndarray,
                      timestamps: np.ndarray) -> List[BlinkEvent]:
        """
        检测眨眼事件
        
        Args:
            ear_sequence: (N,) EAR序列
            timestamps: (N,) 时间戳（秒）
        
        Returns:
            blinks: 眨眼事件列表
        """
        blinks = []
        
        # 1. 二值化（开/闭）
        is_closed = ear_sequence < self.closure_threshold
        
        # 2. 查找闭合区间
        closed_regions = self._find_closed_regions(is_closed)
        
        # 3. 过滤并记录
        for start, end in closed_regions:
            duration_frames = end - start
            
            # 过滤过短/过长
            if duration_frames < self.min_blink_frames:
                continue
            if duration_frames > self.max_blink_frames:
                continue
            
            # 计算时长（ms）
            duration_ms = duration_frames / self.fps * 1000.0
            
            # 计算最大闭合度
            max_closure = 1.0 - np.min(ear_sequence[start:end])
            
            blinks.append(BlinkEvent(
                start_frame=start,
                end_frame=end,
                duration_ms=duration_ms,
                max_closure=max_closure
            ))
        
        return blinks
    
    def _find_closed_regions(self, is_closed: np.ndarray) -> List[Tuple[int, int]]:
        """查找闭合区间"""
        regions = []
        
        in_blink = False
        start = 0
        
        for i, closed in enumerate(is_closed):
            if closed and not in_blink:
                # 开始闭合
                in_blink = True
                start = i
            elif not closed and in_blink:
                # 结束闭合
                in_blink = False
                regions.append((start, i))
        
        # 处理最后仍在闭合的情况
        if in_blink:
            regions.append((start, len(is_closed)))
        
        return regions
    
    def compute_blink_statistics(self, 
                                  blinks: List[BlinkEvent],
                                  window_sec: float = 60.0) -> Dict:
        """
        计算眨眼统计
        
        Args:
            blinks: 眨眼事件列表
            window_sec: 统计窗口（秒）
        
        Returns:
            stats: 统计结果
        """
        if len(blinks) == 0:
            return {
                'blink_rate': 0.0,
                'avg_duration': 0.0,
                'max_duration': 0.0,
                'perclos': 0.0
            }
        
        # 1. 眨眼频率（次/分钟）
        blink_rate = len(blinks) / window_sec * 60.0
        
        # 2. 平均时长
        durations = [b.duration_ms for b in blinks]
        avg_duration = np.mean(durations)
        max_duration = np.max(durations)
        
        # 3. PERCLOS（总闭眼时间/窗口时间）
        total_closed_ms = sum(durations)
        window_ms = window_sec * 1000.0
        perclos = total_closed_ms / window_ms * 100.0
        
        return {
            'blink_rate': blink_rate,
            'avg_duration': avg_duration,
            'max_duration': max_duration,
            'perclos': perclos
        }


# 测试
if __name__ == "__main__":
    detector = HighFrameRateBlinkDetector(fps=100)
    
    # 模拟100fps EAR序列（10秒）
    N = 1000  # 10秒
    
    # 正常眨眼
    ear = np.ones(N) * 0.35
    
    # 模拟5次眨眼
    for i in range(5):
        start = 100 + i * 150
        # 眨眼持续5帧（50ms）
        ear[start:start+5] = 0.15
    
    timestamps = np.arange(N) / 100.0
    
    # 检测
    blinks = detector.detect_blinks(ear, timestamps)
    
    print(f"检测到 {len(blinks)} 次眨眼")
    for i, blink in enumerate(blinks):
        print(f"  眨眼{i+1}: 时长={blink.duration_ms:.0f}ms")
    
    # 统计
    stats = detector.compute_blink_statistics(blinks, window_sec=10.0)
    print(f"\n统计结果:")
    print(f"  眨眼频率: {stats['blink_rate']:.1f} 次/分钟")
    print(f"  平均时长: {stats['avg_duration']:.0f}ms")
    print(f"  PERCLOS: {stats['perclos']:.1f}%")

---

性能指标

指标	30fps系统	100fps系统
眨眼检测率	85%	98%
时长精度	±33ms	±10ms
PERCLOS误差	5%	2%
微睡眠检测	不支持	支持

---

IMS开发启示

1. 硬件选型

组件	30fps方案	100fps方案
摄像头	OV2311	高帧率IR摄像头
处理器	低功耗MCU	QCS8255
成本	$15	$35

2. 与Euro NCAP对接

ENCAP场景	30fps支持	100fps支持
疲劳检测	✅	✅
微睡眠检测	❌	✅
快速眨眼	❌	✅

---

本文为高帧率眨眼检测系统的详细解读与代码实现。