Euro NCAP 2026 安全带误用检测深度解读：从协议要求到视觉AI算法实现

论文/法规信息

项目	内容
法规	Euro NCAP 2026 Safe Driving and Occupant Monitoring Protocol
版本	2026版
发布机构	Euro NCAP
生效时间	2026年1月（驾驶员座椅），2029年扩展至其他座椅
关联论文	Gu et al., “Seat belt detection using gated Bi-LSTM”, Expert Syst. Appl. 2024
关联论文	MDPI Applied Sciences 2024, “Seatbelt Detection Algorithm Improved”
关联论文	Tambwekar et al., Sensors 2024, “3D Posture Estimation”

核心创新/要点

Euro NCAP 2026 将安全带检测从二元状态（扣/未扣）升级为路由分析（正确佩戴/错误佩戴），要求识别三种误用场景：仅扣扣子、腰带、背后。需要摄像头视觉AI识别肩带位置和路由路径。

1. Euro NCAP 2026 安全带误用检测核心要求

1.1 三种误用场景定义

误用类型	描述	检测要点	分值
仅扣扣子	扣子插入，但安全带未佩戴	扣子状态ON + 无肩带/腰带	2分
仅腰带	腰带佩戴，肩带在背后	腰带可见 + 肩带位置错误	2分
完全在背后	整条安全带置于背后	扣子ON + 无可见安全带	1分

1.2 检测范围与时间节点

项目	2026要求	2029扩展
检测座椅	驾驶员座椅	所有座椅位置
检测时机	行程开始 + 行程中持续	同上
警告触发	误用检测后30秒内	同上

1.3 警告时序要求

sequenceDiagram
    participant S as 传感器
    participant V as 视觉AI
    participant W as 警告系统
    participant D as 驾驶员

    Note over S,V: 行程开始
    S->>S: 扣子状态检测
    V->>V: 肩带路由分析
    V->>V: 腰带位置识别
    
    alt 安全带正确佩戴
        V->>W: 佩戴正确，无需警告
    else 误用检测
        V->>W: 检测到误用类型
        Note over W: 30秒内触发警告
        W->>D: 声音警告（至少90秒）
        W->>D: 视觉警告（持续显示）
        Note over D: 声音可关闭一次
        Note over D: 视觉警告必须持续
    end

    alt 驾驶员重新扣好
        S->>S: 扣子重新插入
        V->>V: 再次路由分析
        V->>W: 正确佩戴，警告停止
    else 再次误用
        Note over W: 全部警告重启
        W->>D: 声音+视觉重启
    end

警告详细要求表

警告类型	触发条件	持续时间	可否关闭
声音警告	误用检测后30秒内触发	≥90秒	可关闭一次
视觉警告	误用检测后立即显示	持续显示	不可关闭
触发时机	<40km/h 或 <1km 或 <90秒引擎	-	-
静默间隔	声音警告中静默≤10秒	-	-

1.4 与乘员检测联动

关键约束：

• 驾驶员座椅： 可假设有人
• 其他座椅： 必须先检测到乘员存在
• 后排座椅： 需同时有乘员检测 + 安全带提醒
• 未检测乘员： 不触发警告，不得分

得分规则：

配置	后排座椅覆盖	得分
全覆盖	所有后排座椅都有乘员检测+安全带提醒	5分
部分覆盖	部分座椅有检测	1-4分
无检测	无乘员检测系统	0分

1.5 Airbag联动约束

• 前排乘客座椅： Airbag关闭开关不能关闭安全带提醒
• 两个系统独立： Airbag状态与安全带提醒互不影响

2. 视觉AI安全带路由检测算法

2.1 问题定义

输入： 车内摄像头RGB图像（驾驶员/乘客座椅区域）

输出：

检测项	类别	精度要求
扣子状态	已扣/未扣	≥98%
肩带位置	正常/背后/缺失	≥95%
腰带位置	正常/缺失	≥95%
路由完整性	正确/误用	≥95%

2.2 检测难点分析

难点	描述	解决方案
肩带遮挡	手臂/衣服遮挡肩带	多角度摄像头 + 关键点推断
腰带遮挡	大腿/衣服遮挡腰带	3D姿态估计 + 压力传感器辅助
背后检测	背后安全带不可见	间接推断：扣子ON + 无可见肩带
光照变化	日夜光照差异	红外摄像头 + HDR处理
衣服干扰	不同颜色/材质衣服	多样化训练数据

2.3 基于YOLOv8的安全带检测实现

"""
Euro NCAP 2026 安全带误用检测系统
基于YOLOv8的关键点检测方案

参考：
- Gu et al., Expert Syst. Appl. 2024
- MDPI Applied Sciences 2024
- Euro NCAP 2026 Safe Driving Protocol
"""

import numpy as np
import cv2
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
from enum import Enum

class BeltStatus(Enum):
    """安全带状态枚举"""
    CORRECT = "正确佩戴"
    BUCKLE_ONLY = "仅扣扣子"
    LAP_ONLY = "仅腰带"
    BEHIND_BACK = "背后佩戴"
    UNBUCKLED = "未扣"

class RoutingStatus(Enum):
    """路由状态"""
    NORMAL = "正常"
    MISROUTED = "误路由"
    MISSING = "缺失"

@dataclass
class BeltDetectionResult:
    """安全带检测结果"""
    buckle_status: str              # 扣子状态
    shoulder_belt_status: RoutingStatus  # 肩带状态
    lap_belt_status: RoutingStatus        # 腰带状态
    overall_status: BeltStatus     # 综合状态
    confidence: float              # 置信度
    keypoints: Dict[str, Tuple[float, float]]  # 关键点坐标

class SeatbeltMisuseDetector:
    """
    安全带误用检测器
    
    检测流程：
    1. YOLOv8检测驾驶员身体关键点
    2. 识别安全带扣子位置和状态
    3. 检测肩带路由（肩部→胸部→扣子）
    4. 检测腰带路由（腰部→大腿→扣子）
    5. 综合判定佩戴状态
    """
    
    def __init__(self, config: dict):
        """
        Args:
            config: 配置字典
                - model_path: YOLOv8模型路径
                - confidence_threshold: 置信度阈值
                - camera_type: 摄像头类型 (RGB/IR)
        """
        self.conf_thresh = config.get('confidence_threshold', 0.85)
        self.camera_type = config.get('camera_type', 'RGB')
        
        # 身体关键点定义（参考COCO格式）
        self.body_keypoints = {
            'left_shoulder': 5,
            'right_shoulder': 6,
            'left_elbow': 7,
            'right_elbow': 8,
            'left_hip': 11,
            'right_hip': 12,
            'chest_center': None  # 需计算
        }
        
        # 安全带关键点
        self.belt_keypoints = {
            'buckle_anchor': None,     # 扣子锚点（固定在座椅）
            'shoulder_anchor': None,   # 肩带锚点（B柱）
            'lap_anchor': None,        # 腰带锚点（座椅侧面）
            'buckle_insert': None,     # 扣子插口
        }
        
    def detect_body_keypoints(
        self, 
        image: np.ndarray
    ) -> Dict[str, Tuple[float, float, float]]:
        """
        检测身体关键点
        
        Args:
            image: 输入图像, shape=(H, W, 3)
            
        Returns:
            keypoints: 关键点字典，key: 点名, value: (x, y, confidence)
        
        使用YOLOv8-pose模型检测身体关键点
        """
        # 实际实现中调用YOLOv8模型
        # 这里给出伪代码结构
        
        # 模型推理
        # results = self.model.predict(image)
        # keypoints = results[0].keypoints
        
        # 简化示例：返回模拟数据
        H, W = image.shape[:2]
        
        keypoints = {
            'left_shoulder': (W * 0.35, H * 0.25, 0.92),
            'right_shoulder': (W * 0.65, H * 0.25, 0.91),
            'left_elbow': (W * 0.30, H * 0.35, 0.88),
            'right_elbow': (W * 0.70, H * 0.35, 0.87),
            'left_hip': (W * 0.40, H * 0.55, 0.90),
            'right_hip': (W * 0.60, H * 0.55, 0.89),
        }
        
        # 计算胸部中心
        left_shoulder = keypoints['left_shoulder']
        right_shoulder = keypoints['right_shoulder']
        chest_x = (left_shoulder[0] + right_shoulder[0]) / 2
        chest_y = (left_shoulder[1] + right_shoulder[1]) / 2 + H * 0.08
        keypoints['chest_center'] = (chest_x, chest_y, 0.85)
        
        return keypoints
    
    def detect_buckle(
        self, 
        image: np.ndarray,
        body_keypoints: Dict
    ) -> Tuple[bool, Tuple[float, float], float]:
        """
        检测安全带扣子
        
        Args:
            image: 输入图像
            body_keypoints: 身体关键点
            
        Returns:
            is_buckled: 是否扣好
            buckle_pos: 扣子位置 (x, y)
            confidence: 置信度
        
        扣子检测策略：
        1. 在腰部右侧（right_hip附近）搜索扣子区域
        2. 检测扣子特征：金属反光、圆形形状
        3. 判断是否有插入片（已扣状态）
        """
        # 扣子通常在右髋附近
        right_hip = body_keypoints['right_hip']
        
        # ROI区域：右髋±50px
        roi_x = int(right_hip[0]) - 50
        roi_y = int(right_hip[1]) - 30
        
        # 在实际实现中：
        # 1. 提取ROI区域
        # 2. 用专门的扣子检测模型判断状态
        
        # 模拟返回
        is_buckled = True  # 模拟扣好状态
        buckle_pos = (right_hip[0] + 20, right_hip[1])
        confidence = 0.96
        
        return is_buckled, buckle_pos, confidence
    
    def detect_shoulder_belt(
        self,
        image: np.ndarray,
        body_keypoints: Dict,
        buckle_pos: Tuple[float, float]
    ) -> Tuple[RoutingStatus, List[Tuple[float, float]], float]:
        """
        检测肩带路由
        
        Args:
            image: 输入图像
            body_keypoints: 身体关键点
            buckle_pos: 扣子位置
            
        Returns:
            status: 肩带路由状态
            path: 肩带路径关键点列表
            confidence: 置信度
        
        正确路由：肩部锚点 → 肩部 → 胸部 → 扣子
        误路由检测：肩带不在肩部→胸部路径上
        """
        left_shoulder = body_keypoints['left_shoulder']
        chest_center = body_keypoints['chest_center']
        
        # 肩带正确路径应该是：
        # B柱锚点 → 左肩 → 胸部中 → 扣子
        
        # 检测策略：
        # 1. 在左肩到胸部区域搜索肩带线条
        # 2. 检测线条是否连续
        # 3. 判断线条是否穿过胸部
        
        # 简化实现：基于关键点位置推断
        # 如果在左肩→胸部→扣子路径上有连续线条，则为正常
        
        # 模拟路径点
        shoulder_anchor = (left_shoulder[0] - 50, left_shoulder[1] - 100)
        normal_path = [
            shoulder_anchor,
            (left_shoulder[0], left_shoulder[1]),
            (chest_center[0], chest_center[1]),
            buckle_pos
        ]
        
        # 检测肩带是否存在（简化）
        # 实际实现需要线条检测算法
        has_shoulder_belt = True  # 模拟存在
        
        if has_shoulder_belt:
            # 检查是否在正确位置
            # 实际需要线条跟踪算法
            status = RoutingStatus.NORMAL
            confidence = 0.92
        else:
            status = RoutingStatus.MISSING
            confidence = 0.88
        
        return status, normal_path, confidence
    
    def detect_lap_belt(
        self,
        image: np.ndarray,
        body_keypoints: Dict,
        buckle_pos: Tuple[float, float]
    ) -> Tuple[RoutingStatus, List[Tuple[float, float]], float]:
        """
        检测腰带路由
        
        Args:
            image: 输入图像
            body_keypoints: 身体关键点
            buckle_pos: 扣子位置
            
        Returns:
            status: 腰带路由状态
            path: 腰带路径关键点列表
            confidence: 置信度
        
        正确路由：座椅侧面锚点 → 左髋 → 右髋 → 扣子
        """
        left_hip = body_keypoints['left_hip']
        right_hip = body_keypoints['right_hip']
        
        # 腰带正确路径：
        # 左侧锚点 → 左髋 → 大腿 → 右髋 → 扣子
        
        lap_anchor_left = (left_hip[0] - 60, left_hip[1])
        normal_path = [
            lap_anchor_left,
            (left_hip[0], left_hip[1] + 30),
            (right_hip[0], right_hip[1] + 30),
            buckle_pos
        ]
        
        # 检测腰带是否存在
        has_lap_belt = True  # 模拟
        
        if has_lap_belt:
            status = RoutingStatus.NORMAL
            confidence = 0.91
        else:
            status = RoutingStatus.MISSING
            confidence = 0.87
        
        return status, normal_path, confidence
    
    def classify_belt_status(
        self,
        is_buckled: bool,
        shoulder_status: RoutingStatus,
        lap_status: RoutingStatus
    ) -> BeltStatus:
        """
        综合判定安全带状态
        
        Args:
            is_buckled: 扣子是否扣好
            shoulder_status: 肩带状态
            lap_status: 腰带状态
            
        Returns:
            overall_status: 综合状态
        
        判定逻辑：
        - 未扣扣子 → UNBUCKLED
        - 已扣扣子 + 无肩带 + 无腰带 → BUCKLE_ONLY
        - 已扣扣子 + 有腰带 + 无肩带 → LAP_ONLY
        - 已扣扣子 + 无肩带(背后) → BEHIND_BACK
        - 已扣扣子 + 正常肩带 + 正常腰带 → CORRECT
        """
        if not is_buckled:
            return BeltStatus.UNBUCKLED
        
        # 扣子已扣，检查路由
        if shoulder_status == RoutingStatus.MISSING and \
           lap_status == RoutingStatus.MISSING:
            return BeltStatus.BUCKLE_ONLY
        
        if shoulder_status == RoutingStatus.MISSING and \
           lap_status == RoutingStatus.NORMAL:
            return BeltStatus.LAP_ONLY
        
        if shoulder_status == RoutingStatus.MISROUTED:
            return BeltStatus.BEHIND_BACK
        
        if shoulder_status == RoutingStatus.NORMAL and \
           lap_status == RoutingStatus.NORMAL:
            return BeltStatus.CORRECT
        
        # 其他情况视为误用
        return BeltStatus.BEHIND_BACK
    
    def detect(
        self, 
        image: np.ndarray
    ) -> BeltDetectionResult:
        """
        完整安全带检测流程
        
        Args:
            image: 输入图像
            
        Returns:
            result: 检测结果
        """
        # 1. 检测身体关键点
        body_kps = self.detect_body_keypoints(image)
        
        # 2. 检测扣子状态
        is_buckled, buckle_pos, buckle_conf = self.detect_buckle(
            image, body_kps
        )
        
        # 3. 检测肩带
        shoulder_status, shoulder_path, shoulder_conf = \
            self.detect_shoulder_belt(image, body_kps, buckle_pos)
        
        # 4. 检测腰带
        lap_status, lap_path, lap_conf = \
            self.detect_lap_belt(image, body_kps, buckle_pos)
        
        # 5. 综合判定
        overall_status = self.classify_belt_status(
            is_buckled, shoulder_status, lap_status
        )
        
        # 综合置信度
        overall_conf = np.mean([
            buckle_conf, shoulder_conf, lap_conf
        ])
        
        # 组装关键点
        all_keypoints = {
            'buckle': buckle_pos,
            'shoulder_path': tuple(shoulder_path),
            'lap_path': tuple(lap_path),
        }
        
        return BeltDetectionResult(
            buckle_status="已扣" if is_buckled else "未扣",
            shoulder_belt_status=shoulder_status,
            lap_belt_status=lap_status,
            overall_status=overall_status,
            confidence=overall_conf,
            keypoints=all_keypoints
        )


# 测试代码
if __name__ == "__main__":
    config = {
        'confidence_threshold': 0.85,
        'camera_type': 'RGB'
    }
    
    detector = SeatbeltMisuseDetector(config)
    
    # 创建模拟图像
    image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
    
    # 执行检测
    result = detector.detect(image)
    
    print(f"扣子状态: {result.buckle_status}")
    print(f"肩带状态: {result.shoulder_belt_status.value}")
    print(f"腰带状态: {result.lap_belt_status.value}")
    print(f"综合状态: {result.overall_status.value}")
    print(f"置信度: {result.confidence:.2f}")

2.4 Gated Bi-LSTM序列检测方案

参考 Gu et al. Expert Systems with Applications 2024 论文，使用时序模型提升检测稳定性：

"""
基于Gated Bi-LSTM的安全带序列检测
参考：Gu et al., Expert Syst. Appl. 2024

核心思想：
- 单帧检测可能不稳定（遮挡、光照）
- 使用Bi-LSTM融合多帧特征
- 时序一致性过滤抖动
"""

import torch
import torch.nn as nn
import numpy as np

class GatedBiLSTMSeatbelt(nn.Module):
    """
    Gated Bi-LSTM安全带检测模型
    
    结构：
    1. 特征提取：从每帧提取安全带特征向量
    2. Bi-LSTM：双向时序建模
    3. Gate机制：自适应权重调整
    4. 分类头：输出安全带状态
    """
    
    def __init__(
        self,
        feature_dim: int = 256,
        hidden_dim: int = 128,
        num_classes: int = 5,  # 5种状态
        num_frames: int = 30,  # 30帧序列
        dropout: float = 0.3
    ):
        super().__init__()
        
        self.feature_dim = feature_dim
        self.hidden_dim = hidden_dim
        self.num_frames = num_frames
        
        # 特征提取（假设已由CNN提取）
        # 这里只实现LSTM部分
        
        # Bi-LSTM层
        self.bilstm = nn.LSTM(
            input_size=feature_dim,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
            dropout=dropout
        )
        
        # Gate机制
        self.gate = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.Sigmoid()
        )
        
        # 分类头
        self.classifier = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, num_classes)
        )
        
    def forward(
        self, 
        x: torch.Tensor,
        features_per_frame: Optional[torch.Tensor] = None
    ) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 输入特征序列, shape=(B, T, feature_dim)
               B: batch size
               T: 时间步数（帧数）
               feature_dim: 特征维度
            
        Returns:
            logits: 分类输出, shape=(B, num_classes)
        """
        # Bi-LSTM编码
        lstm_out, (h_n, c_n) = self.bilstm(x)
        
        # lstm_out: (B, T, hidden_dim*2)
        # 取最后一帧的双向输出
        final_hidden = lstm_out[:, -1, :]  # (B, hidden_dim*2)
        
        # Gate机制
        gate_weight = self.gate(final_hidden)  # (B, hidden_dim)
        
        # 应用Gate
        gated_hidden = final_hidden * gate_weight
        
        # 分类
        logits = self.classifier(gated_hidden)
        
        return logits
    
    def extract_frame_features(
        self,
        frames: np.ndarray,
        cnn_model: nn.Module
    ) -> torch.Tensor:
        """
        从帧序列提取特征
        
        Args:
            frames: 帧序列, shape=(T, H, W, C)
            cnn_model: CNN特征提取模型
            
        Returns:
            features: 特征序列, shape=(T, feature_dim)
        
        实际实现中使用预训练CNN（如ResNet18）
        """
        T = len(frames)
        features = []
        
        for frame in frames:
            # CNN特征提取
            # feature = cnn_model(frame)
            # 简化：模拟特征
            feature = torch.randn(self.feature_dim)
            features.append(feature)
        
        return torch.stack(features)  # (T, feature_dim)


# 测试
if __name__ == "__main__":
    model = GatedBiLSTMSeatbelt(
        feature_dim=256,
        hidden_dim=128,
        num_classes=5
    )
    
    # 模拟输入：batch=4, frames=30, features=256
    x = torch.randn(4, 30, 256)
    
    logits = model(x)
    probs = torch.softmax(logits, dim=-1)
    
    print(f"输出shape: {logits.shape}")
    print(f"预测类别分布（第1个样本）:")
    classes = ['正确', '仅扣扣子', '仅腰带', '背后', '未扣']
    for i, cls in enumerate(classes):
        print(f"  {cls}: {probs[0, i].item():.2%}")

3. 乘员姿态估计：辅助误用检测

3.1 为什么需要姿态估计？

场景	仅安全带检测局限	姿态估计辅助
手臂遮挡肩带	无法确认肩带位置	推断手臂位置，判断遮挡区域
背后佩戴	背后不可见	从肩部姿态推断（肩部后倾）
腿部遮挡腰带	无法确认腰带	从髋部姿态推断位置
非正常坐姿	可能误判	先判断坐姿正常性

3.2 3D姿态估计方案（参考 Sensors 2024）

"""
乘员3D姿态估计辅助安全带误用检测
参考：Tambwekar et al., Sensors 2024
      "Three-Dimensional Posture Estimation of Vehicle Occupants 
       Using Depth and Infrared Images"

核心思想：
- 使用深度摄像头+红外摄像头
- 估计身体3D姿态
- 推断安全带路由合理性
"""

import numpy as np
from typing import Dict, Tuple

class OccupantPoseEstimator:
    """
    乘员3D姿态估计器
    
    输入：
    - RGB图像
    - 深度图像（可选）
    - 红外图像（可选）
    
    输出：
    - 3D身体关键点
    - 坐姿分类
    - 安全带路由可行性判断
    """
    
    def __init__(self):
        # 关键点定义（3D）
        self.keypoint_names = [
            'head_top',
            'neck',
            'left_shoulder', 'right_shoulder',
            'left_elbow', 'right_elbow',
            'left_hip', 'right_hip',
            'left_knee', 'right_knee',
            'chest_center',
            'spine_mid'
        ]
        
    def estimate_3d_pose(
        self,
        rgb_image: np.ndarray,
        depth_image: Optional[np.ndarray] = None,
        ir_image: Optional[np.ndarray] = None
    ) -> Dict[str, Tuple[float, float, float]]:
        """
        估计3D姿态
        
        Args:
            rgb_image: RGB图像, shape=(H, W, 3)
            depth_image: 深度图, shape=(H, W), 单位mm
            ir_image: 红外图像, shape=(H, W)
            
        Returns:
            keypoints_3d: 3D关键点字典, (x, y, z)
        
        深度传感器配置（参考论文）：
        - Azure Kinect DK或类似
        - 深度分辨率：512x512
        - 深度范围：0.25-5m
        """
        H, W = rgb_image.shape[:2]
        
        # 2D关键点检测
        # keypoints_2d = detect_2d_keypoints(rgb_image)
        
        # 模拟2D关键点
        keypoints_2d = {
            'left_shoulder': (W * 0.35, H * 0.25),
            'right_shoulder': (W * 0.65, H * 0.25),
            'left_hip': (W * 0.40, H * 0.55),
            'right_hip': (W * 0.60, H * 0.55),
        }
        
        # 2D→3D转换（需要深度图）
        keypoints_3d = {}
        
        if depth_image is not None:
            for name, (x, y) in keypoints_2d.items():
                z = depth_image[int(y), int(x)]  # 深度值(mm)
                keypoints_3d[name] = (x, y, z)
        else:
            # 无深度时，使用估计值
            for name, (x, y) in keypoints_2d.items():
                z = np.random.uniform(800, 1200)  # 模拟800-1200mm
                keypoints_3d[name] = (x, y, z)
        
        return keypoints_3d
    
    def check_belt_routing_feasibility(
        self,
        keypoints_3d: Dict[str, Tuple[float, float, float]],
        belt_anchor_points: Dict[str, Tuple[float, float, float]]
    ) -> Dict[str, bool]:
        """
        检查安全带路由可行性
        
        Args:
            keypoints_3d: 身体3D关键点
            belt_anchor_points: 安全带锚点位置
            
        Returns:
            feasibility: 各路由路径可行性
        
        逻辑：
        1. 计算肩带理想路径（肩锚点→肩部→胸部）
        2. 计算腰带理想路径（腰锚点→髋部→扣子）
        3. 检查身体姿态是否允许这些路径
        """
        left_shoulder = keypoints_3d['left_shoulder']
        right_hip = keypoints_3d['right_hip']
        
        # 肩带锚点（B柱）
        shoulder_anchor = belt_anchor_points.get(
            'shoulder_anchor', 
            (left_shoulder[0] - 100, left_shoulder[1], left_shoulder[2])
        )
        
        # 检查肩部是否在合理位置
        # 肩部应该在前方，而非后方
        shoulder_feasible = left_shoulder[2] < shoulder_anchor[2] + 200
        
        # 腰带锚点（座椅侧面）
        lap_anchor = belt_anchor_points.get(
            'lap_anchor',
            (right_hip[0] + 100, right_hip[1], right_hip[2])
        )
        
        # 检查髋部是否在合理位置
        lap_feasible = right_hip[2] < lap_anchor[2] + 200
        
        return {
            'shoulder_belt_feasible': shoulder_feasible,
            'lap_belt_feasible': lap_feasible,
            'overall_feasible': shoulder_feasible and lap_feasible
        }
    
    def classify_posture(
        self,
        keypoints_3d: Dict[str, Tuple[float, float, float]]
    ) -> str:
        """
        坐姿分类
        
        Args:
            keypoints_3d: 身体3D关键点
            
        Returns:
            posture: 坐姿类别
        
        坐姿类型：
        - NORMAL: 正常坐姿
        - LEANING_FORWARD: 前倾（靠近仪表板）
        - LEANING_BACK: 后倾（背后佩戴可能）
        - SIDEWAYS: 侧倾
        """
        # 计算脊柱倾斜角度
        neck = keypoints_3d.get('neck', (0, 0, 0))
        spine_mid = keypoints_3d.get('spine_mid', (0, 0, 0))
        
        if neck[2] > 0 and spine_mid[2] > 0:
            # Z轴方向判断前倾/后倾
            z_diff = neck[2] - spine_mid[2]
            
            if z_diff > 50:  # 前倾
                return 'LEANING_FORWARD'
            elif z_diff < -50:  # 后倾
                return 'LEANING_BACK'
        
        return 'NORMAL'


# 测试
if __name__ == "__main__":
    estimator = OccupantPoseEstimator()
    
    # 模拟RGB图像
    rgb = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
    depth = np.random.randint(800, 1200, (480, 640), dtype=np.uint16)
    
    keypoints_3d = estimator.estimate_3d_pose(rgb, depth)
    posture = estimator.classify_posture(keypoints_3d)
    
    print(f"坐姿分类: {posture}")
    print(f"关键点示例:")
    for name, pos in keypoints_3d.items():
        print(f"  {name}: ({pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f}mm)")

4. 系统集成架构

graph TD
    A[RGB摄像头] --> B[身体关键点检测]
    C[红外摄像头] --> D[暗光安全带检测]
    E[深度摄像头] --> F[3D姿态估计]
    
    B --> G[安全带路由分析]
    D --> G
    F --> H[坐姿可行性判断]
    
    G --> I[误用分类]
    H --> I
    
    I --> J{误用类型}
    J --> K[仅扣扣子]
    J --> L[仅腰带]
    J --> M[背后佩戴]
    J --> N[正确佩戴]
    
    K --> O[触发警告]
    L --> O
    M --> O
    N --> P[正常状态]
    
    O --> Q[声音警告90秒]
    O --> R[视觉警告持续]

5. IMS开发启示

5.1 开发优先级

优先级	开发项	技术路线	周期	验证方法
🔴 P0	扣子状态检测	现有传感器接口	1周	1000次扣/拔测试
🔴 P0	肩带关键点检测	YOLOv8-pose	3周	多光照场景
🔴 P0	腰带关键点检测	同上	3周	不同衣服材质
🟡 P1	时序稳定性	Bi-LSTM	2周	30帧序列测试
🟡 P1	3D姿态辅助	深度摄像头	4周	与RGB对比
🟢 P2	警告系统集成	状态机	1周	Euro NCAP协议测试
🟢 P2	多座椅扩展	复用驾驶员方案	2周	后排实测

5.2 性能指标要求

指标	Euro NCAP要求	IMS目标	测试场景
扣子检测准确率	≥98%	≥99%	10万次测试
肩带路由检测率	≥95%	≥97%	多光照+遮挡
腰带路由检测率	≥95%	≥96%	不同体型
误报率	≤5%	≤2%	正常佩戴场景
检测延迟	≤30秒	≤15秒	从行程开始
暗光性能	必须	✅	0-500 lux

5.3 硬件选型建议

组件	推荐型号	参数	成本
RGB摄像头	OV2311	2MP, 全局快门	$8
红外摄像头	同上 + 红外补光	940nm, 120mW	+$5
深度摄像头	Azure Kinect DK（开发）	512x512, 0.25-5m	~$400
量产深度方案	PMD TOF	640x480, 定制	~$30

6. 总结

Euro NCAP 2026 安全带误用检测从二元状态升级为路由分析，要求视觉AI系统具备：

1. 扣子状态检测：金属扣子识别，插入片判断
2. 肩带路由分析：肩→胸→扣路径跟踪
3. 腰带路由分析：髋→腿→扣路径跟踪
4. 时序稳定性：Bi-LSTM多帧融合
5. 姿态辅助：3D姿态估计推断遮挡区域

核心技术路线：YOLOv8-pose + Gated Bi-LSTM + 深度摄像头辅助。IMS开发需重点关注肩带遮挡场景的鲁棒性和暗光环境性能。

---

参考链接：

• https://www.euroncap.com/en/for-engineers/protocols/2026-protocols/
• https://smarteye.se/blog/euro-ncap-2026-seatbelt-use/
• https://www.skyengine.ai/blog/navigating-euro-ncap-2026-how-synthetic-data-powers-next-gen-in-cabin-monitoring-systems
• https://link.springer.com/chapter/10.1007/978-3-032-24239-6_12
• https://www.mdpi.com/2076-3417/14/8/3346
• https://www.mdpi.com/1424-8220/24/17/5530