Euro NCAP 2026 乘员监测与自适应约束系统完整指南

Euro NCAP 2026 乘员监测与自适应约束系统完整指南

法规背景

Euro NCAP 2026 对乘员监测系统（OMS）提出了前所未有的严格要求，从简单的”检测是否有人”升级为”识别谁在座位上、怎么坐的、应该如何保护”。

核心变化：

  • 乘员身材分类（5th/50th/95th 百分位）
  • 异常姿态检测（OOP）
  • 自适应安全气囊管理
  • 自动化气囊开关

乘员身材分类要求

分类标准

Euro NCAP 2026 要求系统识别乘员身材，并相应调整约束系统策略。

百分位 定义 身高范围 体重范围
5th 小身材成人 149-152 cm 46-50 kg
50th 中等身材 162-168 cm 62-75 kg
95th 大身材成人 180-188 cm 85-100 kg

技术实现

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
from dataclasses import dataclass
from typing import Tuple, Optional
import numpy as np

@dataclass
class OccupantMetrics:
    """乘员测量指标"""
    # 体型测量
    head_top_y: float  # 头顶 Y 坐标（像素）
    shoulder_width: float  # 肩宽（像素）
    torso_height: float  # 躯干高度（像素）
    
    # 深度信息（若有深度传感器）
    head_depth: Optional[float]  # 头部深度（mm）
    shoulder_depth: Optional[float]  # 肩部深度（mm）
    
    # 座椅信息
    seat_track_position: int  # 座椅滑轨位置
    seat_back_angle: float  # 靠背角度


class StatureClassifier:
    """
    乘员身材分类器
    
    基于 2000 CDC Growth Charts 标准
    """
    
    def __init__(self, camera_intrinsics: dict):
        # 相机内参
        self.fx = camera_intrinsics['fx']
        self.fy = camera_intrinsics['fy']
        self.cx = camera_intrinsics['cx']
        self.cy = camera_intrinsics['cy']
        
        # 标准身材参数（单位：mm）
        self.stature_refs = {
            '5th': {
                'height': (1490, 1520),
                'shoulder_width': (340, 380),
                'sitting_height': (790, 820)
            },
            '50th': {
                'height': (1620, 1680),
                'shoulder_width': (400, 450),
                'sitting_height': (870, 910)
            },
            '95th': {
                'height': (1800, 1880),
                'shoulder_width': (470, 520),
                'sitting_height': (960, 1000)
            }
        }
    
    def classify(
        self,
        metrics: OccupantMetrics,
        depth_map: Optional[np.ndarray] = None
    ) -> dict:
        """
        分类乘员身材
        
        Args:
            metrics: 乘员测量指标
            depth_map: 深度图（可选）
        
        Returns:
            classification: {
                'stature': '5th'/'50th'/'95th',
                'confidence': float,
                'estimated_height_mm': float
            }
        """
        # 估算实际高度
        estimated_height = self._estimate_height(metrics, depth_map)
        
        # 匹配百分位
        scores = {}
        for percentile, ref in self.stature_refs.items():
            height_range = ref['height']
            
            # 计算高度匹配分数
            if height_range[0] <= estimated_height <= height_range[1]:
                scores[percentile] = 1.0
            else:
                # 计算距离分数
                dist_to_range = min(
                    abs(estimated_height - height_range[0]),
                    abs(estimated_height - height_range[1])
                )
                scores[percentile] = max(0, 1 - dist_to_range / 200)
        
        # 选择最佳匹配
        best_percentile = max(scores, key=scores.get)
        confidence = scores[best_percentile]
        
        return {
            'stature': best_percentile,
            'confidence': confidence,
            'estimated_height_mm': estimated_height,
            'all_scores': scores
        }
    
    def _estimate_height(
        self,
        metrics: OccupantMetrics,
        depth_map: Optional[np.ndarray]
    ) -> float:
        """
        估算乘员身高
        
        使用视觉测量 + 深度信息融合
        """
        if depth_map is not None and metrics.head_depth is not None:
            # 有深度信息，精确计算
            # 实际高度 = (像素高度 × 深度) / 焦距
            pixel_height = metrics.torso_height + (metrics.head_top_y - metrics.shoulder_width / 2)
            actual_height = (pixel_height * metrics.head_depth) / self.fy
            
            # 加上腿部估算（坐姿）
            # 实际站立高度 ≈ 坐高 × 1.3
            standing_height = actual_height * 1.3
            
            return standing_height
        else:
            # 无深度信息，基于座椅位置和躯干比例估算
            # 座椅滑轨位置 + 躯干高度 → 估算
            base_height = 1500 + metrics.seat_track_position * 10
            torso_contribution = metrics.torso_height * 2  # 粗略估算
            
            return base_height + torso_contribution


# 测试代码
if __name__ == "__main__":
    camera_params = {
        'fx': 1000, 'fy': 1000,
        'cx': 960, 'cy': 540
    }
    
    classifier = StatureClassifier(camera_params)
    
    # 模拟测量数据
    metrics = OccupantMetrics(
        head_top_y=200,
        shoulder_width=420,
        torso_height=350,
        head_depth=800,  # 800mm
        shoulder_depth=850,
        seat_track_position=5,
        seat_back_angle=25
    )
    
    result = classifier.classify(metrics)
    print(f"分类结果: {result['stature']}")
    print(f"置信度: {result['confidence']:.2%}")
    print(f"估算身高: {result['estimated_height_mm']:.0f} mm")

异常姿态检测（OOP）

检测场景

Euro NCAP 2026 定义了两类主要的异常姿态：

场景类型 具体姿态 风险
近距离仪表盘 头部距仪表盘 <20cm 气囊展开冲击伤害
脚踏仪表盘 脚放在仪表盘上 气囊展开骨折风险

检测实现

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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
from enum import Enum
from typing import List, Tuple
import cv2
import numpy as np

class OOPType(Enum):
    """异常姿态类型"""
    NORMAL = 'normal'
    HEAD_CLOSE_DASHBOARD = 'head_close_dashboard'
    FEET_ON_DASHBOARD_INBOARD = 'feet_on_dashboard_inboard'
    FEET_ON_DASHBOARD_CENTER = 'feet_on_dashboard_center'
    FEET_ON_DASHBOARD_OUTBOARD = 'feet_on_dashboard_outboard'


class OOPDetector:
    """
    异常姿态检测器
    
    检测乘员是否处于危险坐姿
    """
    
    def __init__(self, vehicle_config: dict):
        """
        Args:
            vehicle_config: 车辆配置
                - dashboard_y: 仪表盘 Y 坐标（图像坐标）
                - dashboard_x_range: 仪表盘 X 范围
                - danger_distance_mm: 危险距离阈值（mm）
        """
        self.dashboard_y = vehicle_config['dashboard_y']
        self.dashboard_x_range = vehicle_config['dashboard_x_range']
        self.danger_distance_mm = vehicle_config.get('danger_distance_mm', 200)
        
        # 关键点检测器（使用预训练模型）
        self.keypoint_detector = self._load_keypoint_model()
    
    def detect(
        self,
        image: np.ndarray,
        depth_map: Optional[np.ndarray] = None
    ) -> dict:
        """
        检测异常姿态
        
        Args:
            image: 乘员图像
            depth_map: 深度图（可选）
        
        Returns:
            result: {
                'oop_type': OOPType,
                'is_dangerous': bool,
                'distance_mm': float,
                'alert_required': bool
            }
        """
        # 检测人体关键点
        keypoints = self._detect_keypoints(image)
        
        # 1. 检测头部距仪表盘距离
        head_result = self._check_head_distance(
            keypoints, depth_map
        )
        
        # 2. 检测脚部位置
        feet_result = self._check_feet_position(keypoints)
        
        # 综合判断
        if head_result['is_dangerous']:
            return {
                'oop_type': OOPType.HEAD_CLOSE_DASHBOARD,
                'is_dangerous': True,
                'distance_mm': head_result['distance_mm'],
                'alert_required': True,
                'details': head_result
            }
        
        if feet_result['is_dangerous']:
            return {
                'oop_type': feet_result['oop_type'],
                'is_dangerous': True,
                'distance_mm': 0,
                'alert_required': True,
                'details': feet_result
            }
        
        return {
            'oop_type': OOPType.NORMAL,
            'is_dangerous': False,
            'distance_mm': head_result.get('distance_mm', 999),
            'alert_required': False
        }
    
    def _detect_keypoints(self, image: np.ndarray) -> dict:
        """检测人体关键点"""
        # 使用 OpenPose / MMPose 等模型
        # 返回格式：{keypoint_name: (x, y, confidence)}
        
        # 模拟结果
        return {
            'nose': (500, 300, 0.95),
            'left_eye': (510, 290, 0.98),
            'right_eye': (490, 290, 0.98),
            'left_shoulder': (540, 380, 0.92),
            'right_shoulder': (460, 380, 0.92),
            'left_hip': (520, 550, 0.88),
            'right_hip': (480, 550, 0.88),
            'left_knee': (580, 700, 0.85),
            'right_knee': (420, 700, 0.85),
            'left_ankle': (600, 850, 0.82),
            'right_ankle': (400, 850, 0.82)
        }
    
    def _check_head_distance(
        self,
        keypoints: dict,
        depth_map: Optional[np.ndarray]
    ) -> dict:
        """检查头部距仪表盘距离"""
        
        # 获取头部位置
        nose = keypoints.get('nose', (0, 0, 0))
        head_x, head_y = nose[0], nose[1]
        
        # 计算距仪表盘距离
        if depth_map is not None:
            # 有深度图，精确计算
            # 获取仪表盘深度
            dashboard_depth = depth_map[
                int(self.dashboard_y),
                int(head_x)
            ]
            
            # 获取头部深度
            head_depth = depth_map[int(head_y), int(head_x)]
            
            # 实际距离
            distance_mm = abs(dashboard_depth - head_depth)
        else:
            # 无深度图，基于图像坐标估算
            # 简化：假设头部越靠近图像上方（Y 越小），距仪表盘越近
            distance_pixels = abs(head_y - self.dashboard_y)
            distance_mm = distance_pixels * 2  # 粗略转换
        
        return {
            'is_dangerous': distance_mm < self.danger_distance_mm,
            'distance_mm': distance_mm,
            'head_position': (head_x, head_y)
        }
    
    def _check_feet_position(self, keypoints: dict) -> dict:
        """检查脚部是否在仪表盘上"""
        
        # 获取脚踝位置
        left_ankle = keypoints.get('left_ankle', (0, 0, 0))
        right_ankle = keypoints.get('right_ankle', (0, 0, 0))
        
        # 判断脚踝是否在仪表盘区域
        dashboard_y_min = self.dashboard_y - 100
        dashboard_y_max = self.dashboard_y + 50
        x_min, x_max = self.dashboard_x_range
        
        result = {
            'is_dangerous': False,
            'oop_type': OOPType.NORMAL
        }
        
        for ankle, ankle_type in [
            (left_ankle, 'left'),
            (right_ankle, 'right')
        ]:
            ax, ay, conf = ankle
            
            if conf < 0.7:
                continue
            
            # 检查 Y 坐标（是否在仪表盘高度范围）
            if dashboard_y_min <= ay <= dashboard_y_max:
                # 检查 X 坐标
                if ax < (x_min + x_max) / 3:
                    result['oop_type'] = OOPType.FEET_ON_DASHBOARD_INBOARD
                    result['is_dangerous'] = True
                elif ax < 2 * (x_min + x_max) / 3:
                    result['oop_type'] = OOPType.FEET_ON_DASHBOARD_CENTER
                    result['is_dangerous'] = True
                else:
                    result['oop_type'] = OOPType.FEET_ON_DASHBOARD_OUTBOARD
                    result['is_dangerous'] = True
                
                break
        
        return result


# 警告逻辑
class OOPWarningManager:
    """异常姿态警告管理器"""
    
    def __init__(self):
        self.warning_interval = 15 * 60  # 15 分钟（秒）
        self.last_warning_time = 0
        self.warning_duration = 30  # 秒
    
    def should_warn(
        self,
        oop_result: dict,
        current_time: float
    ) -> dict:
        """
        判断是否需要警告
        
        Euro NCAP 要求：
        - 30 秒内开始警告
        - 视觉+听觉双重警告
        - 每 15 分钟重复警告
        """
        if not oop_result['is_dangerous']:
            return {'alert': False}
        
        # 检查距上次警告时间
        time_since_last = current_time - self.last_warning_time
        
        if time_since_last < self.warning_interval:
            # 未到重复警告时间
            return {
                'alert': False,
                'reason': 'waiting_for_interval'
            }
        
        # 触发警告
        self.last_warning_time = current_time
        
        return {
            'alert': True,
            'warning_type': 'visual_audible',
            'message': self._get_warning_message(oop_result['oop_type']),
            'duration': self.warning_duration
        }
    
    def _get_warning_message(self, oop_type: OOPType) -> str:
        """获取警告消息"""
        messages = {
            OOPType.HEAD_CLOSE_DASHBOARD: "请调整坐姿，远离仪表盘",
            OOPType.FEET_ON_DASHBOARD_INBOARD: "请将脚从仪表盘上移开",
            OOPType.FEET_ON_DASHBOARD_CENTER: "请将脚从仪表盘上移开",
            OOPType.FEET_ON_DASHBOARD_OUTBOARD: "请将脚从仪表盘上移开"
        }
        return messages.get(oop_type, "请调整坐姿")

自适应安全气囊管理

气囊状态决策

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
class AirbagDecisionEngine:
    """
    自适应安全气囊决策引擎
    
    根据乘员信息决定气囊状态
    """
    
    def __init__(self):
        # 气囊状态
        self.AIRBAG_ON = 'ON'
        self.AIRBAG_OFF = 'OFF'
    
    def decide(
        self,
        occupancy: dict,
        stature: str,
        oop_type: OOPType,
        crs_present: bool,
        crs_type: Optional[str]
    ) -> dict:
        """
        决定气囊状态
        
        Euro NCAP 规则：
        - 后向儿童座椅：必须 OFF
        - 5th 百分位及以上成人：必须 ON
        - 异常姿态：可能需要调整部署策略
        
        Args:
            occupancy: 乘员占用信息
            stature: 身材分类
            oop_type: 异常姿态类型
            crs_present: 是否有儿童座椅
            crs_type: 儿童座椅类型
        
        Returns:
            decision: {
                'airbag_status': 'ON'/'OFF',
                'deployment_strategy': str,
                'reason': str,
                'user_action_required': bool
            }
        """
        # 检查座位占用
        if not occupancy.get('occupied', False):
            return {
                'airbag_status': self.AIRBAG_OFF,
                'deployment_strategy': 'disabled',
                'reason': 'seat_empty',
                'user_action_required': False
            }
        
        # 检查儿童座椅
        if crs_present:
            if crs_type == 'rearward_facing':
                # 后向儿童座椅：必须关闭
                return {
                    'airbag_status': self.AIRBAG_OFF,
                    'deployment_strategy': 'suppressed',
                    'reason': 'rearward_facing_crs',
                    'user_action_required': False  # 应自动处理
                }
            elif crs_type == 'forward_facing':
                # 前向儿童座椅：取决于儿童大小
                # 需要进一步判断
                pass
        
        # 检查身材
        if stature == '5th':
            # 小身材成人：气囊 ON，但可能需要低功率部署
            return {
                'airbag_status': self.AIRBAG_ON,
                'deployment_strategy': 'reduced_power',
                'reason': 'small_adult',
                'user_action_required': False
            }
        
        # 标准成人
        return {
            'airbag_status': self.AIRBAG_ON,
            'deployment_strategy': 'standard',
            'reason': 'adult_occupant',
            'user_action_required': False
        }
    
    def get_user_prompt(
        self,
        decision: dict,
        manual_switch_present: bool
    ) -> Optional[str]:
        """
        获取用户提示
        
        Euro NCAP 要求：
        - 手动开关不足以获得高分
        - 系统应自动处理或提供明确指导
        """
        if decision['user_action_required']:
            if manual_switch_present:
                return f"请将气囊开关设置为 {decision['airbag_status']}"
            else:
                return "系统将自动调整气囊设置"
        
        return None

Euro NCAP 测试场景

完整测试矩阵

测试 ID 场景 检测项 预期结果
OM-01 5th 百分位成人 身材分类 正确识别 + 低功率部署
OM-02 95th 百分位成人 身材分类 正确识别 + 标准部署
OM-03 后向儿童座椅 CRS 检测 气囊 OFF
OM-04 头部距仪表盘 <20cm OOP 检测 30s 内警告
OM-05 脚踏仪表盘 OOP 检测 30s 内警告
OM-06 正常坐姿 正常检测 无警告
OM-07 空座 占用检测 气囊 OFF
OM-08 乘员换座 实时更新 10s 内更新状态

验证要点

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
class EuroNCAPValidator:
    """Euro NCAP 合规验证"""
    
    def validate_occupant_monitoring(
        self,
        system_outputs: dict,
        test_scenario: dict
    ) -> dict:
        """
        验证乘员监测系统合规性
        """
        results = {
            'compliant': True,
            'issues': []
        }
        
        # 1. 验证身材分类响应时间
        if 'stature_change_time' in system_outputs:
            if system_outputs['stature_change_time'] > 10:
                results['compliant'] = False
                results['issues'].append(
                    f"身材分类响应时间 {system_outputs['stature_change_time']}s > 10s"
                )
        
        # 2. 验证 OOP 警告时延
        if 'oop_warning_delay' in system_outputs:
            if system_outputs['oop_warning_delay'] > 30:
                results['compliant'] = False
                results['issues'].append(
                    f"OOP 警告延迟 {system_outputs['oop_warning_delay']}s > 30s"
                )
        
        # 3. 验证气囊状态
        expected_status = test_scenario.get('expected_airbag_status')
        actual_status = system_outputs.get('airbag_status')
        if expected_status and actual_status != expected_status:
            results['compliant'] = False
            results['issues'].append(
                f"气囊状态错误：期望 {expected_status}，实际 {actual_status}"
            )
        
        # 4. 验证警告类型
        if test_scenario.get('requires_warning'):
            warning_types = system_outputs.get('warning_types', [])
            if 'visual' not in warning_types or 'audible' not in warning_types:
                results['compliant'] = False
                results['issues'].append(
                    "警告类型不完整：需视觉+听觉双重警告"
                )
        
        return results

IMS 开发建议

传感器配置

传感器 用途 必要性
3D 深度摄像头 身材估算、OOP 检测 高
座椅压力传感器 占用检测、体重估算 中
座椅位置传感器 身材辅助判断 中
安全带传感器 儿童座椅检测 高

软件架构

1
2
3
4
5
6
7
8
9
摄像头输入 → 人体关键点检测 → 身材估算
                      ↓
                  姿态分析 → OOP 检测
                      ↓
                  CRS 检测 → 气囊决策
                      ↓
              传感器融合 → 最终决策
                      ↓
                  HMI 输出

部署时间表

1
2
3
4
5
2025 Q3: 传感器选型完成
2025 Q4: 算法开发完成
2026 Q1: 实车集成测试
2026 Q2: Euro NCAP 认证
2026 Q3: SOP 量产

参考文献

  1. Smart Eye, “Euro NCAP 2026: New Standards for Occupant Monitoring and Adaptive Restraints”, 2025
  2. Euro NCAP, “Safe Driving Occupant Monitoring Protocol v1.1”, 2025
  3. CDC, “2000 CDC Growth Charts”, 2000

总结： Euro NCAP 2026 对乘员监测提出了全面的智能化要求，包括身材分类、异常姿态检测、自适应气囊管理。建议采用 3D 深度摄像头 + 多传感器融合方案，确保 10 秒内响应乘员变化、30 秒内发出 OOP 警告，并实现气囊自动管理以满足合规要求。

IMS研究
#Euro NCAP #OMS #安全带 #传感器融合
Euro NCAP 2026 乘员监测与自适应约束系统完整指南
https://dapalm.com/2026/06/04/2026-06-04-Euro-NCAP-2026乘员监测与自适应约束系统完整指南/
作者
Mars
发布于
2026年6月4日
许可协议