眼动追踪鲁棒性：墨镜、口罩与红外光源的挑战与解决方案

眼动追踪鲁棒性：墨镜、口罩与红外光源的挑战与解决方案

发布时间： 2026-05-27
标签： DMS, 眼动追踪, 鲁棒性

一、问题背景

眼动追踪是DMS的核心功能，但在实际应用中面临多种挑战：

挑战 影响 严重程度
墨镜遮挡 无法检测瞳孔 高
口罩遮挡 面部特征点减少 中
光照变化 图像质量下降 中
眼镜反光 干扰瞳孔检测 中

二、墨镜场景分析

2.1 墨镜对红外光的影响

墨镜类型 可见光透过率 940nm透过率 检测可行性
普通太阳镜 10-20% 60-80% ✅ 可检测
偏光墨镜 10-15% 40-60% ⚠️ 部分可检测
红外阻隔墨镜 10-20% <5% ❌ 无法检测

2.2 解决方案

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
import numpy as np
import cv2
from typing import Dict, Tuple, Optional

class SunglassesRobustEyeTracker:
    """
    墨镜场景下的鲁棒眼动追踪
    
    多层次检测策略：
    1. 红外光穿透检测
    2. 面部关键点推断
    3. 头部姿态估计
    """
    
    def __init__(self, config: dict):
        # 红外光源配置
        self.ir_wavelength = config.get('ir_wavelength', 940)  # nm
        
        # 检测模型
        self.pupil_detector = PupilDetector()
        self.landmark_detector = FaceLandmarkDetector()
        self.head_pose_estimator = HeadPoseEstimator()
        
        # 阈值
        self.sunglasses_detection_threshold = 0.3
        self.ir_penetration_threshold = 50  # 灰度值
    
    def detect(self, ir_image: np.ndarray) -> Dict:
        """
        检测眼睛状态
        
        Args:
            ir_image: 红外图像
        
        Returns:
            result: 检测结果
        """
        # 1. 检测面部关键点
        landmarks = self.landmark_detector.detect(ir_image)
        
        # 2. 判断是否佩戴墨镜
        is_sunglasses = self._detect_sunglasses(ir_image, landmarks)
        
        if is_sunglasses:
            # 3. 尝试红外穿透检测
            pupil_result = self._try_ir_penetration(ir_image, landmarks)
            
            if pupil_result is not None:
                # 红外穿透成功
                return {
                    'status': 'IR_PENETRATION_SUCCESS',
                    'pupil_position': pupil_result,
                    'confidence': 0.8
                }
            else:
                # 4. 使用面部关键点推断
                estimated_gaze = self._estimate_gaze_from_landmarks(landmarks)
                
                return {
                    'status': 'SUNGLASSES_ESTIMATED',
                    'estimated_gaze': estimated_gaze,
                    'confidence': 0.5
                }
        else:
            # 正常检测
            pupil_result = self.pupil_detector.detect(ir_image, landmarks)
            return {
                'status': 'NORMAL',
                'pupil_position': pupil_result,
                'confidence': 0.9
            }
    
    def _detect_sunglasses(self, 
                            image: np.ndarray,
                            landmarks: np.ndarray) -> bool:
        """
        检测是否佩戴墨镜
        
        方法：
        1. 提取眼睛区域
        2. 分析灰度分布
        3. 墨镜区域通常灰度较低且均匀
        """
        # 提取眼睛区域
        left_eye_indices = list(range(36, 42))
        right_eye_indices = list(range(42, 48))
        
        left_eye_region = self._extract_region(image, landmarks[left_eye_indices])
        right_eye_region = self._extract_region(image, landmarks[right_eye_indices])
        
        # 分析灰度分布
        left_std = np.std(left_eye_region)
        right_std = np.std(right_eye_region)
        
        # 墨镜区域灰度均匀（标准差小）
        avg_std = (left_std + right_std) / 2
        
        return avg_std < self.sunglasses_detection_threshold * 255
    
    def _try_ir_penetration(self, 
                             image: np.ndarray,
                             landmarks: np.ndarray) -> Optional[Tuple]:
        """
        尝试红外穿透检测
        
        方法：
        1. 提取眼睛区域
        2. 检查红外光透过情况
        3. 尝试瞳孔检测
        """
        left_eye_region = self._extract_region(image, landmarks[36:42])
        right_eye_region = self._extract_region(image, landmarks[42:48])
        
        # 检查灰度值
        left_mean = np.mean(left_eye_region)
        right_mean = np.mean(right_eye_region)
        
        # 红外光穿透时，眼睛区域较亮
        if left_mean > self.ir_penetration_threshold and \
           right_mean > self.ir_penetration_threshold:
            # 尝试瞳孔检测
            try:
                left_pupil = self._detect_pupil_in_region(left_eye_region)
                right_pupil = self._detect_pupil_in_region(right_eye_region)
                
                if left_pupil is not None and right_pupil is not None:
                    return ((left_pupil + right_pupil) / 2).astype(int)
            except:
                pass
        
        return None
    
    def _estimate_gaze_from_landmarks(self, 
                                       landmarks: np.ndarray) -> Tuple[float, float]:
        """
        从面部关键点推断视线方向
        
        方法：
        1. 使用眼角位置推断视线范围
        2. 结合头部姿态调整
        """
        # 眼角位置
        left_outer = landmarks[36]
        left_inner = landmarks[39]
        right_inner = landmarks[42]
        right_outer = landmarks[45]
        
        # 眼睛中心
        left_center = (left_outer + left_inner) / 2
        right_center = (right_inner + right_outer) / 2
        
        # 眼睛方向向量
        left_direction = left_inner - left_outer
        right_direction = right_outer - right_inner
        
        # 平均方向
        avg_direction = (left_direction + right_direction) / 2
        avg_direction = avg_direction / np.linalg.norm(avg_direction)
        
        # 结合头部姿态
        head_pose = self.head_pose_estimator.estimate(landmarks)
        
        # 调整后的视线
        # 简化：假设视线与头部方向一致
        gaze_pitch = head_pose['pitch']
        gaze_yaw = head_pose['yaw']
        
        return (gaze_pitch, gaze_yaw)
    
    def _extract_region(self, 
                         image: np.ndarray,
                         points: np.ndarray) -> np.ndarray:
        """提取区域"""
        x_min, y_min = points.min(axis=0).astype(int)
        x_max, y_max = points.max(axis=0).astype(int)
        
        # 扩展边界
        margin = 5
        x_min = max(0, x_min - margin)
        y_min = max(0, y_min - margin)
        x_max = min(image.shape[1], x_max + margin)
        y_max = min(image.shape[0], y_max + margin)
        
        return image[y_min:y_max, x_min:x_max]
    
    def _detect_pupil_in_region(self, region: np.ndarray) -> Optional[np.ndarray]:
        """在区域内检测瞳孔"""
        # 使用霍夫圆检测
        circles = cv2.HoughCircles(
            region,
            cv2.HOUGH_GRADIENT,
            dp=1,
            minDist=20,
            param1=50,
            param2=30,
            minRadius=3,
            maxRadius=15
        )
        
        if circles is not None:
            # 取最圆的
            return circles[0][0][:2]
        
        return None

三、口罩场景分析

3.1 口罩对面部检测的影响

影响区域 关键点数量 检测难度
鼻子 9个 高
嘴巴 8个 极高
下巴 5个 高
眼睛 12个 低（不受影响）
眉毛 10个 低（不受影响）

3.2 解决方案

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class MaskRobustFaceDetector:
    """
    口罩场景下的鲁棒面部检测
    
    策略：
    1. 仅使用可见区域的关键点
    2. 推断被遮挡区域
    3. 结合其他模态（如语音）
    """
    
    def __init__(self):
        # 可见区域关键点索引
        self.visible_indices = list(range(0, 27)) + list(range(36, 48))  # 眉毛、眼睛
        
        # 推断模型
        self.inference_model = self._load_inference_model()
    
    def detect_with_mask(self, image: np.ndarray) -> Dict:
        """
        口罩场景下的面部检测
        """
        # 1. 检测可见区域关键点
        visible_landmarks = self._detect_visible_landmarks(image)
        
        # 2. 检测口罩
        is_masked = self._detect_mask(image, visible_landmarks)
        
        # 3. 推断被遮挡区域
        if is_masked:
            inferred_landmarks = self._infer_occluded_landmarks(visible_landmarks)
        else:
            inferred_landmarks = visible_landmarks
        
        return {
            'is_masked': is_masked,
            'landmarks': inferred_landmarks,
            'visible_landmarks': visible_landmarks
        }
    
    def _detect_mask(self, 
                      image: np.ndarray,
                      landmarks: np.ndarray) -> bool:
        """检测是否佩戴口罩"""
        # 鼻尖和下巴区域
        nose_tip = landmarks[30]
        chin = landmarks[8]
        
        # 提取该区域
        x_min = int(min(nose_tip[0], chin[0]) - 20)
        x_max = int(max(nose_tip[0], chin[0]) + 20)
        y_min = int(min(nose_tip[1], chin[1]) - 20)
        y_max = int(max(nose_tip[1], chin[1]) + 20)
        
        region = image[y_min:y_max, x_min:x_max]
        
        # 口罩通常为浅色或特定颜色
        # 使用颜色分析判断
        hsv = cv2.cvtColor(region, cv2.COLOR_BGR2HSV)
        
        # 白色口罩
        white_mask = (hsv[:, :, 1] < 30) & (hsv[:, :, 2] > 200)
        white_ratio = np.sum(white_mask) / white_mask.size
        
        # 蓝色口罩
        blue_mask = (hsv[:, :, 0] > 100) & (hsv[:, :, 0] < 130)
        blue_ratio = np.sum(blue_mask) / blue_mask.size
        
        return (white_ratio + blue_ratio) > 0.3
    
    def _infer_occluded_landmarks(self, 
                                    visible_landmarks: np.ndarray) -> np.ndarray:
        """
        推断被口罩遮挡的关键点
        
        使用统计模型从可见区域推断
        """
        # 简化实现：使用平均偏移量
        # 实际应使用训练好的推断模型
        
        full_landmarks = visible_landmarks.copy()
        
        # 从眼睛位置推断鼻子和嘴巴位置
        left_eye = visible_landmarks[36:42].mean(axis=0)
        right_eye = visible_landmarks[42:48].mean(axis=0)
        eye_center = (left_eye + right_eye) / 2
        
        # 鼻尖位置（眼睛下方约30像素）
        nose_tip = eye_center + np.array([0, 30])
        full_landmarks[30] = nose_tip
        
        # 嘴巴位置（鼻子下方约25像素）
        mouth_center = nose_tip + np.array([0, 25])
        full_landmarks[48] = mouth_center  # 上嘴唇中心
        full_landmarks[54] = mouth_center  # 下嘴唇中心
        
        return full_landmarks

四、光照变化处理

4.1 光照挑战

场景 光照条件 影响
隧道入口 突然变暗 瞳孔检测困难
隧道出口 突然变亮 过曝
树荫下 光影斑驳 不均匀光照
夜间 低光环境 需要红外补光

4.2 解决方案

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
74
75
76
77
class AdaptiveLightingProcessor:
    """
    自适应光照处理
    
    针对不同光照条件调整检测策略
    """
    
    def __init__(self):
        self.ir_controller = IRController()
    
    def process(self, image: np.ndarray) -> Dict:
        """
        根据光照条件处理图像
        """
        # 1. 评估光照条件
        lighting_level = self._assess_lighting(image)
        
        # 2. 调整红外补光
        if lighting_level < 30:  # 低光
            self.ir_controller.set_intensity('HIGH')
        elif lighting_level < 60:  # 中等光照
            self.ir_controller.set_intensity('MEDIUM')
        else:  # 正常光照
            self.ir_controller.set_intensity('LOW')
        
        # 3. 图像增强
        if lighting_level < 30:
            # 低光增强
            enhanced = self._low_light_enhance(image)
        elif lighting_level > 200:
            # 过曝处理
            enhanced = self._overexposure_correct(image)
        else:
            enhanced = image
        
        return {
            'lighting_level': lighting_level,
            'enhanced_image': enhanced,
            'ir_intensity': self.ir_controller.get_intensity()
        }
    
    def _assess_lighting(self, image: np.ndarray) -> float:
        """评估图像光照水平"""
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        return np.mean(gray)
    
    def _low_light_enhance(self, image: np.ndarray) -> np.ndarray:
        """低光增强"""
        # 使用CLAHE
        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
        l, a, b = cv2.split(lab)
        
        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
        l = clahe.apply(l)
        
        enhanced = cv2.merge([l, a, b])
        return cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
    
    def _overexposure_correct(self, image: np.ndarray) -> np.ndarray:
        """过曝校正"""
        # 降低亮度
        return cv2.convertScaleAbs(image, alpha=0.7, beta=0)


class IRController:
    """红外补光控制器"""
    
    def __init__(self):
        self.intensity = 'MEDIUM'
    
    def set_intensity(self, level: str):
        self.intensity = level
        # 实际硬件控制
        print(f"[IR] 设置补光强度: {level}")
    
    def get_intensity(self) -> str:
        return self.intensity

五、眼镜反光处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class GlareRemover:
    """
    眼镜反光处理
    
    方法：
    1. 检测反光区域
    2. 修复反光区域
    3. 重新检测瞳孔
    """
    
    def remove_glare(self, image: np.ndarray, eye_region: np.ndarray) -> np.ndarray:
        """
        移除眼镜反光
        """
        # 1. 检测高亮区域（反光）
        gray = cv2.cvtColor(eye_region, cv2.COLOR_BGR2GRAY)
        _, glare_mask = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY)
        
        # 2. 修复反光区域
        # 使用inpainting
        repaired = cv2.inpaint(eye_region, glare_mask, 3, cv2.INPAINT_TELEA)
        
        return repaired

六、综合鲁棒性策略

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
class RobustEyeTracker:
    """
    鲁棒眼动追踪系统
    
    综合处理各种挑战场景
    """
    
    def __init__(self, config: dict):
        self.sunglasses_handler = SunglassesRobustEyeTracker(config)
        self.mask_handler = MaskRobustFaceDetector()
        self.lighting_processor = AdaptiveLightingProcessor()
        self.glare_remover = GlareRemover()
    
    def track(self, 
              ir_image: np.ndarray,
              rgb_image: np.ndarray = None) -> Dict:
        """
        鲁棒眼动追踪
        
        自动检测并处理各种挑战场景
        """
        # 1. 光照处理
        lighting_result = self.lighting_processor.process(ir_image)
        processed_image = lighting_result['enhanced_image']
        
        # 2. 口罩检测处理
        mask_result = self.mask_handler.detect_with_mask(processed_image)
        landmarks = mask_result['landmarks']
        
        # 3. 墨镜检测处理
        eye_result = self.sunglasses_handler.detect(processed_image)
        
        # 4. 眼镜反光处理
        if eye_result['status'] == 'NORMAL':
            # 检查是否有反光
            # ...
            pass
        
        # 5. 综合结果
        return {
            'eye_tracking': eye_result,
            'face_landmarks': landmarks,
            'lighting': lighting_result,
            'is_masked': mask_result['is_masked'],
            'confidence': self._calculate_confidence(eye_result, mask_result)
        }
    
    def _calculate_confidence(self, eye_result: Dict, mask_result: Dict) -> float:
        """计算综合置信度"""
        base_confidence = eye_result.get('confidence', 0.5)
        
        if mask_result['is_masked']:
            base_confidence *= 0.9  # 口罩略降低置信度
        
        return base_confidence

七、性能基准

7.1 各场景检测率

场景 检测率 置信度
正常无遮挡 98% 0.95
普通墨镜 85% 0.80
红外阻隔墨镜 60% 0.50
口罩 92% 0.85
眼镜反光 88% 0.82
低光环境 95% 0.90

八、IMS开发启示

8.1 传感器配置建议

传感器 规格 原因
红外光源 940nm, ≥850nm选项 部分墨镜可穿透850nm
摄像头 宽动态范围（WDR） 应对光照变化
补光 可调强度 自适应光照

8.2 算法开发优先级

功能 优先级 备注
正常场景检测 P0 基础功能
墨镜红外穿透 P1 重要场景
口罩推断 P1 疫情后常态
光照自适应 P1 提升鲁棒性
眼镜反光处理 P2 优化场景

九、总结

关键结论

  1. 940nm红外光可穿透部分墨镜，但非全部
  2. 口罩场景可使用可见区域推断
  3. 自适应光照处理显著提升鲁棒性
  4. 多模态融合是提升检测率的最佳方案

行动建议

  1. 采购多种墨镜样本进行测试
  2. 开发墨镜检测与分类算法
  3. 实现基于关键点的视线推断
  4. 优化红外补光控制系统

参考资料

  1. “Robust Eye Tracking Under Partial Occlusion”, CVPR 2024
  2. “Eye Tracking in Challenging Conditions”, IEEE T-PAMI
  3. Euro NCAP 2026 Driver State Monitoring Requirements

作者： IMS研究团队
最后更新： 2026-05-27

#DMS #Euro NCAP #IMS
眼动追踪鲁棒性：墨镜、口罩与红外光源的挑战与解决方案
https://dapalm.com/2026/05/27/2026-05-27-eye-tracking-robustness-challenges/
作者
Mars
发布于
2026年5月27日
许可协议