ChairPose：基于压力分布的座椅姿态估计及其IMS应用

论文信息

核心创新

ChairPose是首个无需穿戴设备、基于压力传感的全身体态估计系统，可在任意座椅形状上工作，无需为每种座椅重新训练或校准。

关键突破：

  1. 仅用压力床垫即可重建全身3D姿态（MPJE 89.4mm）
  2. 显式引入座椅形态学，跨座椅泛化无需重训练
  3. 物理驱动数据增强，模拟真实座椅/用户多样性
  4. 实时运行，隐私友好（无视觉传感器）

方法详解

1. 问题定义

输入： 压力分布矩阵 P ∈ ℝ^{m×n}（来自TPE压力床垫）
座椅形态： 3D座椅扫描模型 C
输出： 全身3D姿态序列 Θ = [θ₁, θ₂, ..., θ_T]，包含17个关节点

挑战：

  • 压力信号只反映接触面，无法直接推断非接触部位
  • 不同座椅形状影响压力分布模式
  • 真实数据采集成本高、多样性有限

2. 两阶段生成模型

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
# ChairPose 核心架构（复现代码）
import torch
import torch.nn as nn

class ChairPoseStage1(nn.Module):
    """
    第一阶段：压力→初始姿态猜测
    
    输入：压力矩阵 + 座椅形态编码
    输出：粗略姿态估计
    """
    def __init__(self, pressure_dim=(64, 48), chair_dim=128):
        super().__init__()
        # 压力编码器（CNN）
        self.pressure_encoder = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=5, stride=2, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((4, 4)),
            nn.Flatten()
        )
        
        # 座椅形态编码器（PointNet变体）
        self.chair_encoder = nn.Sequential(
            nn.Linear(1024, 512),
            nn.ReLU(),
            nn.Linear(512, chair_dim)
        )
        
        # 融合解码器
        self.decoder = nn.Sequential(
            nn.Linear(128*16 + chair_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 17*3)  # 17个关节点，每个3D坐标
        )
    
    def forward(self, pressure, chair_features):
        """
        Args:
            pressure: (B, 64, 48) 压力矩阵
            chair_features: (B, 1024) 座椅点云特征
        
        Returns:
            pose_init: (B, 17, 3) 初始姿态估计
        """
        p_feat = self.pressure_encoder(pressure.unsqueeze(1))
        c_feat = self.chair_encoder(chair_features)
        fused = torch.cat([p_feat, c_feat], dim=1)
        pose_flat = self.decoder(fused)
        return pose_flat.view(-1, 17, 3)


class ChairPoseStage2(nn.Module):
    """
    第二阶段：时序精细化
    
    利用时序连续性优化姿态估计
    """
    def __init__(self, pose_dim=17*3):
        super().__init__()
        self.temporal_refine = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=pose_dim, nhead=8),
            num_layers=3
        )
        self.output_proj = nn.Linear(pose_dim, pose_dim)
    
    def forward(self, pose_sequence):
        """
        Args:
            pose_sequence: (B, T, 51) 时序姿态序列
        
        Returns:
            refined_pose: (B, T, 17, 3) 精细化姿态
        """
        refined = self.temporal_refine(pose_sequence)
        refined = self.output_proj(refined)
        return refined.view(-1, pose_sequence.size(1), 17, 3)


# 完整模型
class ChairPose(nn.Module):
    def __init__(self):
        super().__init__()
        self.stage1 = ChairPoseStage1()
        self.stage2 = ChairPoseStage2()
    
    def forward(self, pressure_sequence, chair_features):
        """
        Args:
            pressure_sequence: (B, T, 64, 48) 时序压力序列
            chair_features: (B, 1024) 座椅特征
        
        Returns:
            final_pose: (B, T, 17, 3) 最终姿态估计
        """
        B, T = pressure_sequence.size(0), pressure_sequence.size(1)
        
        # 第一阶段：逐帧估计
        poses_init = []
        for t in range(T):
            pose_t = self.stage1(pressure_sequence[:, t], chair_features)
            poses_init.append(pose_t)
        poses_init = torch.stack(poses_init, dim=1)  # (B, T, 17, 3)
        
        # 第二阶段：时序精细化
        poses_flat = poses_init.view(B, T, -1)
        final_pose = self.stage2(poses_flat)
        
        return final_pose


# 测试代码
if __name__ == "__main__":
    model = ChairPose()
    
    # 模拟输入
    pressure_seq = torch.randn(2, 30, 64, 48)  # 2用户，30帧，64x48压力矩阵
    chair_feat = torch.randn(2, 1024)  # 座椅点云特征
    
    # 运行
    output = model(pressure_seq, chair_feat)
    print(f"输入压力序列: {pressure_seq.shape}")
    print(f"输出姿态序列: {output.shape}")
    
    # 计算MPJE（平均关节误差）
    # 假设真实姿态
    gt_pose = torch.randn(2, 30, 17, 3)
    mpje = torch.mean(torch.norm(output - gt_pose, dim=-1))
    print(f"模拟MPJE: {mpje.item():.2f} mm")

3. 物理驱动数据增强

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
# 物理模拟增强管道
import numpy as np
from physics_sim import RagdollSimulator

class PhysicsAugmentation:
    """
    使用布娃娃物理模拟生成多样化压力-姿态配对
    """
    def __init__(self):
        self.sim = RagdollSimulator()
    
    def augment(self, base_pose, chair_model, variations=100):
        """
        Args:
            base_pose: 基础姿态序列
            chair_model: 座椅3D模型
            variations: 生成变体数量
        
        Returns:
            augmented_data: 增强后的压力-姿态配对
        """
        augmented = []
        
        for _ in range(variations):
            # 随机扰动身体参数
            body_params = {
                'mass': np.random.uniform(50, 100),  # kg
                'height': np.random.uniform(150, 190),  # cm
                'seat_depth': np.random.uniform(-5, 5),  # cm
                'lean_angle': np.random.uniform(-15, 15)  # degrees
            }
            
            # 物理模拟
            sim_pose = self.sim.simulate(base_pose, chair_model, body_params)
            
            # 计算压力分布
            pressure_map = self.compute_pressure(sim_pose, chair_model)
            
            augmented.append({
                'pose': sim_pose,
                'pressure': pressure_map,
                'chair': chair_model
            })
        
        return augmented
    
    def compute_pressure(self, pose, chair):
        """
        根据姿态和座椅计算压力分布
        
        使用接触力学模型
        """
        # 简化实现：基于接触点距离计算压力
        contact_points = self.find_contact_points(pose, chair)
        pressure_map = np.zeros((64, 48))
        
        for point in contact_points:
            # 高斯分布模拟压力扩散
            x, y, force = point
            for i in range(64):
                for j in range(48):
                    dist = np.sqrt((i - x)**2 + (j - y)**2)
                    pressure_map[i, j] += force * np.exp(-dist**2 / 100)
        
        return pressure_map


# 示例：生成训练数据
aug = PhysicsAugmentation()

# 基础姿态（来自现有数据集）
base_pose = np.random.randn(17, 3)  # 17关节点

# 座椅模型（办公椅）
chair_office = load_chair_model("office_chair.usd")

# 生成增强数据
augmented_data = aug.augment(base_pose, chair_office, variations=50)
print(f"生成增强数据量: {len(augmented_data)}")

实验结果

指标 ChairPose 3DHPE (Zhao 2024) IS (Seong 2024)
MPJE (seen user/chair) 67.2 mm 82.5 mm 95.3 mm
MPJE (unseen user) 78.3 mm 105.4 mm 112.7 mm
MPJE (unseen chair) 89.4 mm - -
实时性能 ✓ 30 fps - -
跨座椅泛化 ✓ ✗ ✗
穿戴设备需求 ✗ ✗ ✗

TDSD数据集：

  • 12种活动（工作、休息、手机、阅读等）
  • 4种座椅（办公椅、沙发、轮椅、躺椅）
  • 8名参与者
  • 30fps时序同步

IMS应用启示

1. OOP异常姿态检测

Euro NCAP 2026 OOP要求： 检测乘员异常姿态（趴在座椅上、腿搭在方向盘等）

应用方案：

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
# IMS OOP检测模块
class OOPDetector:
    """
    基于ChairPose的异常姿态检测
    
    Euro NCAP场景映射：
    - OOP-01: 乘员趴在座椅上
    - OOP-02: 腿搭在方向盘
    - OOP-03: 反向坐姿
    """
    def __init__(self, pose_estimator):
        self.pose_est = pose_estimator
        self.normal_thresholds = load_normal_pose_stats()
    
    def detect_oop(self, pressure_sequence, chair_features):
        """
        检测异常姿态
        
        Returns:
            oop_type: 异常类型编码
            confidence: 置信度
            severity: 严重等级（1-3）
        """
        pose = self.pose_est(pressure_sequence, chair_features)
        
        # 判断异常类型
        if self.is_face_down(pose):
            return 'OOP-01', 0.85, 3  # 趴姿，高风险
        elif self.is_leg_on_wheel(pose):
            return 'OOP-02', 0.72, 2  # 腿搭方向盘
        elif self.is_backward(pose):
            return 'OOP-03', 0.91, 2  # 反向坐姿
        
        return None, 0.0, 0  # 正常
    
    def is_face_down(self, pose):
        """
        判断是否趴姿
        
        特征：头部高度低于肩部，躯干倾斜角异常
        """
        head = pose[:, 0]  # 头部关节
        shoulders = pose[:, 7:9]  # 左右肩
        
        head_below = head[:, 2] < shoulders[:, :, 2].mean(dim=1)
        torso_angle = compute_torso_angle(pose)
        
        return head_below & (torso_angle < -30)


# IMS集成示例
if __name__ == "__main__":
    chairpose = ChairPose()
    oop_detector = OOPDetector(chairpose)
    
    # 模拟压力输入
    pressure = torch.randn(1, 30, 64, 48)
    chair_feat = load_chair_features("sedan_front_seat")
    
    # 检测OOP
    oop_type, conf, severity = oop_detector.detect_oop(pressure, chair_feat)
    
    if oop_type:
        print(f"检测到异常姿态: {oop_type}")
        print(f"置信度: {conf:.2f}")
        print(f"严重等级: {severity}")
        
        # Euro NCAP要求：≤3秒内发出警告
        trigger_warning(oop_type, severity)

2. 疲劳检测增强

PERCLOS局限性： 只依赖眼部，无法捕捉身体姿态疲劳信号

ChairPose增强方案：

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
# 基于姿态的疲劳检测
class PostureFatigueDetector:
    """
    融合眼部PERCLOS + 身体姿态熵
    
    检测维度：
    - PERCLOS ≥ 30%（眼部）
    - 姿态熵 > 阈值（身体晃动无规律）
    - 坐姿稳定性下降（躯干倾角变化率）
    """
    def __init__(self):
        self.pose_estimator = ChairPose()
        self.perclos_calculator = PERCLOSModule()
    
    def detect_fatigue(self, pressure_seq, eye_data, chair_feat):
        """
        多模态疲劳检测
        
        Returns:
            fatigue_level: 0-3（正常/轻度/中度/重度）
            evidence: 检测依据
        """
        # 身体姿态分析
        pose_seq = self.pose_estimator(pressure_seq, chair_feat)
        posture_entropy = self.compute_posture_entropy(pose_seq)
        stability = self.compute_stability(pose_seq)
        
        # 眼部PERCLOS
        perclos = self.perclos_calculator(eye_data)
        
        # 融合判断
        fatigue_score = 0
        
        if perclos > 30:
            fatigue_score += 2
        if posture_entropy > 0.8:
            fatigue_score += 1
        if stability < 0.6:
            fatigue_score += 1
        
        fatigue_level = min(fatigue_score, 3)
        
        evidence = {
            'PERCLOS': perclos,
            'posture_entropy': posture_entropy,
            'stability': stability
        }
        
        return fatigue_level, evidence
    
    def compute_posture_entropy(self, pose_seq):
        """
        计算姿态时序熵
        
        熵值越高，姿态越无规律（疲劳信号）
        """
        # 计算姿态变化序列
        delta_pose = pose_seq[:, 1:] - pose_seq[:, :-1]
        
        # 归一化
        delta_norm = torch.norm(delta_pose, dim=-1)
        
        # 计算近似熵
        entropy = approximate_entropy(delta_norm.numpy())
        
        return entropy


# Euro NCAP疲劳场景测试
if __name__ == "__main__":
    detector = PostureFatigueDetector()
    
    # 模拟20分钟驾驶
    pressure_20min = torch.randn(1, 3600, 64, 48)  # 20min @ 30fps
    eye_data_20min = load_eye_tracking_data("fatigue_session")
    chair_feat = load_chair_features("driver_seat")
    
    # 每60秒检测一次
    for minute in range(20):
        start_idx = minute * 180
        end_idx = (minute + 1) * 180
        
        pressure_window = pressure_20min[:, start_idx:end_idx]
        eye_window = eye_data_20min[start_idx:end_idx]
        
        level, evidence = detector.detect_fatigue(
            pressure_window, eye_window, chair_feat
        )
        
        if level >= 2:
            print(f"[Minute {minute}] 疲劳等级: {level}")
            print(f"PERCLOS: {evidence['PERCLOS']:.1f}%")
            print(f"姿态熵: {evidence['posture_entropy']:.2f}")
            print(f"稳定性: {evidence['stability']:.2f}")

3. 驾驶员状态评估

Euro NCAP 2027新增要求： 驾驶员综合状态评估（疲劳+分心+损伤+姿态）

graph TD
    A[压力床垫] --> B[ChairPose姿态估计]
    C[红外摄像头] --> D[眼部追踪]
    E[方向盘传感器] --> F[操控熵计算]
    
    B --> G[姿态熵]
    D --> H[PERCLOS]
    D --> I[视线偏离]
    F --> J[操控熵]
    
    G --> K[疲劳融合模块]
    H --> K
    J --> K
    
    K --> L[驾驶员状态评分]
    I --> M[分心评分]
    
    L --> N[综合状态判定]
    M --> N
    
    N --> O{状态等级}
    O -->|正常| P[继续驾驶]
    O -->|轻度疲劳| Q[一级警告]
    O -->|中度疲劳| R[二级警告+语音]
    O -->|重度疲劳/分心| S[建议休息/干预]

IMS开发建议

优先级排序

功能模块 优先级 实现难度 Euro NCAP关联
OOP异常姿态检测 🔴 P0 中等 2026新增要求
疲劳检测增强 🔴 P0 低 已有要求，增强精度
驾驶员状态评估 🟡 P1 高 2027综合评估
乘员分类 🟡 P1 中等 OMS基础功能
座椅舒适度监测 🟢 P2 低 非法规要求，增值功能

硬件方案

硬件组件 推荐型号 参数 成本估算
压力床垫 TPE柔性传感器阵列 64×48网格，分辨率<5mm $80-120
座椅形态扫描 3D结构光传感器 精度<2mm，单次扫描<5s $50-80
处理器 Qualcomm QCS8255 Hexagon NPU，26 TOPS $150-200

数据采集流程

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
# IMS座椅姿态数据采集脚本
import numpy as np
from pressure_sensor import TPEMat
from camera import DepthCamera

class IMSDataCollector:
    """
    IMS座椅姿态数据采集
    
    流程：
    1. 采集压力分布（TPE床垫）
    2. 同步采集姿态真值（深度相机）
    3. 记录座椅形态
    """
    def __init__(self):
        self.pressure_mat = TPEMat(resolution=(64, 48))
        self.depth_cam = DepthCamera(model="Intel RealSense D435")
        self.pose_extractor = MediaPipePose()
    
    def collect_session(self, duration_sec=120, activities=None):
        """
        采集一 session
        
        Args:
            duration_sec: 采集时长
            activities: 活动列表（['driving', 'phone', 'rest', ...])
        """
        if activities is None:
            activities = ['driving', 'phone_call', 'reading', 'eating']
        
        data = {
            'pressure': [],
            'pose_gt': [],
            'timestamps': [],
            'activity': []
        }
        
        fps = 30
        total_frames = duration_sec * fps
        
        for activity in activities:
            print(f"开始采集活动: {activity}")
            
            for frame_idx in range(total_frames // len(activities)):
                # 采集压力
                pressure_frame = self.pressure_mat.read()
                
                # 采集姿态真值
                depth_frame = self.depth_cam.capture()
                pose_gt = self.pose_extractor.extract(depth_frame)
                
                data['pressure'].append(pressure_frame)
                data['pose_gt'].append(pose_gt)
                data['timestamps'].append(frame_idx / fps)
                data['activity'].append(activity)
        
        return data
    
    def save_dataset(self, data, output_path):
        """
        保存为TDSD格式
        """
        np.savez(output_path,
                 pressure=np.array(data['pressure']),
                 pose_gt=np.array(data['pose_gt']),
                 timestamps=np.array(data['timestamps']),
                 activity=np.array(data['activity']))


# 执行采集
collector = IMSDataCollector()

# 采集12种活动，每种120秒
activities = [
    'driving', 'phone_call', 'reading', 'eating',
    'resting', 'working', 'watching', 'talking',
    'yawning', 'stretching', 'sleeping', 'emergency'
]

dataset = collector.collect_session(duration_sec=1440, activities=activities)
collector.save_dataset(dataset, "ims_tdSD_dataset.npz")

print(f"数据集大小: {len(dataset['pressure'])} 帧")
print(f"时长: {max(dataset['timestamps']):.1f} 秒")

论文复现要点

1. 数据准备

1
2
3
4
5
6
7
8
9
10
# Kaggle下载ChairPose数据集
kaggle datasets download -d lalaray/chairpose
unzip chairpose.zip -d ./data/

# 数据结构
data/
  ├── pressure_maps/      # 压力分布矩阵 (64x48)
  ├── poses/              # 姿态真值 (17关节点)
  ├── chair_scans/        # 座椅3D模型 (USD格式)
  └── metadata.json       # 活动标签、用户ID

2. 模型训练

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
# 训练ChairPose
import torch
from torch.utils.data import DataLoader

# 加载数据
train_data = ChairPoseDataset("./data/", split="train")
val_data = ChairPoseDataset("./data/", split="val")

train_loader = DataLoader(train_data, batch_size=16, shuffle=True)
val_loader = DataLoader(val_data, batch_size=16)

# 初始化模型
model = ChairPose()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

# 训练循环
for epoch in range(100):
    for batch in train_loader:
        pressure = batch['pressure']
        pose_gt = batch['pose']
        chair_feat = batch['chair_features']
        
        # 前向传播
        pose_pred = model(pressure, chair_feat)
        
        # 损失计算（MPJE + 时序一致性）
        loss_mpje = torch.mean(torch.norm(pose_pred - pose_gt, dim=-1))
        loss_temporal = temporal_consistency_loss(pose_pred)
        
        loss = loss_mpje + 0.1 * loss_temporal
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    # 验证
    val_mpje = validate(model, val_loader)
    print(f"Epoch {epoch}: Val MPJE = {val_mpje:.2f} mm")

3. IMS集成测试

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
# IMS集成测试
def test_ims_integration():
    """
    IMS座椅姿态检测集成测试
    
    Euro NCAP OOP场景：
    - OOP-01: 俯趴姿态
    - OOP-02: 腿搭方向盘
    - OOP-03: 反向坐姿
    """
    model = ChairPose()
    model.load_state_dict(torch.load("chairpose_ims.pth"))
    
    oop_detector = OOPDetector(model)
    
    # 测试OOP-01（俯趴）
    pressure_facedown = simulate_facedown_pressure()
    chair_feat = load_chair_features("driver_seat")
    
    pose = model(pressure_facedown, chair_feat)
    oop_type, conf, severity = oop_detector.detect_oop(
        pressure_facedown, chair_feat
    )
    
    assert oop_type == 'OOP-01'
    assert conf > 0.7
    assert severity == 3
    
    print("✓ OOP-01检测通过")
    
    # 测试疲劳增强
    fatigue_detector = PostureFatigueDetector()
    
    pressure_fatigue = simulate_fatigue_pressure(duration=60)
    eye_data_fatigue = simulate_fatigue_eye(perclos=35)
    
    level, evidence = fatigue_detector.detect_fatigue(
        pressure_fatigue, eye_data_fatigue, chair_feat
    )
    
    assert level >= 2
    assert evidence['PERCLOS'] > 30
    assert evidence['posture_entropy'] > 0.7
    
    print("✓ 疲劳检测增强通过")


if __name__ == "__main__":
    test_ims_integration()

参考文献

  1. Lalaray et al., “ChairPose: Pressure-based Chair Morphology Grounded Sitting Pose Estimation through Simulation-Assisted Training”, UIST 2025
  2. Zhao et al., “3DHPE: 3D Human Pose Estimation from Pressure Distribution”, 2024
  3. Seong et al., “IS: Intelligent Seat for Pose Estimation”, 2024
  4. Euro NCAP, “Assessment Protocol 2026 - Driver State Monitoring (DSM)”, v11.0
  5. Euro NCAP, “Assessment Protocol 2026 - Occupant Monitoring System (OMS)”, v11.0

总结

ChairPose提供了IMS座椅姿态检测的低成本、隐私友好、跨座椅泛化方案，核心价值在于：

  1. 硬件简单：仅需压力床垫，无需视觉传感器（隐私友好）
  2. 部署灵活：跨座椅无需重训练，适配任意座椅形状
  3. 实时性能：30fps满足Euro NCAP时延要求（≤3秒检测）
  4. IMS增强：OOP检测、疲劳增强、状态评估多维度应用

IMS开发优先级： P0（OOP异常姿态）→ P1（疲劳增强）→ P2（舒适度监测）

技术路线： 压力床垫（64×48）→ ChairPose推理 → OOP/疲劳判定 → Euro NCAP合规输出

ChairPose：基于压力分布的座椅姿态估计及其IMS应用
https://dapalm.com/2026/07/12/2026-07-12-chairpose-pressure-based-sitting-pose-estimation-ims-application/
作者
Mars
发布于
2026年7月12日
许可协议