Euro NCAP 2026 CPD 儿童存在检测：雷达与摄像头融合方案

发布时间： 2026-06-15
标签： Euro NCAP 2026, CPD, 儿童检测, 雷达融合, 60GHz
来源： Euro NCAP 官方协议, TI, Infineon

---

核心要求

Euro NCAP 2026 要求车辆能够检测遗留儿童并发出警告，最高可获 5 分。

---

检测要求

1. 触发条件

条件	描述
发动机关闭	车辆停止且引擎关闭
座椅占用	后排座椅检测到儿童
车门关闭	所有车门关闭
时间超限	持续超过阈值时间

2. 警告层级

层级	触发时间	警告方式
Level 1	60 秒	车内蜂鸣
Level 2	90 秒	喇叭 + 灯光
Level 3	120 秒	手机通知 + 紧急呼叫

---

技术路线对比

技术路线	优势	劣势	Euro NCAP 评分
60GHz 雷达	穿透性强、可测生命体征	成本较高	满分
摄像头	可见光、成本低	光照敏感、隐私顾虑	部分
超声波	成本最低	仅检测运动	最低
压力传感器	简单可靠	无生命体征检测	部分
雷达+摄像头融合	鲁棒性最强	成本最高	满分

---

雷达-摄像头融合实现

"""
CPD 雷达-摄像头融合检测系统
Euro NCAP 2026 合规实现
"""

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

@dataclass
class CPDAlert:
    """CPD 警告"""
    level: int               # 警告等级 1-3
    trigger_time: float      # 触发时间
    location: Tuple[int, int] # 座椅位置 (排, 座)
    child_age_estimate: str   # 年龄估计
    vital_signs: Dict         # 生命体征
    confidence: float         # 置信度


class RadarCPDDetector:
    """
    60GHz 雷达 CPD 检测器
    
    使用 TI IWR6843AOP 或类似芯片
    """
    
    def __init__(self, config: Dict):
        # 雷达参数
        self.frequency = 60e9  # 60 GHz
        self.range_resolution = config.get('range_resolution', 0.04)  # 4cm
        self.velocity_resolution = config.get('velocity_resolution', 0.1)  # m/s
        
        # 检测参数
        self.breathing_threshold = config.get('breathing_threshold', 0.01)  # m
        self.heart_rate_range = config.get('heart_rate_range', (60, 180))   # bpm
        
        # 座椅区域定义
        self.seat_zones = {
            'rear_left': {'x': (-0.5, 0.0), 'y': (0.5, 1.0), 'z': (0.0, 0.5)},
            'rear_center': {'x': (-0.25, 0.25), 'y': (0.5, 1.0), 'z': (0.0, 0.5)},
            'rear_right': {'x': (0.0, 0.5), 'y': (0.5, 1.0), 'z': (0.0, 0.5)}
        }
    
    def process_frame(self, radar_data: np.ndarray) -> Dict:
        """
        处理单帧雷达数据
        
        Args:
            radar_data: 雷达点云 (N, 4)
                [x, y, z, velocity]
        
        Returns:
            detection: 检测结果
        """
        # 1. 点云聚类
        clusters = self._cluster_points(radar_data)
        
        # 2. 检测运动（呼吸/心跳）
        vital_signs = self._detect_vital_signs(clusters)
        
        # 3. 座椅占用判断
        occupancy = self._check_occupancy(clusters)
        
        return {
            'clusters': clusters,
            'vital_signs': vital_signs,
            'occupancy': occupancy
        }
    
    def _cluster_points(self, points: np.ndarray) -> List[Dict]:
        """点云聚类"""
        if len(points) == 0:
            return []
        
        # DBSCAN 聚类
        from sklearn.cluster import DBSCAN
        
        clustering = DBSCAN(eps=0.2, min_samples=5).fit(points[:, :3])
        labels = clustering.labels_
        
        clusters = []
        for label in set(labels):
            if label == -1:
                continue
            
            cluster_points = points[labels == label]
            center = cluster_points[:, :3].mean(axis=0)
            
            clusters.append({
                'center': center,
                'points': cluster_points,
                'size': len(cluster_points)
            })
        
        return clusters
    
    def _detect_vital_signs(self, clusters: List[Dict]) -> List[Dict]:
        """检测生命体征"""
        vital_signs = []
        
        for cluster in clusters:
            velocities = cluster['points'][:, 3]
            
            # 分析速度分布（呼吸频率范围）
            # 呼吸频率 ~0.2-0.5 Hz，对应微小运动
            velocity_variance = np.var(velocities)
            
            if velocity_variance > self.breathing_threshold:
                # 可能有生命体征
                vital_signs.append({
                    'location': cluster['center'],
                    'confidence': min(velocity_variance / self.breathing_threshold, 1.0)
                })
        
        return vital_signs
    
    def _check_occupancy(self, clusters: List[Dict]) -> Dict:
        """检查座椅占用"""
        occupancy = {seat: False for seat in self.seat_zones}
        
        for cluster in clusters:
            center = cluster['center']
            
            for seat, zone in self.seat_zones.items():
                if (zone['x'][0] <= center[0] <= zone['x'][1] and
                    zone['y'][0] <= center[1] <= zone['y'][1] and
                    zone['z'][0] <= center[2] <= zone['z'][1]):
                    occupancy[seat] = True
        
        return occupancy


class CameraCPDDetector:
    """摄像头 CPD 检测器"""
    
    def __init__(self, config: Dict):
        self.child_detector = ChildDetector(config)
        self.pose_estimator = PoseEstimator(config)
    
    def process_frame(self, frame: np.ndarray) -> Dict:
        """
        处理单帧图像
        
        Args:
            frame: 车内图像 (H, W, 3)
        
        Returns:
            detection: 检测结果
        """
        # 1. 儿童检测
        children = self.child_detector.detect(frame)
        
        # 2. 姿态估计
        poses = []
        for child in children:
            pose = self.pose_estimator.estimate(frame, child['bbox'])
            poses.append(pose)
        
        return {
            'children': children,
            'poses': poses
        }


class ChildDetector:
    """儿童检测器"""
    
    def __init__(self, config: Dict):
        # 加载模型
        pass
    
    def detect(self, frame: np.ndarray) -> List[Dict]:
        """检测儿童"""
        # 实际使用 YOLO/EfficientDet 等模型
        return []


class PoseEstimator:
    """姿态估计器"""
    
    def __init__(self, config: Dict):
        pass
    
    def estimate(self, frame: np.ndarray, bbox: Tuple) -> Dict:
        """估计姿态"""
        return {}


class CPDFusionSystem:
    """
    CPD 融合系统
    
    雷达 + 摄像头融合
    """
    
    def __init__(self, config: Dict):
        self.radar_detector = RadarCPDDetector(config)
        self.camera_detector = CameraCPDDetector(config)
        
        # 状态跟踪
        self.detection_history = []
        self.alert_state = None
        self.engine_off_time = None
    
    def update(self, 
               radar_data: np.ndarray,
               camera_frame: np.ndarray,
               vehicle_state: Dict,
               current_time: float) -> CPDAlert:
        """
        更新系统状态
        
        Args:
            radar_data: 雷达点云
            camera_frame: 车内图像
            vehicle_state: 车辆状态
                - 'engine_on': bool
                - 'doors_closed': bool
                - 'speed': float
            current_time: 当前时间
        
        Returns:
            alert: CPD 警告（如果触发）
        """
        # 检查触发条件
        if vehicle_state['engine_on']:
            self.engine_off_time = None
            self.alert_state = None
            return None
        
        if self.engine_off_time is None:
            self.engine_off_time = current_time
        
        # 检测
        radar_result = self.radar_detector.process_frame(radar_data)
        camera_result = self.camera_detector.process_frame(camera_frame)
        
        # 融合判断
        child_detected = self._fuse_detections(radar_result, camera_result)
        
        if child_detected:
            elapsed_time = current_time - self.engine_off_time
            
            # 判断警告等级
            if elapsed_time > 120:
                level = 3
            elif elapsed_time > 90:
                level = 2
            elif elapsed_time > 60:
                level = 1
            else:
                return None
            
            return CPDAlert(
                level=level,
                trigger_time=current_time,
                location=child_detected['location'],
                child_age_estimate=child_detected.get('age_estimate', 'unknown'),
                vital_signs=radar_result['vital_signs'],
                confidence=child_detected['confidence']
            )
        
        return None
    
    def _fuse_detections(self, radar_result: Dict, camera_result: Dict) -> Dict:
        """
        融合雷达和摄像头检测结果
        
        Returns:
            fused: 融合结果（如果检测到儿童）
        """
        # 雷达检测到生命体征
        radar_vital = len(radar_result['vital_signs']) > 0
        
        # 摄像头检测到儿童
        camera_child = len(camera_result['children']) > 0
        
        # 双重确认
        if radar_vital and camera_child:
            # 高置信度
            return {
                'location': camera_result['children'][0].get('location', (0, 0)),
                'confidence': 0.95,
                'age_estimate': camera_result['children'][0].get('age', 'unknown')
            }
        elif radar_vital:
            # 仅雷达检测
            return {
                'location': radar_result['vital_signs'][0]['location'],
                'confidence': 0.7,
                'age_estimate': 'unknown'
            }
        elif camera_child:
            # 仅摄像头检测
            return {
                'location': camera_result['children'][0].get('location', (0, 0)),
                'confidence': 0.6,
                'age_estimate': camera_result['children'][0].get('age', 'unknown')
            }
        
        return None


# 测试场景
class EuroNCAP_CPDTest:
    """Euro NCAP CPD 测试"""
    
    def __init__(self):
        self.system = CPDFusionSystem({})
        
        self.test_scenarios = [
            {
                'id': 'CPD-01',
                'description': '6个月婴儿独自留在后座',
                'expected_detection': True,
                'expected_alert_level': 1,
                'time_to_alert': 60
            },
            {
                'id': 'CPD-02',
                'description': '3岁儿童独自留在后座',
                'expected_detection': True,
                'expected_alert_level': 1,
                'time_to_alert': 60
            },
            {
                'id': 'CPD-03',
                'description': '宠物留在车内',
                'expected_detection': True,  # 可选
                'expected_alert_level': 1,
                'time_to_alert': 120
            },
            {
                'id': 'CPD-04',
                'description': '空车',
                'expected_detection': False,
                'expected_alert_level': 0,
                'time_to_alert': None
            }
        ]
    
    def run_test(self, scenario_id: str) -> Dict:
        """运行测试场景"""
        scenario = next(s for s in self.test_scenarios if s['id'] == scenario_id)
        
        # 模拟测试数据
        radar_data = np.random.randn(100, 4) * 0.5
        camera_frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
        vehicle_state = {'engine_on': False, 'doors_closed': True, 'speed': 0}
        
        # 运行系统
        alert = self.system.update(radar_data, camera_frame, vehicle_state, time.time())
        
        return {
            'scenario_id': scenario_id,
            'expected_detection': scenario['expected_detection'],
            'detected': alert is not None,
            'passed': (alert is not None) == scenario['expected_detection']
        }

---

硬件选型

60GHz 雷达芯片

型号	厂商	特点
IWR6843AOP	TI	4发4收，内置天线，低功耗
BGT60ATR24C	Infineon	24GHz/60GHz 双频
MR3003	Socionext	专用 CPD 芯片

摄像头选型

参数	推荐值	原因
分辨率	≥ 2MP	儿童特征识别
视场角	120-180°	覆盖后排
光谱	RGB + IR	夜间检测

---

Euro NCAP 评分细则

功能	评分
后排占用检测	2 分
儿童检测（非仅占用）	1 分
直接检测（雷达/摄像头）	1 分
警告功能完整	1 分
总分	5 分

---

IMS 开发启示

1. 传感器布局

车顶后部：
├── 60GHz 雷达 x 1-2（覆盖后排）
└── 广角摄像头 x 1（覆盖后排）

2. 算法优先级

优先级	功能	难度
P0	占用检测	⭐
P0	生命体征检测	⭐⭐
P1	儿童分类	⭐⭐⭐
P2	年龄估计	⭐⭐⭐⭐

3. 误报率控制

场景	常见误报	解决方案
阳光变化	摄像头误检	红外补光
行李物品	雷达误判	形状识别 + 生命体征
车辆振动	运动误判	速度滤波

---

总结

Euro NCAP 2026 CPD 要求推动了车内监控从被动检测向主动安全保护演进：

1. 雷达优势：穿透性强、可检测生命体征
2. 融合必要：单一传感器鲁棒性不足
3. 成本权衡：雷达成本高但可靠性好
4. 隐私考量：雷达比摄像头隐私友好

---

参考来源：

• Euro NCAP Safe Driving Occupant Monitoring Protocol
• TI IWR6843AOP