TDGV时间仪表盘视线方差：认知分心检测的理论驱动方案

论文信息

项目	内容
论文标题	Temporal Dashboard Gaze Variance (TDGV) Changes for Measuring Cognitive Distraction While Driving
作者	Cyril Marx, Elem Güzel Kalayci, Peter Moertl
期刊	Sensors 2022, 22(23), 9556
DOI	10.3390/s22239556
PMC	PMC9740877

核心创新

TDGV 是首个基于时间控制理论的认知分心检测方法，仅通过视线在仪表盘区域的时序方差变化即可检测认知分心。

特性	说明
理论基础	时间控制理论 (Temporal Control Theory)
检测信号	仪表盘视线时序方差 (TDGV)
检测对象	认知分心（”mind off the road”）
验证方式	实地驾驶 + 模拟器双验证
核心优势	仅需视线追踪，无需生理传感器

方法详解

1. 理论基础：时间控制理论

"""
TDGV: 时间仪表盘视线方差
基于时间控制理论 (Moertl & Moore, 2018)

核心假设:
- 驾驶是周期性控制任务，驾驶员通过仪表盘扫视维持控制
- 认知分心破坏时间控制节奏 → 方差变化
- TDGV = 仪表盘扫视时间间隔的方差

依赖: numpy, scipy
"""

import numpy as np
from scipy import stats
from typing import List, Tuple

class TDGVDetector:
    """
    Temporal Dashboard Gaze Variance (TDGV) 认知分心检测器
    
    算法流程:
    1. 检测仪表盘扫视事件 (gaze enters dashboard AOI)
    2. 计算连续扫视间的时间间隔
    3. 在滑动窗口内计算时间间隔的方差 (TDGV)
    4. 与基线比较，方差显著变化 = 认知分心
    
    参考: Marx, C. et al. (2022). Sensors, 22(23), 9556.
    """
    
    def __init__(self, 
                 sampling_rate: int = 60,
                 window_size_sec: int = 60,
                 baseline_window_sec: int = 300,
                 dashboard_aoi: Tuple[float, float, float, float] = None):
        """
        Args:
            sampling_rate: 眼动仪采样率 (Hz)
            window_size_sec: TDGV计算窗口 (秒)
            baseline_window_sec: 基线建立窗口 (秒)
            dashboard_aoi: 仪表盘AOI (x_min, y_min, x_max, y_max) 归一化坐标
        """
        self.fs = sampling_rate
        self.window_size = int(window_size_sec * sampling_rate)
        self.baseline_window = int(baseline_window_sec * sampling_rate)
        
        # 默认仪表盘区域 (归一化坐标)
        if dashboard_aoi is None:
            self.dashboard_aoi = (0.3, 0.5, 0.7, 0.9)
        else:
            self.dashboard_aoi = dashboard_aoi
        
    def detect_dashboard_gaze_events(self, 
                                     gaze_x: np.ndarray, 
                                     gaze_y: np.ndarray) -> np.ndarray:
        """
        检测仪表盘扫视事件
        
        Args:
            gaze_x: (N,) 水平视线位置 (归一化 0-1)
            gaze_y: (N,) 垂直视线位置 (归一化 0-1)
            
        Returns:
            event_indices: 仪表盘扫视开始的帧索引
        """
        x_min, y_min, x_max, y_max = self.dashboard_aoi
        
        # 判断是否在仪表盘AOI内
        in_dashboard = (
            (gaze_x >= x_min) & (gaze_x <= x_max) &
            (gaze_y >= y_min) & (gaze_y <= y_max)
        )
        
        # 检测进入仪表盘的事件 (上升沿)
        events = []
        prev_in = False
        for i, curr_in in enumerate(in_dashboard):
            if curr_in and not prev_in:
                events.append(i)
            prev_in = curr_in
        
        return np.array(events)
    
    def calculate_tdgv(self, event_indices: np.ndarray) -> np.ndarray:
        """
        计算TDGV (时间仪表盘视线方差)
        
        核心公式:
            intervals = diff(event_times)  # 连续扫视的时间间隔
            TDGV = variance(intervals) in sliding window
        
        Args:
            event_indices: 仪表盘扫视事件的帧索引
            
        Returns:
            tdgv_values: (M,) TDGV值序列
        """
        if len(event_indices) < 3:
            return np.array([])
        
        # 计算扫视间的时间间隔 (秒)
        event_times = event_indices / self.fs
        intervals = np.diff(event_times)
        
        # 滑动窗口计算方差
        tdgv_values = []
        for i in range(len(intervals) - self.window_size + 1):
            window = intervals[i:i + self.window_size]
            tdgv = np.var(window)
            tdgv_values.append(tdgv)
        
        return np.array(tdgv_values)
    
    def detect_cognitive_distraction(self,
                                     gaze_x: np.ndarray,
                                     gaze_y: np.ndarray) -> dict:
        """
        完整的认知分心检测流程
        
        Args:
            gaze_x: (N,) 水平视线位置
            gaze_y: (N,) 垂直视线位置
            
        Returns:
            result: dict, 包含:
                - tdgv_baseline: 基线TDGV
                - tdgv_current: 当前TDGV
                - distraction_score: 分心分数 (0-1)
                - is_distracted: bool
                - confidence: 置信度
        """
        # 1. 检测仪表盘扫视事件
        events = self.detect_dashboard_gaze_events(gaze_x, gaze_y)
        
        if len(events) < 10:
            return {
                'tdgv_baseline': 0, 'tdgv_current': 0,
                'distraction_score': 0, 'is_distracted': False,
                'confidence': 0, 'message': 'Insufficient events'
            }
        
        # 2. 计算TDGV
        tdgv = self.calculate_tdgv(events)
        
        if len(tdgv) < 2:
            return {
                'tdgv_baseline': 0, 'tdgv_current': 0,
                'distraction_score': 0, 'is_distracted': False,
                'confidence': 0, 'message': 'Insufficient TDGV data'
            }
        
        # 3. 建立基线 (前baseline_window)
        baseline_end = min(self.baseline_window, len(tdgv))
        tdgv_baseline = np.mean(tdgv[:baseline_end])
        
        # 4. 当前状态 (最后window_size个样本)
        tdgv_current = np.mean(tdgv[-self.window_size:])
        
        # 5. 计算分心分数
        # 认知分心导致TDGV显著变化 (通常增大)
        if tdgv_baseline > 0:
            distraction_score = abs(
                tdgv_current - tdgv_baseline
            ) / tdgv_baseline
        else:
            distraction_score = 0
        
        # 6. 统计检验 (t-test)
        if len(tdgv) >= 2 * self.window_size:
            baseline_data = tdgv[:self.window_size]
            current_data = tdgv[-self.window_size:]
            t_stat, p_value = stats.ttest_ind(
                baseline_data, current_data
            )
            is_significant = p_value < 0.05
        else:
            p_value = 1.0
            is_significant = False
        
        is_distracted = distraction_score > 0.5 and is_significant
        
        return {
            'tdgv_baseline': tdgv_baseline,
            'tdgv_current': tdgv_current,
            'distraction_score': min(distraction_score, 1.0),
            'is_distracted': is_distracted,
            'confidence': 1 - p_value,
            'p_value': p_value,
            'num_events': len(events),
            'num_tdgv_samples': len(tdgv),
        }


# ========== 测试 ==========
if __name__ == "__main__":
    np.random.seed(42)
    
    detector = TDGVDetector(
        sampling_rate=60,
        window_size_sec=30,      # 30秒窗口
        baseline_window_sec=120,  # 2分钟基线
    )
    
    print("=" * 60)
    print("TDGV 认知分心检测器测试")
    print("=" * 60)
    
    # --- 模拟正常驾驶 ---
    # 定期扫视仪表盘 (约每3-5秒一次)
    n_samples = 300 * 60  # 5分钟, 60Hz
    normal_gaze_x = np.random.normal(0.5, 0.15, n_samples)
    normal_gaze_y = np.random.normal(0.3, 0.12, n_samples)
    
    # 模拟正常仪表盘扫视 (规律性)
    for t in range(0, n_samples, int(60 * np.random.uniform(3, 5))):
        # 扫视仪表盘约0.5秒
        duration = int(0.5 * 60)
        end = min(t + duration, n_samples)
        normal_gaze_x[t:end] = np.random.uniform(0.35, 0.65, end-t)
        normal_gaze_y[t:end] = np.random.uniform(0.55, 0.85, end-t)
    
    result_normal = detector.detect_cognitive_distraction(
        normal_gaze_x, normal_gaze_y
    )
    print(f"\n正常驾驶:")
    for k, v in result_normal.items():
        print(f"  {k}: {v}")
    
    # --- 模拟认知分心驾驶 ---
    distracted_gaze_x = np.random.normal(0.5, 0.10, n_samples)  # 更集中
    distracted_gaze_y = np.random.normal(0.25, 0.08, n_samples)
    
    # 模拟认知分心时的不规则扫视 (时序被打乱)
    for t in range(0, n_samples, int(60 * np.random.uniform(1, 12))):
        duration = int(0.3 * 60)
        end = min(t + duration, n_samples)
        distracted_gaze_x[t:end] = np.random.uniform(0.35, 0.65, end-t)
        distracted_gaze_y[t:end] = np.random.uniform(0.55, 0.85, end-t)
    
    result_distracted = detector.detect_cognitive_distraction(
        distracted_gaze_x, distracted_gaze_y
    )
    print(f"\n认知分心驾驶:")
    for k, v in result_distracted.items():
        print(f"  {k}: {v}")
    
    # --- 对比 ---
    print(f"\n{'='*60}")
    print(f"对比分析:")
    print(f"  正常 TDGV基线: {result_normal['tdgv_baseline']:.4f}")
    print(f"  正常 TDGV当前: {result_normal['tdgv_current']:.4f}")
    print(f"  分心 TDGV基线: {result_distracted['tdgv_baseline']:.4f}")
    print(f"  分心 TDGV当前: {result_distracted['tdgv_current']:.4f}")
    print(f"  正常分心分数: {result_normal['distraction_score']:.4f}")
    print(f"  分心分心分数: {result_distracted['distraction_score']:.4f}")
    print(f"  正常是否分心: {result_normal['is_distracted']}")
    print(f"  分心是否分心: {result_distracted['is_distracted']}")

2. TDGV vs 其他认知分心检测方法

方法	信号源	优势	劣势	准确率	实时性
TDGV	仪表盘扫视方差	仅需视线追踪，理论驱动	需要建立基线	~75%	30-60s延迟
眼动熵	视线分布熵	无需基线	受场景影响	~70%	10-30s
瞳孔直径	瞳孔变化	生理直接信号	需IR摄像头，受光照影响	~65%	5-10s
驾驶操作	方向盘微修正	无需额外传感器	受路面影响大	~60%	30-60s
EEG/EEG替代	脑电信号	直接测量认知负荷	不可车载	~80%	实时
多模态融合	多源融合	最高准确率	复杂，成本高	~85%	10-30s

3. 论文实验设计

实验	类型	受试者	时长	认知任务
实验1	实地驾驶	N=24	40min/人	音频n-back任务
实验2	模拟器	N=32	60min/人	数学计算+对话
验证	双重验证	-	-	跨场景一致性

关键结果

指标	正常驾驶	认知分心	p值
TDGV	基线方差 σ²₀	显著增加 (×1.5-2.5)	<0.01
仪表盘扫视频率	12-18次/分钟	减少 30-50%	<0.05
扫视时间间隔标准差	2-4秒	增加 50-100%	<0.01
检测延迟	-	30-60秒	-

IMS 开发启示

1. TDGV集成架构

2. 与IMS现有疲劳检测的协同

class IMSCognitiveDistractionModule:
    """
    IMS 认知分心检测模块
    集成 TDGV + 眼动熵 + 瞳孔直径
    """
    
    def __init__(self):
        self.tdgv = TDGVDetector(
            sampling_rate=60,
            window_size_sec=30,
            baseline_window_sec=180,
        )
        self.gaze_entropy_window = 60  # 60秒窗口
        self.pupil_baseline = None
        
    def detect(self, gaze_data, pupil_data=None):
        """
        多特征认知分心检测
        
        Args:
            gaze_data: dict with 'x', 'y' arrays (60Hz)
            pupil_data: optional (N,) pupil diameter
            
        Returns:
            result: dict with distraction_level, score, features
        """
        result = {}
        
        # 1. TDGV 检测 (主信号)
        tdgv_result = self.tdgv.detect_cognitive_distraction(
            gaze_data['x'], gaze_data['y']
        )
        result['tdgv_score'] = tdgv_result['distraction_score']
        
        # 2. 眼动熵 (辅助信号)
        entropy = self._compute_gaze_entropy(
            gaze_data['x'], gaze_data['y']
        )
        result['gaze_entropy'] = entropy
        
        # 3. 瞳孔直径 (可选)
        if pupil_data is not None and self.pupil_baseline is not None:
            pupil_change = (
                np.mean(pupil_data) - self.pupil_baseline
            ) / self.pupil_baseline
            result['pupil_change'] = pupil_change
        else:
            result['pupil_change'] = 0
        
        # 4. 融合决策
        score = (
            0.5 * result['tdgv_score'] +
            0.3 * (1 - min(entropy / 3.0, 1.0)) +  # 低熵=隧道视觉
            0.2 * min(abs(result['pupil_change']), 1.0)
        )
        
        result['total_score'] = score
        result['distraction_level'] = self._classify(score)
        
        return result
    
    def _compute_gaze_entropy(self, x, y, bins=20):
        """计算视线分布2D熵"""
        hist, _, _ = np.histogram2d(x, y, bins=bins)
        hist = hist / hist.sum()
        from scipy.stats import entropy
        return entropy(hist.flatten())
    
    def _classify(self, score):
        """分类分心等级"""
        if score < 0.2:
            return 0  # 正常
        elif score < 0.5:
            return 1  # 轻度分心 (一级警告)
        else:
            return 2  # 严重分心 (二级警告)


# 测试
if __name__ == "__main__":
    module = IMSCognitiveDistractionModule()
    
    # 模拟数据
    np.random.seed(42)
    n = 300 * 60  # 5分钟
    gaze = {
        'x': np.random.normal(0.5, 0.1, n),
        'y': np.random.normal(0.3, 0.08, n),
    }
    pupil = np.random.normal(4.0, 0.3, n)
    
    # 建立基线
    module.pupil_baseline = np.mean(pupil[:180*60])
    
    result = module.detect(gaze, pupil)
    print("IMS 认知分心检测结果:")
    for k, v in result.items():
        print(f"  {k}: {v:.4f}" if isinstance(v, float) else f"  {k}: {v}")

3. 硬件需求

组件	型号	参数	说明
眼动仪	Tobii Pro Nano	60Hz, 精度0.3°	已有
IR摄像头	OV9282	1MP, 120fps	瞳孔检测
处理器	QCS8255	26 TOPS	TDGV计算量极低
内存	4GB DDR4	-	1分钟窗口约1KB

4. TDGV的局限性

局限	描述	IMS缓解方案
检测延迟30-60秒	需要足够事件建立统计	多模态融合加速
需要建立基线	每个驾驶员不同	前5分钟自动校准
仅限认知分心	不检测视觉/手动分心	已有视线偏离检测
仪表盘依赖	需要仪表盘AOI定义	自适应AOI校准
个体差异	不同人扫视模式不同	个性化阈值

5. 与Euro NCAP 2026的对接

Euro NCAP 2026 DSM 要求认知分心检测，但尚未给出具体技术路线。TDGV 提供理论驱动的方案：

Euro NCAP要求	TDGV方案	可行性
检测认知分心	TDGV方差变化	✅ 已验证
实时警告	30-60秒内检测	⚠️ 需多模态加速
个性化适配	5分钟基线建立	✅ 可行
车载部署	仅需眼动追踪	✅ 低算力需求

参考文献

1. Marx, C., Kalayci, E.G., Moertl, P. “Temporal Dashboard Gaze Variance (TDGV) Changes for Measuring Cognitive Distraction While Driving.” Sensors 2022, 22(23), 9556. DOI: 10.3390/s22239556
2. Moertl, P., Moore, C. “Temporal Control Theory: A novel timing framework.” 2018.
3. Euro NCAP 2026 DSM Protocol - Cognitive Distraction requirements.

---

TDGV 的核心价值在于它是少数有心理学理论支撑的认知分心检测方法。虽然30-60秒的检测延迟对紧急场景偏慢，但作为认知分心的”慢速通道”与眼动熵的”快速通道”配合，可以形成完整的认知分心检测体系。建议IMS中实现TDGV作为认知分心检测的核心算法之一。