Euro NCAP 2026安全带误用检测技术要求与实现方案

法规背景

Euro NCAP 2026新增”安全带误用检测”（Seatbelt Misuse Detection）要求，这是对传统”安全带未系检测”的升级。

误用场景定义：

误用类型	描述	检测难度
肩带滑落	肩带从肩膀滑落到手臂下方	高
腰带过松	腰带未收紧，预留过多空隙	中等
腰带位置错误	腰带位于腹部而非髋骨	高
背后扣合	安全带绕过身体背部扣合	极高
儿童误用	儿童使用成人安全带（肩带卡脖子）	高

技术难点

传统传感器方案的局限

传感器	原理	可检测项	误用检测能力
卷收器传感器	检测安全带拉出长度	未系/已系	❌ 无法检测误用
张紧传感器	检测安全带张力	松脱	🟡 仅能检测过松
座椅传感器	检测座椅承重	有人/无人	❌ 无法检测误用

结论： 传统传感器无法检测肩带滑落、背后扣合等误用场景，必须引入视觉感知。

视觉检测方案

KPGBeltNet算法架构

基于最新论文（The Visual Computer, 2026）的检测方案：

"""
KPGBeltNet: 基于人体关键点引导的安全带检测算法
论文：KPGBeltNet: in-vehicle seatbelt detection algorithm based on 
      human keypoint-guided sampling and local–global attention
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from typing import Tuple, List

class KeypointGuidedSampling(nn.Module):
    """
    关键点引导采样模块
    
    思路：根据人体关键点（肩、腰）裁剪安全带感兴趣区域
    """
    
    def __init__(self):
        super().__init__()
        
        # 关键点索引（COCO格式）
        self.shoulder_left = 5
        self.shoulder_right = 6
        self.hip_left = 11
        self.hip_right = 12
    
    def forward(
        self, 
        image: torch.Tensor,
        keypoints: torch.Tensor
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        根据关键点裁剪安全带区域
        
        Args:
            image: 输入图像 (B, 3, H, W)
            keypoints: 关键点坐标 (B, 17, 3) - x, y, confidence
        
        Returns:
            shoulder_crop: 肩部裁剪区域 (B, 3, crop_size, crop_size)
            hip_crop: 腰部裁剪区域
        """
        B, C, H, W = image.shape
        
        # 提取肩部关键点
        left_shoulder = keypoints[:, self.shoulder_left, :2]  # (B, 2)
        right_shoulder = keypoints[:, self.shoulder_right, :2]
        
        # 计算肩部中心
        shoulder_center = (left_shoulder + right_shoulder) / 2  # (B, 2)
        
        # 计算裁剪框（以肩部为中心，扩展到腰部）
        crop_size = 128
        
        # 腰部关键点
        left_hip = keypoints[:, self.hip_left, :2]
        right_hip = keypoints[:, self.hip_right, :2]
        hip_center = (left_hip + right_hip) / 2
        
        # 裁剪肩部区域（检测肩带是否滑落）
        shoulder_boxes = self._get_crop_boxes(
            shoulder_center, crop_size, H, W
        )
        shoulder_crop = self._crop_and_resize(image, shoulder_boxes, crop_size)
        
        # 裁剪腰部区域（检测腰带位置）
        hip_boxes = self._get_crop_boxes(hip_center, crop_size, H, W)
        hip_crop = self._crop_and_resize(image, hip_boxes, crop_size)
        
        return shoulder_crop, hip_crop
    
    def _get_crop_boxes(
        self, 
        centers: torch.Tensor, 
        size: int, 
        H: int, 
        W: int
    ) -> torch.Tensor:
        """计算裁剪框坐标"""
        B = centers.shape[0]
        boxes = torch.zeros(B, 4, device=centers.device)
        
        half = size // 2
        boxes[:, 0] = centers[:, 0] - half  # x1
        boxes[:, 1] = centers[:, 1] - half  # y1
        boxes[:, 2] = centers[:, 0] + half  # x2
        boxes[:, 3] = centers[:, 1] + half  # y2
        
        # 归一化到[0, 1]
        boxes[:, [0, 2]] /= W
        boxes[:, [1, 3]] /= H
        
        return boxes
    
    def _crop_and_resize(
        self, 
        image: torch.Tensor,
        boxes: torch.Tensor,
        size: int
    ) -> torch.Tensor:
        """裁剪并调整大小"""
        B = image.shape[0]
        
        # 使用grid_sample进行裁剪
        grid = self._boxes_to_grid(boxes, size)
        cropped = F.grid_sample(
            image, grid, 
            mode='bilinear', 
            padding_mode='zeros',
            align_corners=True
        )
        
        return cropped
    
    def _boxes_to_grid(self, boxes: torch.Tensor, size: int) -> torch.Tensor:
        """将boxes转换为grid坐标"""
        B = boxes.shape[0]
        
        # 生成归一化网格
        y = torch.linspace(-1, 1, size, device=boxes.device)
        x = torch.linspace(-1, 1, size, device=boxes.device)
        grid_y, grid_x = torch.meshgrid(y, x, indexing='ij')
        
        grid = torch.stack([grid_x, grid_y], dim=-1)  # (size, size, 2)
        grid = grid.unsqueeze(0).expand(B, -1, -1, -1)  # (B, size, size, 2)
        
        return grid


class LocalGlobalAttention(nn.Module):
    """
    局部-全局注意力模块
    
    局部：精细检测安全带边缘
    全局：理解安全带与身体的关系
    """
    
    def __init__(self, in_channels: int):
        super().__init__()
        
        # 局部注意力（卷积）
        self.local_attention = nn.Sequential(
            nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1, groups=in_channels),
            nn.BatchNorm2d(in_channels),
            nn.ReLU(),
            nn.Conv2d(in_channels, in_channels, kernel_size=1),
            nn.Sigmoid()
        )
        
        # 全局注意力（SE模块）
        self.global_attention = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_channels, in_channels // 8, kernel_size=1),
            nn.ReLU(),
            nn.Conv2d(in_channels // 8, in_channels, kernel_size=1),
            nn.Sigmoid()
        )
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 输入特征 (B, C, H, W)
        
        Returns:
            out: 注意力增强后的特征
        """
        # 局部注意力
        local_weight = self.local_attention(x)
        local_out = x * local_weight
        
        # 全局注意力
        global_weight = self.global_attention(x)
        global_out = x * global_weight
        
        # 融合
        out = local_out + global_out
        
        return out


class SeatbeltMisuseDetector(nn.Module):
    """
    安全带误用检测器
    
    检测项：
    1. 肩带是否正确位置
    2. 腰带是否正确位置
    3. 安全带是否扣合
    """
    
    def __init__(self, config: dict):
        """
        Args:
            config: 配置参数
                - backbone: 骨干网络类型（resnet18/resnet34）
                - num_classes: 分类数（默认5：正常、肩带滑落、腰带过松、腰带位置错误、背后扣合）
        """
        super().__init__()
        
        self.num_classes = config.get('num_classes', 5)
        
        # 关键点引导采样
        self.kgp_sampling = KeypointGuidedSampling()
        
        # 骨干网络（肩部）
        self.shoulder_backbone = self._build_backbone(config.get('backbone', 'resnet18'))
        
        # 骨干网络（腰部）
        self.hip_backbone = self._build_backbone(config.get('backbone', 'resnet18'))
        
        # 局部-全局注意力
        self.shoulder_attention = LocalGlobalAttention(512)
        self.hip_attention = LocalGlobalAttention(512)
        
        # 分类头
        self.classifier = nn.Sequential(
            nn.Linear(512 * 2, 256),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, self.num_classes)
        )
    
    def _build_backbone(self, name: str) -> nn.Module:
        """构建骨干网络"""
        import torchvision.models as models
        
        if name == 'resnet18':
            model = models.resnet18(pretrained=True)
            model = nn.Sequential(*list(model.children())[:-1])  # 移除FC层
        elif name == 'resnet34':
            model = models.resnet34(pretrained=True)
            model = nn.Sequential(*list(model.children())[:-1])
        else:
            raise ValueError(f"Unknown backbone: {name}")
        
        return model
    
    def forward(
        self, 
        image: torch.Tensor, 
        keypoints: torch.Tensor
    ) -> torch.Tensor:
        """
        前向传播
        
        Args:
            image: 输入图像 (B, 3, H, W)
            keypoints: 人体关键点 (B, 17, 3)
        
        Returns:
            logits: 分类输出 (B, num_classes)
        """
        # 关键点引导裁剪
        shoulder_crop, hip_crop = self.kgp_sampling(image, keypoints)
        
        # 骨干网络特征提取
        shoulder_feat = self.shoulder_backbone(shoulder_crop)  # (B, 512, 1, 1)
        hip_feat = self.hip_backbone(hip_crop)
        
        # 注意力增强
        shoulder_feat = self.shoulder_attention(shoulder_feat)
        hip_feat = self.hip_attention(hip_feat)
        
        # 展平
        shoulder_feat = shoulder_feat.flatten(1)  # (B, 512)
        hip_feat = hip_feat.flatten(1)
        
        # 拼接
        fused_feat = torch.cat([shoulder_feat, hip_feat], dim=1)  # (B, 1024)
        
        # 分类
        logits = self.classifier(fused_feat)
        
        return logits


# 测试示例
if __name__ == "__main__":
    # 配置
    config = {
        'backbone': 'resnet18',
        'num_classes': 5
    }
    
    # 初始化模型
    model = SeatbeltMisuseDetector(config)
    model.eval()
    
    # 模拟输入
    B = 2
    H, W = 480, 640
    image = torch.randn(B, 3, H, W)
    
    # 模拟关键点（COCO格式：17个关键点）
    keypoints = torch.zeros(B, 17, 3)
    # 肩部关键点
    keypoints[:, 5, :2] = torch.tensor([[200, 150], [220, 160]])  # 左肩
    keypoints[:, 6, :2] = torch.tensor([[400, 150], [380, 160]])  # 右肩
    # 腰部关键点
    keypoints[:, 11, :2] = torch.tensor([[240, 350], [260, 360]])  # 左腰
    keypoints[:, 12, :2] = torch.tensor([[360, 350], [340, 360]])  # 右腰
    keypoints[:, :, 2] = 1.0  # 置信度
    
    # 推理
    with torch.no_grad():
        logits = model(image, keypoints)
    
    # 输出
    misuse_types = ['正常', '肩带滑落', '腰带过松', '腰带位置错误', '背后扣合']
    predictions = torch.argmax(logits, dim=-1)
    
    print(f"预测结果:")
    for i, pred in enumerate(predictions):
        print(f"  样本{i+1}: {misuse_types[pred.item()]}")
    
    # 参数统计
    total_params = sum(p.numel() for p in model.parameters())
    print(f"\n模型参数量: {total_params:,} ({total_params/1e6:.2f}M)")

检测性能评估

测试数据集

使用公开数据集验证：

数据集	场景	样本数	标注类别
KPG-Belt-10K	多姿态、多车型	10,000	正常、肩带滑落、腰带错误
SEAT-DET	交通监控	5,000	系/未系

准确率对比

方法	正常检测	肩带滑落	腰带错误	平均mAP
传统CNN	92.3%	65.7%	58.2%	72.1%
YOLOv7	94.1%	71.3%	64.5%	76.6%
KPGBeltNet	96.5%	84.2%	79.8%	86.8%

提升原因： 关键点引导采样聚焦安全带区域，局部-全局注意力提升细节感知。

Euro NCAP合规检查

功能要求

• 检测肩带是否在肩膀上
• 检测腰带是否在髋骨位置
• 检测安全带是否过松
• 检测背后扣合（精度待提升）
• 误报率 < 5%

性能要求

• 检测延迟 < 3秒
• 支持0-100km/h全速域
• 支持不同体型乘员
• 支持不同服装（厚外套、裙子等）

---

开发启示： 安全带误用检测需要视觉感知，传统传感器无法胜任。建议采用关键点引导的检测方案，优先实现肩带滑落和腰带位置检测，背后扣合作为长期目标。