眼动模式识别认知分心：注视时长+扫视幅度+扫描路径规律性

眼动模式识别认知分心：注视时长+扫视幅度+扫描路径规律性

核心发现

arXiv 2604.05475 提出的眼动行为分析：

指标 正常驾驶 认知分心
注视时长 300-500ms 200-300ms（变短）
扫视幅度 5-15° 3-8°（变小）
扫描路径规律性 高（检查镜） 低（不规则）
视线集中度 分散 集中于中心

研究背景

视觉分心 vs 认知分心

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
两种分心的区别：

┌─────────────────────────────────────────────────────┐
│           视觉分心                                  │
├─────────────────────────────────────────────────────┤
│                                                     │
│  定义：视线离开道路                                 │
│  示例：看手机、看导航、看后座                       │
│                                                     │
│  检测方法：                                         │
│  ✅ 视线方向检测                                    │
│  ✅ 头部姿态检测                                    │
│  ✅ 视线偏离道路时长                                │
│                                                     │
│  检测难度：低（直接观测）                           │
│                                                     │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│           认知分心                                  │
├─────────────────────────────────────────────────────┤
│                                                     │
│  定义：视线在道路，但思维不在                       │
│  示例：发呆、思考问题、情绪波动                     │
│                                                     │
│  检测方法：                                         │
│  ⚠️ 视线方向无法检测                               │
│  ✅ 眼动模式分析                                    │
│  ✅ 注视时长变化                                    │
│  ✅ 扫描路径规律性                                  │
│                                                     │
│  检测难度：高（需要行为建模）                       │
│                                                     │
└─────────────────────────────────────────────────────┘

眼动特征详解

1. 注视时长 (Fixation Duration)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
"""
注视时长分析

认知分心时注视时长变短
"""

import numpy as np

def calculate_fixation_duration(
    gaze_points: np.ndarray,
    timestamps: np.ndarray,
    velocity_threshold: float = 30.0  # deg/s
) -> np.ndarray:
    """
    计算注视时长
    
    Args:
        gaze_points: (N, 2) 视线点序列 (度)
        timestamps: (N,) 时间戳序列 (秒)
        velocity_threshold: 速度阈值，低于此值视为注视
        
    Returns:
        fixation_durations: 注视时长数组 (毫秒)
    """
    # 计算视线速度
    dt = np.diff(timestamps)
    dx = np.diff(gaze_points[:, 0])
    dy = np.diff(gaze_points[:, 1])
    
    velocity = np.sqrt(dx**2 + dy**2) / dt
    
    # 识别注视段
    is_fixation = velocity < velocity_threshold
    
    # 计算注视时长
    fixation_durations = []
    current_duration = 0
    
    for i, fix in enumerate(is_fixation):
        if fix:
            current_duration += dt[i] * 1000  # 转换为毫秒
        else:
            if current_duration > 50:  # 最小注视时长 50ms
                fixation_durations.append(current_duration)
            current_duration = 0
            
    return np.array(fixation_durations)


# 认知分心判断
def detect_cognitive_distraction_by_fixation(
    fixation_durations: np.ndarray,
    baseline_mean: float = 400.0,  # 基线平均注视时长 (ms)
    threshold_ratio: float = 0.75
) -> bool:
    """
    根据注视时长检测认知分心
    
    Args:
        fixation_durations: 注视时长数组
        baseline_mean: 基线平均注视时长
        threshold_ratio: 阈值比例
        
    Returns:
        is_cognitive_distraction: 是否认知分心
    """
    current_mean = np.mean(fixation_durations)
    
    # 认知分心时注视时长变短
    if current_mean < baseline_mean * threshold_ratio:
        return True
        
    return False

2. 扫视幅度 (Saccade Amplitude)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
"""
扫视幅度分析

认知分心时扫视幅度变小
"""

def calculate_saccade_amplitude(
    gaze_points: np.ndarray,
    velocity_threshold: float = 30.0  # deg/s
) -> np.ndarray:
    """
    计算扫视幅度
    
    Args:
        gaze_points: (N, 2) 视线点序列 (度)
        velocity_threshold: 速度阈值，高于此值视为扫视
        
    Returns:
        saccade_amplitudes: 扫视幅度数组 (度)
    """
    # 计算视线速度
    # ...（同上）
    
    # 识别扫视段
    is_saccade = velocity > velocity_threshold
    
    # 计算扫视幅度
    saccade_amplitudes = []
    saccade_start = None
    
    for i, sac in enumerate(is_saccade):
        if sac and saccade_start is None:
            saccade_start = i
        elif not sac and saccade_start is not None:
            # 计算扫视幅度
            start_point = gaze_points[saccade_start]
            end_point = gaze_points[i-1]
            amplitude = np.linalg.norm(end_point - start_point)
            saccade_amplitudes.append(amplitude)
            saccade_start = None
            
    return np.array(saccade_amplitudes)

3. 扫描路径规律性 (Scanpath Regularity)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
"""
扫描路径规律性分析

认知分心时扫描路径更不规则
"""

def calculate_scanpath_regularity(
    gaze_points: np.ndarray,
    grid_size: int = 10
) -> float:
    """
    计算扫描路径规律性
    
    使用熵度量：熵越低，规律性越高
    
    Args:
        gaze_points: (N, 2) 视线点序列 (归一化 0-1)
        grid_size: 网格大小
        
    Returns:
        regularity: 规律性得分 (0-1)
    """
    # 将视线点映射到网格
    grid_x = (gaze_points[:, 0] * grid_size).astype(int)
    grid_y = (gaze_points[:, 1] * grid_size).astype(int)
    
    # 限制在网格范围内
    grid_x = np.clip(grid_x, 0, grid_size - 1)
    grid_y = np.clip(grid_y, 0, grid_size - 1)
    
    # 计算转移矩阵
    n_cells = grid_size * grid_size
    transition_matrix = np.zeros((n_cells, n_cells))
    
    for i in range(len(gaze_points) - 1):
        from_cell = grid_x[i] + grid_y[i] * grid_size
        to_cell = grid_x[i+1] + grid_y[i+1] * grid_size
        transition_matrix[from_cell, to_cell] += 1
        
    # 归一化
    row_sums = transition_matrix.sum(axis=1, keepdims=True)
    transition_matrix = transition_matrix / (row_sums + 1e-10)
    
    # 计算熵
    entropy = -np.sum(transition_matrix * np.log(transition_matrix + 1e-10))
    
    # 归一化到 0-1
    max_entropy = np.log(n_cells)
    regularity = 1 - entropy / max_entropy
    
    return regularity

完整检测系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
"""
认知分心检测系统

多指标融合判断
"""

class CognitiveDistractionDetector:
    """
    认知分心检测器
    """
    
    def __init__(self):
        # 基线参数（需根据驾驶员校准）
        self.baseline = {
            'fixation_duration_mean': 400.0,  # ms
            'fixation_duration_std': 100.0,
            'saccade_amplitude_mean': 8.0,    # deg
            'saccade_amplitude_std': 3.0,
            'scanpath_regularity': 0.6
        }
        
        # 窗口大小
        self.window_size = 10.0  # 秒
        
    def detect(
        self,
        gaze_points: np.ndarray,
        timestamps: np.ndarray
    ) -> dict:
        """
        检测认知分心
        
        Args:
            gaze_points: (N, 2) 视线点序列
            timestamps: (N,) 时间戳序列
            
        Returns:
            {
                'is_distracted': bool,
                'fixation_score': float,
                'saccade_score': float,
                'regularity_score': float,
                'confidence': float
            }
        """
        # 1. 计算各指标
        fixation_durations = calculate_fixation_duration(gaze_points, timestamps)
        saccade_amplitudes = calculate_saccade_amplitude(gaze_points, timestamps)
        regularity = calculate_scanpath_regularity(gaze_points)
        
        # 2. 计算得分（归一化）
        fixation_mean = np.mean(fixation_durations)
        fixation_score = 1 - fixation_mean / self.baseline['fixation_duration_mean']
        
        saccade_mean = np.mean(saccade_amplitudes)
        saccade_score = 1 - saccade_mean / self.baseline['saccade_amplitude_mean']
        
        regularity_score = 1 - regularity / self.baseline['scanpath_regularity']
        
        # 3. 融合判断
        # 认知分心时：注视时长↓、扫视幅度↓、规律性↓
        # 所以三个得分都应该为正
        combined_score = (fixation_score + saccade_score + regularity_score) / 3
        
        is_distracted = combined_score > 0.25  # 阈值
        
        return {
            'is_distracted': is_distracted,
            'fixation_score': fixation_score,
            'saccade_score': saccade_score,
            'regularity_score': regularity_score,
            'confidence': abs(combined_score)
        }

Euro NCAP 合规

认知分心测试场景

Euro NCAP 场景 检测方法 时延要求
D-06 认知分心 眼动模式分析 ≤5秒

检测流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Euro NCAP 认知分心检测：

1. 建立基线
   ├─ 驾驶员校准（30秒正常驾驶）
   ├─ 注视时长基线
   ├─ 扫视幅度基线
   └─ 扫描路径规律性基线

2. 实时检测
   ├─ 滑动窗口分析（10秒）
   ├─ 计算各指标偏离度
   └─ 多指标融合判断

3. 警告触发
   ├─ 一级警告：视觉 + 声音
   └─ 二级警告：座椅震动

IMS 开发启示

1. 集成到 DMS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
"""
IMS 认知分心检测模块

集成眼动模式分析
"""

class IMSCognitiveDistractionModule:
    """
    IMS 认知分心检测模块
    """
    
    def __init__(self):
        self.detector = CognitiveDistractionDetector()
        
        # 视线追踪
        self.gaze_tracker = GazeTracker()
        
        # 历史数据
        self.gaze_history = []
        self.timestamp_history = []
        
    def process_frame(self, frame, timestamp):
        """
        处理单帧
        
        Args:
            frame: 图像帧
            timestamp: 时间戳
            
        Returns:
            {
                'is_cognitive_distraction': bool,
                'confidence': float,
                'metrics': dict
            }
        """
        # 1. 视线估计
        gaze = self.gaze_tracker.estimate(frame)
        
        # 2. 更新历史
        self.gaze_history.append(gaze)
        self.timestamp_history.append(timestamp)
        
        # 3. 保留窗口内的数据
        cutoff = timestamp - self.detector.window_size
        while self.timestamp_history and self.timestamp_history[0] < cutoff:
            self.gaze_history.pop(0)
            self.timestamp_history.pop(0)
            
        # 4. 检测（窗口内数据足够时）
        if len(self.gaze_history) > 100:  # 至少100个采样点
            result = self.detector.detect(
                np.array(self.gaze_history),
                np.array(self.timestamp_history)
            )
            return {
                'is_cognitive_distraction': result['is_distracted'],
                'confidence': result['confidence'],
                'metrics': {
                    'fixation_score': result['fixation_score'],
                    'saccade_score': result['saccade_score'],
                    'regularity_score': result['regularity_score']
                }
            }
        
        return {
            'is_cognitive_distraction': False,
            'confidence': 0.0,
            'metrics': {}
        }

2. 部署挑战

挑战 解决方案
基线校准 驾驶开始时自动校准
个体差异 个性化基线存储
实时性 边缘计算优化
误报控制 多指标融合 + 阈值调整

总结

认知分心检测核心要点：

  1. 注视时长 - 认知分心时变短
  2. 扫视幅度 - 认知分心时变小
  3. 扫描路径规律性 - 认知分心时降低
  4. 多指标融合 - 提高检测准确性

对 IMS 开发的启示：

  • 认知分心是 Euro NCAP 2026 重点
  • 眼动模式分析是检测关键
  • 基线校准是准确性的前提
  • 多指标融合降低误报

参考资源

资源 链接
论文 arxiv.org/abs/2604.05475
Euro NCAP euroncap.com/protocols
技术研究
#DMS #认知分心 #IMS #眼动追踪
眼动模式识别认知分心：注视时长+扫视幅度+扫描路径规律性
https://dapalm.com/2026/04/26/2026-04-26-cognitive-distraction-eye-movement/
作者
Mars
发布于
2026年4月26日
许可协议