Euro NCAP 2026 OOP检测：3D深度摄像头方案

法规要求

OOP定义

Out-of-Position (OOP)：乘员姿态异常，可能导致气囊展开时受伤风险增加。

Euro NCAP 2026 OMS OOP要求

官方协议文档（Euro NCAP Protocol v0.9）：

测试场景	检测要求	警告条件
前排乘员前倾	检测乘员姿态	距离仪表板 ≤20cm 时警告
乘员侧倾	检测侧向偏移	偏离座椅中心 >15cm
乘员后仰	检测靠背角度	靠背角度 >45°
儿童错误坐姿	检测OOP状态	不符合安全座椅要求

技术方案对比

方案	成本	精度	鲁棒性	Euro NCAP兼容
2D摄像头	低	中	❌ 光照敏感	⚠️ 部分
3D深度摄像头	中	高	✅	✅ 完全
雷达	高	中	✅	✅
压力传感器	低	低	✅	⚠️ 部分

3D深度摄像头方案

1. 硬件选型

"""
推荐3D深度摄像头型号

TOF (Time-of-Flight) vs 双目 vs 结构光
"""

depth_cameras = {
    "TOF方案": {
        "代表型号": "Sony IMX556PLR-C",
        "分辨率": "640×480 @ 30fps",
        "深度范围": "0.15-10m",
        "精度": "±1cm @ 1m",
        "优点": ["精度高", "响应快", "抗光干扰"],
        "缺点": ["成本较高", "功耗大"],
        "推荐": True
    },
    "双目方案": {
        "代表型号": "Stereo Vision (OV2311×2)",
        "分辨率": "1600×1200 @ 30fps",
        "深度范围": "0.3-10m",
        "精度": "±3cm @ 1m",
        "优点": ["成本低", "可见光工作"],
        "缺点": ["光照依赖", "计算量大"],
        "推荐": "后备方案"
    },
    "结构光方案": {
        "代表型号": "Intel RealSense D435",
        "分辨率": "1280×720 @ 30fps",
        "深度范围": "0.3-3m",
        "精度": "±2mm @ 1m",
        "优点": ["精度最高"],
        "缺点": ["阳光干扰", "范围短"],
        "推荐": "夜间优先"
    }
}

2. 乘员姿态检测算法

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

@dataclass
class OccupantPose:
    """乘员姿态数据结构"""
    position: Tuple[float, float, float]  # 3D位置 (x, y, z) 米
    orientation: Tuple[float, float, float]  # 姿态角 (roll, pitch, yaw) 度
    body_keypoints: np.ndarray  # 身体关键点 (N, 3)
    distance_to_dashboard: float  # 距仪表板距离 cm
    is_oop: bool  # 是否OOP
    oop_type: str  # OOP类型


class OOPDetector:
    """
    Out-of-Position检测器
    
    基于TOF深度数据检测乘员异常姿态
    """
    
    def __init__(self):
        # 车内几何参数（需标定）
        self.dashboard_position = np.array([0.0, 0.0, 0.5])  # 仪表板位置
        self.seat_center = np.array([0.0, 0.0, 1.2])  # 座椅中心
        
        # OOP阈值
        self.oop_thresholds = {
            'dashboard_distance': 20,  # cm
            'lateral_offset': 15,      # cm
            'recline_angle': 45,       # 度
        }
        
    def detect_oop(self, 
                   depth_image: np.ndarray,
                   rgb_image: np.ndarray = None) -> OccupantPose:
        """
        检测乘员OOP状态
        
        Args:
            depth_image: 深度图 (H, W) 单位：米
            rgb_image: RGB图（可选，用于关键点检测）
        
        Returns:
            pose: 乘员姿态信息
        """
        # 1. 提取点云
        point_cloud = self._depth_to_pointcloud(depth_image)
        
        # 2. 分割乘员区域
        occupant_points = self._segment_occupant(point_cloud)
        
        # 3. 计算乘员中心位置
        center = np.mean(occupant_points, axis=0)
        
        # 4. 计算距仪表板距离
        distance_to_dashboard = self._calculate_dashboard_distance(
            occupant_points
        )
        
        # 5. 估计身体姿态
        orientation = self._estimate_orientation(occupant_points)
        
        # 6. 检测关键点（如果有RGB）
        keypoints = self._detect_body_keypoints(rgb_image, depth_image) if rgb_image is not None else np.array([])
        
        # 7. 判断OOP
        is_oop, oop_type = self._classify_oop(
            distance_to_dashboard, center, orientation
        )
        
        return OccupantPose(
            position=tuple(center),
            orientation=orientation,
            body_keypoints=keypoints,
            distance_to_dashboard=distance_to_dashboard,
            is_oop=is_oop,
            oop_type=oop_type
        )
    
    def _depth_to_pointcloud(self, depth_image: np.ndarray) -> np.ndarray:
        """
        深度图转点云
        
        使用相机内参（需标定）
        """
        # 相机内参（示例）
        fx, fy = 500, 500  # 焦距
        cx, cy = 320, 240  # 光心
        
        h, w = depth_image.shape
        u, v = np.meshgrid(np.arange(w), np.arange(h))
        
        # 去除无效深度
        valid = depth_image > 0
        
        z = depth_image[valid]
        x = (u[valid] - cx) * z / fx
        y = (v[valid] - cy) * z / fy
        
        return np.column_stack([x, y, z])
    
    def _segment_occupant(self, 
                          point_cloud: np.ndarray,
                          seat_region: Tuple = None) -> np.ndarray:
        """
        分割乘员点云
        
        使用座位区域过滤
        """
        if seat_region is None:
            # 默认前排乘客区域
            seat_region = (-0.5, 0.5, -0.3, 1.0, 0.5, 2.0)  # (x_min, x_max, ...)
        
        x_min, x_max, y_min, y_max, z_min, z_max = seat_region
        
        mask = (
            (point_cloud[:, 0] >= x_min) & (point_cloud[:, 0] <= x_max) &
            (point_cloud[:, 1] >= y_min) & (point_cloud[:, 1] <= y_max) &
            (point_cloud[:, 2] >= z_min) & (point_cloud[:, 2] <= z_max)
        )
        
        return point_cloud[mask]
    
    def _calculate_dashboard_distance(self, 
                                       occupant_points: np.ndarray) -> float:
        """
        计算乘员到仪表板的最短距离
        
        Returns:
            distance: 厘米
        """
        # 找最前端点（z最小）
        front_point = occupant_points[np.argmin(occupant_points[:, 2])]
        
        # 计算到仪表板平面的距离
        # 假设仪表板平面 z = dashboard_z
        dashboard_z = self.dashboard_position[2]
        distance = (front_point[2] - dashboard_z) * 100  # 转厘米
        
        return distance
    
    def _estimate_orientation(self, 
                               occupant_points: np.ndarray) -> Tuple[float, float, float]:
        """
        估计乘员姿态角
        
        使用PCA分析主方向
        """
        # PCA
        centered = occupant_points - np.mean(occupant_points, axis=0)
        cov = np.cov(centered.T)
        eigenvalues, eigenvectors = np.linalg.eigh(cov)
        
        # 主方向（躯干方向）
        main_direction = eigenvectors[:, 2]  # 最大特征值对应方向
        
        # 计算姿态角
        roll = np.arctan2(main_direction[0], main_direction[1]) * 180 / np.pi
        pitch = np.arctan2(main_direction[2], 
                          np.sqrt(main_direction[0]**2 + main_direction[1]**2)) * 180 / np.pi
        yaw = 0  # 需要更多信息
        
        return (roll, pitch, yaw)
    
    def _detect_body_keypoints(self, 
                                rgb_image: np.ndarray,
                                depth_image: np.ndarray) -> np.ndarray:
        """
        检测身体关键点
        
        结合RGB和深度信息
        """
        # 实际应用使用OpenPose/MediaPipe等
        # 这里返回简化结果
        return np.zeros((17, 3))  # 17个COCO关键点
    
    def _classify_oop(self, 
                      distance: float, 
                      center: np.ndarray, 
                      orientation: Tuple[float, float, float]) -> Tuple[bool, str]:
        """
        分类OOP类型
        
        Returns:
            is_oop: 是否OOP
            oop_type: OOP类型描述
        """
        roll, pitch, yaw = orientation
        lateral_offset = abs(center[0] - self.seat_center[0]) * 100  # cm
        
        # 前倾OOP
        if distance < self.oop_thresholds['dashboard_distance']:
            return True, f"前倾（距仪表板{distance:.1f}cm）"
        
        # 侧倾OOP
        if lateral_offset > self.oop_thresholds['lateral_offset']:
            direction = "左侧" if center[0] < 0 else "右侧"
            return True, f"{direction}偏移{lateral_offset:.1f}cm"
        
        # 后仰OOP
        if abs(pitch) > self.oop_thresholds['recline_angle']:
            return True, f"后仰{abs(pitch):.1f}°"
        
        return False, "正常坐姿"


# ============ 气囊抑制决策 ============

class AdaptiveAirbagController:
    """
    自适应气囊控制器
    
    根据OOP状态调整气囊部署策略
    """
    
    def __init__(self):
        self.oop_detector = OOPDetector()
        
        # 气囊部署策略
        self.airbag_modes = {
            'normal': 'full_deployment',
            'oop_mild': 'low_power_deployment',
            'oop_severe': 'no_deployment'
        }
    
    def decide_airbag_mode(self, 
                           depth_image: np.ndarray,
                           crash_severity: str = 'moderate') -> Dict:
        """
        决定气囊部署模式
        
        Args:
            depth_image: 深度图
            crash_severity: 碰撞严重程度 ('low', 'moderate', 'severe')
        
        Returns:
            decision: {
                'mode': str,
                'reason': str,
                'confidence': float
            }
        """
        # 检测OOP
        pose = self.oop_detector.detect_oop(depth_image)
        
        if not pose.is_oop:
            return {
                'mode': 'normal',
                'reason': '正常坐姿',
                'airbag_action': 'full_deployment',
                'confidence': 0.95
            }
        
        # 根据OOP程度和碰撞严重程度决定
        distance = pose.distance_to_dashboard
        
        if distance < 10:  # 严重前倾
            if crash_severity == 'low':
                action = 'no_deployment'
            else:
                action = 'low_power_deployment'
            
            return {
                'mode': 'oop_severe',
                'reason': f'严重OOP: {pose.oop_type}',
                'airbag_action': action,
                'confidence': 0.9
            }
        
        elif distance < 20:  # 轻度前倾
            return {
                'mode': 'oop_mild',
                'reason': f'轻度OOP: {pose.oop_type}',
                'airbag_action': 'low_power_deployment',
                'confidence': 0.85
            }
        
        else:
            return {
                'mode': 'normal',
                'reason': '正常坐姿',
                'airbag_action': 'full_deployment',
                'confidence': 0.95
            }


# ============ Euro NCAP测试场景 ============

def euro_ncap_oop_test_scenarios():
    """
    Euro NCAP 2026 OOP测试场景
    
    来源：Euro NCAP Protocol v0.9
    """
    scenarios = [
        {
            "id": "OOP-01",
            "description": "前排乘员前倾",
            "test_position": "距离仪表板15cm",
            "expected": "检测到OOP，发出警告",
            "pass_criteria": "检测延时 ≤2s"
        },
        {
            "id": "OOP-02",
            "description": "前排乘员侧倾",
            "test_position": "侧向偏移20cm",
            "expected": "检测到OOP",
            "pass_criteria": "检测准确率 ≥90%"
        },
        {
            "id": "OOP-03",
            "description": "前排乘员后仰",
            "test_position": "靠背角度55°",
            "expected": "检测到OOP",
            "pass_criteria": "检测准确率 ≥90%"
        },
        {
            "id": "OOP-04",
            "description": "儿童错误坐姿",
            "test_position": "儿童座椅中站立",
            "expected": "检测到OOP，警告",
            "pass_criteria": "检测延时 ≤2s"
        },
        {
            "id": "OOP-05",
            "description": "腿部翘起",
            "test_position": "脚放置在仪表板上",
            "expected": "检测到OOP",
            "pass_criteria": "检测准确率 ≥85%"
        }
    ]
    
    return scenarios


# ============ 实际测试 ============

if __name__ == "__main__":
    # 初始化检测器
    detector = OOPDetector()
    airbag_ctrl = AdaptiveAirbagController()
    
    # 模拟深度图（640×480）
    np.random.seed(42)
    
    # 场景1：正常坐姿
    print("=" * 60)
    print("场景1：正常坐姿")
    print("=" * 60)
    
    normal_depth = np.ones((480, 640)) * 1.5  # 1.5米处
    pose1 = detector.detect_oop(normal_depth)
    print(f"位置: {pose1.position}")
    print(f"距仪表板: {pose1.distance_to_dashboard:.1f}cm")
    print(f"OOP状态: {'是' if pose1.is_oop else '否'}")
    print(f"类型: {pose1.oop_type}")
    
    # 场景2：前倾OOP
    print("\n" + "=" * 60)
    print("场景2：前倾OOP")
    print("=" * 60)
    
    oop_depth = np.ones((480, 640)) * 0.25  # 25cm处
    pose2 = detector.detect_oop(oop_depth)
    print(f"位置: {pose2.position}")
    print(f"距仪表板: {pose2.distance_to_dashboard:.1f}cm")
    print(f"OOP状态: {'是' if pose2.is_oop else '否'}")
    print(f"类型: {pose2.oop_type}")
    
    # 气囊决策
    print("\n" + "=" * 60)
    print("气囊部署决策")
    print("=" * 60)
    
    decision = airbag_ctrl.decide_airbag_mode(oop_depth, crash_severity='moderate')
    print(f"模式: {decision['mode']}")
    print(f"原因: {decision['reason']}")
    print(f"气囊动作: {decision['airbag_action']}")
    print(f"置信度: {decision['confidence']:.2f}")
    
    # Euro NCAP测试场景
    print("\n" + "=" * 60)
    print("Euro NCAP 2026 OOP测试场景")
    print("=" * 60)
    
    scenarios = euro_ncap_oop_test_scenarios()
    for s in scenarios:
        print(f"\n{s['id']}: {s['description']}")
        print(f"  测试位置: {s['test_position']}")
        print(f"  预期结果: {s['expected']}")
        print(f"  通过标准: {s['pass_criteria']}")