基于OpenCV 的人体姿态估计

这是一个基于 OpenCV 的人体姿态估计系统，可以或许从摄像头视频流中实时检测人体关键点，并通过简化算法重建 3D 姿态，最后在 3D 空间中进行仿真展示。系统主要包含 2D 姿态检测、3D 姿态重建和 3D 仿真三个焦点模块。

模块导入与环境准备

python
运行

1. import cv2
2. import numpy as np
3. import os
4. import time
5. import matplotlib.pyplot as plt
6. from mpl_toolkits.mplot3d import Axes3D
8. # 确保目录存在
9. os.makedirs("results/2d_poses", exist_ok=True)
10. os.makedirs("results/3d_poses", exist_ok=True)
11. os.makedirs("results/simulations", exist_ok=True)

复制代码

• 导入须要的库：计算机视觉 (cv2)、数值计算 (numpy)、文件操纵 (os)、时间丈量 (time) 和画图工具 (matplotlib)
  
• 创建结果生存目次，exist_ok=True 确保目次存在时不会报错
  

常量定义

python
运行

1. JOINT_CONNECTIONS = [
2.     (0, 1), (0, 4), (1, 2), (2, 3), (4, 5), (5, 6), (6, 7),  # 头部
3.     (0, 11), (0, 12), (11, 12),  # 躯干
4.     (11, 13), (13, 15), (15, 17), (17, 19), (19, 21),  # 左臂
5.     (12, 14), (14, 16), (16, 18), (18, 20), (20, 22),  # 右臂
6.     (11, 23), (12, 24), (23, 24),  # 骨盆
7.     (23, 25), (25, 27), (27, 29), (29, 31),  # 左腿
8.     (24, 26), (26, 28), (28, 30), (30, 32)  # 右腿
9. ]

复制代码

• 定义 33 个人体关键点的毗连关系，用于后续绘制骨架
  

2D 姿态估计类

python
运行

1. class HumanPoseEstimator:
2.     def __init__(self):
3.         """初始化OpenCV人体姿态估计器"""
4.         # 使用OpenCV的DNN模块加载预训练的姿态估计模型
5.         self.proto_file = "pose_deploy_linevec_faster_4_stages.prototxt"
6.         self.weights_file = "pose_iter_160000.caffemodel"
7.         self.n_points = 18
8.         
9.         # 检查模型文件是否存在
10.         if not os.path.exists(self.proto_file) or not os.path.exists(self.weights_file):
11.             print("警告: 找不到OpenCV姿态估计模型文件")
12.             print("请从https://github.com/CMU-Perceptual-Computing-Lab/openpose下载模型文件")
13.             self.net = None
14.         else:
15.             self.net = cv2.dnn.readNetFromCaffe(self.proto_file, self.weights_file)
16.             
17.         # 定义COCO人体关键点映射到33点格式
18.         self.coco_to_mp = {
19.             0: 0,    # 鼻子
20.             1: 1,    # 脖子
21.             2: 12,   # 右肩
22.             3: 14,   # 右肘
23.             4: 16,   # 右腕
24.             5: 11,   # 左肩
25.             6: 13,   # 左肘
26.             7: 15,   # 左腕
27.             8: 24,   # 右髋
28.             9: 26,   # 右膝
29.             10: 28,  # 右踝
30.             11: 23,  # 左髋
31.             12: 25,  # 左膝
32.             13: 27,  # 左踝
33.             14: 5,   # 右眼
34.             15: 2,   # 左眼
35.             16: 7,   # 右耳
36.             17: 4    # 左耳
37.         }

复制代码

• 类初始化：加载 OpenCV 预训练的 Caffe 模型
  
• 关键点映射表：将 COCO 数据集的 18 个关键点映射到 MediaPipe 的 33 点格式
  

python
运行

1.     def detect_keypoints(self, image):
2.         """
3.         从图像中检测人体关键点
4.         
5.         返回:
6.             keypoints_2d: 二维关键点坐标 [33, 3] (x, y, confidence)
7.             annotated_image: 标注后的图像
8.         """
9.         if self.net is None:
10.             print("错误: 姿态估计模型未正确加载")
11.             return None, image
12.             
13.         # 准备输入
14.         blob = cv2.dnn.blobFromImage(
15.             image, 1.0 / 255, (368, 368), (0, 0, 0), swapRB=False, crop=False
16.         )
17.         self.net.setInput(blob)
18.         
19.         # 前向传播
20.         output = self.net.forward()
21.         
22.         # 获取图像尺寸
23.         h, w = image.shape[:2]
24.         
25.         # 初始化33个关键点的数组
26.         keypoints_2d = np.zeros((33, 3))
27.         
28.         # 处理检测结果
29.         points = []
30.         for i in range(self.n_points):
31.             # 查找关键点的置信度图
32.             prob_map = output[0, i, :, :]
33.             min_val, prob, min_loc, point = cv2.minMaxLoc(prob_map)
34.             
35.             # 缩放坐标
36.             x = (w * point[0]) / output.shape[3]
37.             y = (h * point[1]) / output.shape[2]
38.             
39.             if prob > 0.1:  # 置信度阈值
40.                 points.append((int(x), int(y)))
41.                
42.                 # 映射到33点格式
43.                 if i in self.coco_to_mp:
44.                     mp_idx = self.coco_to_mp[i]
45.                     keypoints_2d[mp_idx] = [x / w, y / h, prob]
46.             else:
47.                 points.append(None)
48.         
49.         # 可视化关键点
50.         annotated_image = image.copy()
51.         for i, p in enumerate(points):
52.             if p is not None:
53.                 cv2.circle(annotated_image, p, 8, (0, 255, 255), thickness=-1, lineType=cv2.FILLED)
54.                 cv2.putText(annotated_image, f"{i}", p, cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, lineType=cv2.LINE_AA)
55.         
56.         # 绘制骨架连接
57.         skeleton_pairs = [
58.             (1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7),
59.             (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13),
60.             (1, 0), (0, 14), (14, 16), (0, 15), (15, 17)
61.         ]
62.         
63.         for pair in skeleton_pairs:
64.             part_a, part_b = pair
65.             if points[part_a] and points[part_b]:
66.                 cv2.line(annotated_image, points[part_a], points[part_b], (0, 255, 0), 2)
67.         
68.         return keypoints_2d, annotated_image

复制代码

• 图像预处置处罚：将输入图像转换为网络可担当的格式 (368x368)
  
• 模型推理：通过前向传播获取关键点的置信度图
  
• 后处置处罚：从置信度图中提取关键点坐标，应用阈值过滤低置信度点
  
• 可视化：在原图上绘制关键点和骨架毗连，返回标准化的关键点坐标和可视化后的图像
  

3D 姿态估计类

python
运行

1. class Simple3DPoseEstimator:
2.     def __init__(self):
3.         """简单的3D姿态估计器，使用固定比例关系"""
4.         # 定义人体各部分的平均比例（单位：米）
5.         self.body_proportions = {
6.             "head": 0.25,
7.             "torso": 0.5,
8.             "upper_arm": 0.3,
9.             "forearm": 0.25,
10.             "hand": 0.1,
11.             "upper_leg": 0.5,
12.             "lower_leg": 0.5,
13.             "foot": 0.2
14.         }
15.         
16.         # 用于可视化
17.         self.fig = plt.figure(figsize=(10, 8))
18.         self.ax = self.fig.add_subplot(111, projection='3d')

复制代码

• 初始化：定义人体各部门的标准比例（单位：米）
  
• 创建 3D 画图环境用于可视化 3D 姿态
  

python
运行

1.     def estimate_3d_pose(self, keypoints_2d, image_shape, visualize=False):
2.         """
3.         简单估计3D姿态
4.         
5.         参数:
6.             keypoints_2d: 二维关键点 [33, 3]
7.             image_shape: 图像形状 (h, w)
8.             visualize: 是否可视化3D姿态
9.             
10.         返回:
11.             keypoints_3d: 3D关键点 numpy数组 [33, 3]
12.         """
13.         if keypoints_2d is None:
14.             return None
15.             
16.         h, w = image_shape[:2]
17.         
18.         # 创建3D关键点数组
19.         keypoints_3d = np.zeros((33, 3))
20.         
21.         # 提取有效关键点
22.         valid_mask = keypoints_2d[:, 2] > 0.3
23.         if not np.any(valid_mask):
24.             return None
25.             
26.         # 将2D坐标转换为图像坐标系
27.         kp_2d_img = keypoints_2d.copy()
28.         kp_2d_img[:, 0] *= w
29.         kp_2d_img[:, 1] *= h
30.         
31.         # 计算人体中心
32.         center = np.mean(kp_2d_img[valid_mask, :2], axis=0)
33.         
34.         # 估计人体尺寸
35.         # 这里简化为使用肩宽作为参考
36.         if valid_mask[11] and valid_mask[12]:  # 左右肩
37.             shoulder_width = np.linalg.norm(kp_2d_img[11, :2] - kp_2d_img[12, :2])
38.             scale = 0.4 / shoulder_width  # 假设平均肩宽为0.4米
39.         else:
40.             scale = 0.001  # 默认缩放比例
41.             
42.         # 基于2D关键点和人体比例估计3D位置
43.         # 这里使用简化模型，主要基于深度感知和人体比例
44.         for i in range(33):
45.             if valid_mask[i]:
46.                 x, y = kp_2d_img[i, :2]
47.                
48.                 # 计算相对中心的位置
49.                 rel_x = (x - center[0]) * scale
50.                 rel_y = (y - center[1]) * scale
51.                
52.                 # 估计深度（z轴）
53.                 # 这里使用简化方法：离图像中心越远的点假设越远
54.                 depth_factor = np.sqrt(rel_x**2 + rel_y**2) / max(w, h) * 0.5
55.                
56.                 # 设置3D坐标
57.                 keypoints_3d[i] = [rel_x, rel_y, depth_factor]
58.         
59.         # 可视化
60.         if visualize:
61.             self.visualize_3d_pose(keypoints_3d)
62.             
63.         return keypoints_3d

复制代码

• 3D 姿态估计：基于 2D 关键点和人体比例关系计算 3D 坐标
  
• 坐标缩放：利用肩宽作为参考来估计人体尺寸比例
  
• 深度估计：利用离图像中心的间隔来大略估计深度信息（z 轴）
  

python
运行

1.     def visualize_3d_pose(self, keypoints_3d, frame_id=None):
2.         """可视化3D姿态"""
3.         self.ax.clear()
4.         
5.         # 设置坐标轴范围
6.         max_range = np.max(np.abs(keypoints_3d))
7.         self.ax.set_xlim(-max_range, max_range)
8.         self.ax.set_ylim(-max_range, max_range)
9.         self.ax.set_zlim(-max_range, max_range)
10.         
11.         # 设置坐标轴标签
12.         self.ax.set_xlabel('X')
13.         self.ax.set_ylabel('Y')
14.         self.ax.set_zlabel('Z')
15.         
16.         # 绘制关键点
17.         self.ax.scatter(keypoints_3d[:, 0], keypoints_3d[:, 1], keypoints_3d[:, 2], c='r', s=50)
18.         
19.         # 绘制连接关系
20.         for connection in JOINT_CONNECTIONS:
21.             start_idx, end_idx = connection
22.             if start_idx < len(keypoints_3d) and end_idx < len(keypoints_3d):
23.                 self.ax.plot(
24.                     [keypoints_3d[start_idx, 0], keypoints_3d[end_idx, 0]],
25.                     [keypoints_3d[start_idx, 1], keypoints_3d[end_idx, 1]],
26.                     [keypoints_3d[start_idx, 2], keypoints_3d[end_idx, 2]],
27.                     c='b', linewidth=2
28.                 )
29.         
30.         # 设置视角
31.         self.ax.view_init(elev=-90, azim=90)  # 俯视视角
32.         
33.         # 保存图像
34.         if frame_id is not None:
35.             plt.savefig(f"results/3d_poses/3d_pose_frame_{frame_id}.png", dpi=300, bbox_inches='tight')
36.         else:
37.             plt.pause(0.01)

复制代码

• 3D 姿态可视化：在 3D 空间中绘制关键点和骨架毗连
  
• 视角设置：默认利用俯视视角 (-90 度仰角，90 度方位角)
  
• 图像生存：根据需要生存 3D 姿态图像
  

3D 仿真器类

python
运行

1. class SimpleSimulator:
2.     def __init__(self, use_gui=True):
3.         """简单的3D仿真器，使用matplotlib进行可视化"""
4.         self.use_gui = use_gui
5.         
6.         # 用于可视化
7.         self.fig = plt.figure(figsize=(10, 8))
8.         self.ax = self.fig.add_subplot(111, projection='3d')
9.         
10.         # 设置固定的相机位置
11.         self.ax.set_xlim(-1.5, 1.5)
12.         self.ax.set_ylim(-1.5, 1.5)
13.         self.ax.set_zlim(0, 2)
14.         
15.         self.ax.set_xlabel('X')
16.         self.ax.set_ylabel('Y')
17.         self.ax.set_zlabel('Z')
18.         
19.         # 绘制地面
20.         x = np.linspace(-1.5, 1.5, 100)
21.         y = np.linspace(-1.5, 1.5, 100)
22.         X, Y = np.meshgrid(x, y)
23.         Z = np.zeros_like(X)
24.         self.ax.plot_surface(X, Y, Z, alpha=0.3, color='g')
25.         
26.         print("使用简单的3D可视化模拟器")

复制代码

• 初始化：创建 3D 画图环境和固定巨细的场景
  
• 绘制地面平面：利用绿色半透明平面表现地面
  

python
运行

1.     def update_pose(self, keypoints_3d):
2.         """
3.         根据3D姿态更新仿真模型
4.         
5.         参数:
6.             keypoints_3d: 3D关键点 [33, 3]
7.         """
8.         if keypoints_3d is None:
9.             return
10.             
11.         self.ax.clear()
12.         
13.         # 设置坐标轴范围
14.         self.ax.set_xlim(-1.5, 1.5)
15.         self.ax.set_ylim(-1.5, 1.5)
16.         self.ax.set_zlim(0, 2)
17.         
18.         # 设置坐标轴标签
19.         self.ax.set_xlabel('X')
20.         self.ax.set_ylabel('Y')
21.         self.ax.set_zlabel('Z')
22.         
23.         # 绘制地面
24.         x = np.linspace(-1.5, 1.5, 100)
25.         y = np.linspace(-1.5, 1.5, 100)
26.         X, Y = np.meshgrid(x, y)
27.         Z = np.zeros_like(X)
28.         self.ax.plot_surface(X, Y, Z, alpha=0.3, color='g')
29.         
30.         # 绘制关键点
31.         self.ax.scatter(keypoints_3d[:, 0], keypoints_3d[:, 1], keypoints_3d[:, 2], c='r', s=50)
32.         
33.         # 绘制连接关系
34.         for connection in JOINT_CONNECTIONS:
35.             start_idx, end_idx = connection
36.             if start_idx < len(keypoints_3d) and end_idx < len(keypoints_3d):
37.                 self.ax.plot(
38.                     [keypoints_3d[start_idx, 0], keypoints_3d[end_idx, 0]],
39.                     [keypoints_3d[start_idx, 1], keypoints_3d[end_idx, 1]],
40.                     [keypoints_3d[start_idx, 2], keypoints_3d[end_idx, 2]],
41.                     c='b', linewidth=2
42.                 )
43.         
44.         # 设置视角
45.         self.ax.view_init(elev=30, azim=45)  # 侧视视角
46.         
47.         if self.use_gui:
48.             plt.pause(0.01)
49.    
50.     def render_scene(self, frame_id):
51.         """
52.         渲染当前场景并保存
53.         
54.         参数:
55.             frame_id: 帧ID
56.         """
57.         plt.savefig(f"results/simulations/simulation_frame_{frame_id}.png", dpi=300, bbox_inches='tight')

复制代码

• 更新姿态：根据新的 3D 关键点数据更新场景
  
• 固定视角：利用侧视视角 (30 度仰角，45 度方位角)
  
• 场景渲染：将当前场景生存为图像
  

主函数

python
运行

1. def main(camera_id=0, use_gui=True):
2.     """
3.     完整流程：从摄像头读取到3D仿真
4.    
5.     参数:
6.         camera_id: 摄像头ID，0表示默认摄像头
7.         use_gui: 是否使用GUI模式
8.     """
9.     # 1. 初始化模块
10.     pose_estimator = HumanPoseEstimator()
11.     pose_3d_estimator = Simple3DPoseEstimator()
12.     simulator = SimpleSimulator(use_gui=use_gui)
13.    
14.     # 2. 打开摄像头
15.     cap = cv2.VideoCapture(camera_id)
16.    
17.     # 检查摄像头是否成功打开
18.     if not cap.isOpened():
19.         print(f"无法打开摄像头 {camera_id}")
20.         return
21.    
22.     # 获取摄像头信息
23.     fps = cap.get(cv2.CAP_PROP_FPS)
24.     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
25.     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
26.     print(f"摄像头参数: {width}x{height}, 帧率: {fps}")
27.    
28.     # 创建窗口
29.     cv2.namedWindow("2D Pose Estimation", cv2.WINDOW_NORMAL)
30.     cv2.resizeWindow("2D Pose Estimation", 800, 600)
31.    
32.     frame_id = 0
33.    
34.     # 3. 处理摄像头帧
35.     while True:
36.         ret, frame = cap.read()
37.         if not ret:
38.             print("无法获取帧，退出...")
39.             break
40.             
41.         # 翻转帧，使其成为镜像效果
42.         frame = cv2.flip(frame, 1)
43.         
44.         print(f"处理第{frame_id}帧...")
45.         
46.         # 3.1 2D姿态识别
47.         start_time = time.time()
48.         keypoints_2d, vis_frame = pose_estimator.detect_keypoints(frame)
49.         
50.         # 显示2D姿态结果
51.         cv2.imshow("2D Pose Estimation", vis_frame)
52.         
53.         # 保存2D姿态结果
54.         cv2.imwrite(f"results/2d_poses/2d_pose_frame_{frame_id}.png", vis_frame)
55.         
56.         # 3.2 3D姿态重建
57.         keypoints_3d = pose_3d_estimator.estimate_3d_pose(
58.             keypoints_2d, frame.shape, visualize=False
59.         )
60.         
61.         # 可视化3D姿态
62.         if keypoints_3d is not None:
63.             pose_3d_estimator.visualize_3d_pose(keypoints_3d, frame_id)
64.         
65.         # 3.3 更新3D仿真
66.         simulator.update_pose(keypoints_3d)
67.         
68.         # 3.4 渲染场景
69.         simulator.render_scene(frame_id)
70.         
71.         # 计算处理时间
72.         process_time = time.time() - start_time
73.         print(f"处理时间: {process_time:.3f}秒")
74.         
75.         frame_id += 1
76.         
77.         # 按ESC键退出
78.         key = cv2.waitKey(1)
79.         if key == 27:  # ESC键
80.             break
81.    
82.     # 4. 释放资源
83.     cap.release()
84.     cv2.destroyAllWindows()
85.     print(f"处理完成，共{frame_id}帧，结果保存在results目录")

复制代码

• 初始化所有模块：2D 姿态估计器、3D 姿态估计器和 3D 仿真器
  
• 打开摄像头并获取视频流参数
  
• 主循环处置处罚每一帧：
  
  
  • 读取摄像头帧并翻转
    
  • 进行 2D 姿态检测
    
  • 基于 2D 结果进行 3D 姿态重建
    
  • 更新 3D 仿真场景
    
  • 生存所有处置处罚结果
    
  • 计算处置处罚时间
    
  
  
• 资源释放：关闭摄像头和窗口
  

程序入口

python
运行

1. if __name__ == "__main__":
2.     # 运行主程序
3.     main(
4.         camera_id=0,  # 摄像头ID，0表示默认摄像头
5.         use_gui=True  # 是否使用GUI模式
6.     )

复制代码

• 程序入口点，调用 main 函数启动整个系统
  
• 可以通过修改参数来调解系统举动
  

总结

这段代码实现了一个完整的人体姿态估计和 3D 仿真系统，主要特点包括：

• 利用 OpenCV 预训练模型进行 2D 姿态检测
  
• 基于人体比例关系的简化 3D 姿态重建方法
  
• 利用 matplotlib 进行 3D 姿态可视化和仿真
  
• 实时处置处罚摄像头视频流
  
• 生存所有处置处罚结果到指定目次
  

该系统可以用于姿势分析、运动跟踪、人机交互等多种应用场景，并且提供了精良的扩展性，可以根据需求进一步优化 3D 姿态估计算法或添加更多功能。

完整代码

1. import cv2
2. import numpy as np
3. import os
4. import time
5. import matplotlib.pyplot as plt
6. from mpl_toolkits.mplot3d import Axes3D
8. # 确保目录存在
9. os.makedirs("results/2d_poses", exist_ok=True)
10. os.makedirs("results/3d_poses", exist_ok=True)
11. os.makedirs("results/simulations", exist_ok=True)
12. # 定义常量JOINT_CONNECTIONS = [
13.     (0, 1), (0, 4), (1, 2), (2, 3), (4, 5), (5, 6), (6, 7),  # 头部
14.     (0, 11), (0, 12), (11, 12),  # 躯干
15.     (11, 13), (13, 15), (15, 17), (17, 19), (19, 21),  # 左臂
16.     (12, 14), (14, 16), (16, 18), (18, 20), (20, 22),  # 右臂
17.     (11, 23), (12, 24), (23, 24),  # 骨盆
18.     (23, 25), (25, 27), (27, 29), (29, 31),  # 左腿
19.     (24, 26), (26, 28), (28, 30), (30, 32)  # 右腿
20. ]
21. class HumanPoseEstimator:
22.     def __init__(self):
23.         """初始化OpenCV人体姿态估计器"""
24.         # 使用OpenCV的DNN模块加载预训练的姿态估计模型
25.         self.proto_file = "pose_deploy_linevec_faster_4_stages.prototxt"
26.         self.weights_file = "pose_iter_160000.caffemodel"
27.         self.n_points = 18
28.         
29.         # 检查模型文件是否存在
30.         if not os.path.exists(self.proto_file) or not os.path.exists(self.weights_file):
31.             print("警告: 找不到OpenCV姿态估计模型文件")
32.             print("请从https://github.com/CMU-Perceptual-Computing-Lab/openpose下载模型文件")
33.             self.net = None
34.         else:
35.             self.net = cv2.dnn.readNetFromCaffe(self.proto_file, self.weights_file)
36.             
37.         # 定义COCO人体关键点映射到33点格式
38.         self.coco_to_mp = {
39.             0: 0,    # 鼻子
40.             1: 1,    # 脖子
41.             2: 12,   # 右肩
42.             3: 14,   # 右肘
43.             4: 16,   # 右腕
44.             5: 11,   # 左肩
45.             6: 13,   # 左肘
46.             7: 15,   # 左腕
47.             8: 24,   # 右髋
48.             9: 26,   # 右膝
49.             10: 28,  # 右踝
50.             11: 23,  # 左髋
51.             12: 25,  # 左膝
52.             13: 27,  # 左踝
53.             14: 5,   # 右眼
54.             15: 2,   # 左眼
55.             16: 7,   # 右耳
56.             17: 4    # 左耳
57.         }
58.             def detect_keypoints(self, image):
59.         """
60.         从图像中检测人体关键点
61.         
62.         返回:
63.             keypoints_2d: 二维关键点坐标 [33, 3] (x, y, confidence)
64.             annotated_image: 标注后的图像
65.         """
66.         if self.net is None:
67.             print("错误: 姿态估计模型未正确加载")
68.             return None, image
69.             
70.         # 准备输入
71.         blob = cv2.dnn.blobFromImage(
72.             image, 1.0 / 255, (368, 368), (0, 0, 0), swapRB=False, crop=False
73.         )
74.         self.net.setInput(blob)
75.         
76.         # 前向传播
77.         output = self.net.forward()
78.         
79.         # 获取图像尺寸
80.         h, w = image.shape[:2]
81.         
82.         # 初始化33个关键点的数组
83.         keypoints_2d = np.zeros((33, 3))
84.         
85.         # 处理检测结果
86.         points = []
87.         for i in range(self.n_points):
88.             # 查找关键点的置信度图
89.             prob_map = output[0, i, :, :]
90.             min_val, prob, min_loc, point = cv2.minMaxLoc(prob_map)
91.             
92.             # 缩放坐标
93.             x = (w * point[0]) / output.shape[3]
94.             y = (h * point[1]) / output.shape[2]
95.             
96.             if prob > 0.1:  # 置信度阈值
97.                 points.append((int(x), int(y)))
98.                
99.                 # 映射到33点格式
100.                 if i in self.coco_to_mp:
101.                     mp_idx = self.coco_to_mp[i]
102.                     keypoints_2d[mp_idx] = [x / w, y / h, prob]
103.             else:
104.                 points.append(None)
105.         
106.         # 可视化关键点
107.         annotated_image = image.copy()
108.         for i, p in enumerate(points):
109.             if p is not None:
110.                 cv2.circle(annotated_image, p, 8, (0, 255, 255), thickness=-1, lineType=cv2.FILLED)
111.                 cv2.putText(annotated_image, f"{i}", p, cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, lineType=cv2.LINE_AA)
112.         
113.         # 绘制骨架连接
114.         skeleton_pairs = [
115.             (1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7),
116.             (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13),
117.             (1, 0), (0, 14), (14, 16), (0, 15), (15, 17)
118.         ]
119.         
120.         for pair in skeleton_pairs:
121.             part_a, part_b = pair
122.             if points[part_a] and points[part_b]:
123.                 cv2.line(annotated_image, points[part_a], points[part_b], (0, 255, 0), 2)
124.         
125.         return keypoints_2d, annotated_image
126. class Simple3DPoseEstimator:
127.     def __init__(self):
128.         """简单的3D姿态估计器，使用固定比例关系"""
129.         # 定义人体各部分的平均比例（单位：米）
130.         self.body_proportions = {
131.             "head": 0.25,
132.             "torso": 0.5,
133.             "upper_arm": 0.3,
134.             "forearm": 0.25,
135.             "hand": 0.1,
136.             "upper_leg": 0.5,
137.             "lower_leg": 0.5,
138.             "foot": 0.2
139.         }
140.         
141.         # 用于可视化
142.         self.fig = plt.figure(figsize=(10, 8))
143.         self.ax = self.fig.add_subplot(111, projection='3d')
144.         def estimate_3d_pose(self, keypoints_2d, image_shape, visualize=False):
145.         """
146.         简单估计3D姿态
147.         
148.         参数:
149.             keypoints_2d: 二维关键点 [33, 3]
150.             image_shape: 图像形状 (h, w)
151.             visualize: 是否可视化3D姿态
152.             
153.         返回:
154.             keypoints_3d: 3D关键点 numpy数组 [33, 3]
155.         """
156.         if keypoints_2d is None:
157.             return None
158.             
159.         h, w = image_shape[:2]
160.         
161.         # 创建3D关键点数组
162.         keypoints_3d = np.zeros((33, 3))
163.         
164.         # 提取有效关键点
165.         valid_mask = keypoints_2d[:, 2] > 0.3
166.         if not np.any(valid_mask):
167.             return None
168.             
169.         # 将2D坐标转换为图像坐标系
170.         kp_2d_img = keypoints_2d.copy()
171.         kp_2d_img[:, 0] *= w
172.         kp_2d_img[:, 1] *= h
173.         
174.         # 计算人体中心
175.         center = np.mean(kp_2d_img[valid_mask, :2], axis=0)
176.         
177.         # 估计人体尺寸
178.         # 这里简化为使用肩宽作为参考
179.         if valid_mask[11] and valid_mask[12]:  # 左右肩
180.             shoulder_width = np.linalg.norm(kp_2d_img[11, :2] - kp_2d_img[12, :2])
181.             scale = 0.4 / shoulder_width  # 假设平均肩宽为0.4米
182.         else:
183.             scale = 0.001  # 默认缩放比例
184.             
185.         # 基于2D关键点和人体比例估计3D位置
186.         # 这里使用简化模型，主要基于深度感知和人体比例
187.         for i in range(33):
188.             if valid_mask[i]:
189.                 x, y = kp_2d_img[i, :2]
190.                
191.                 # 计算相对中心的位置
192.                 rel_x = (x - center[0]) * scale
193.                 rel_y = (y - center[1]) * scale
194.                
195.                 # 估计深度（z轴）
196.                 # 这里使用简化方法：离图像中心越远的点假设越远
197.                 depth_factor = np.sqrt(rel_x**2 + rel_y**2) / max(w, h) * 0.5
198.                
199.                 # 设置3D坐标
200.                 keypoints_3d[i] = [rel_x, rel_y, depth_factor]
201.         
202.         # 可视化
203.         if visualize:
204.             self.visualize_3d_pose(keypoints_3d)
205.             
206.         return keypoints_3d
207.         def visualize_3d_pose(self, keypoints_3d, frame_id=None):
208.         """可视化3D姿态"""
209.         self.ax.clear()
210.         
211.         # 设置坐标轴范围
212.         max_range = np.max(np.abs(keypoints_3d))
213.         self.ax.set_xlim(-max_range, max_range)
214.         self.ax.set_ylim(-max_range, max_range)
215.         self.ax.set_zlim(-max_range, max_range)
216.         
217.         # 设置坐标轴标签
218.         self.ax.set_xlabel('X')
219.         self.ax.set_ylabel('Y')
220.         self.ax.set_zlabel('Z')
221.         
222.         # 绘制关键点
223.         self.ax.scatter(keypoints_3d[:, 0], keypoints_3d[:, 1], keypoints_3d[:, 2], c='r', s=50)
224.         
225.         # 绘制连接关系
226.         for connection in JOINT_CONNECTIONS:
227.             start_idx, end_idx = connection
228.             if start_idx < len(keypoints_3d) and end_idx < len(keypoints_3d):
229.                 self.ax.plot(
230.                     [keypoints_3d[start_idx, 0], keypoints_3d[end_idx, 0]],
231.                     [keypoints_3d[start_idx, 1], keypoints_3d[end_idx, 1]],
232.                     [keypoints_3d[start_idx, 2], keypoints_3d[end_idx, 2]],
233.                     c='b', linewidth=2
234.                 )
235.         
236.         # 设置视角
237.         self.ax.view_init(elev=-90, azim=90)  # 俯视视角
238.         
239.         # 保存图像
240.         if frame_id is not None:
241.             plt.savefig(f"results/3d_poses/3d_pose_frame_{frame_id}.png", dpi=300, bbox_inches='tight')
242.         else:
243.             plt.pause(0.01)
244. class SimpleSimulator:
245.     def __init__(self, use_gui=True):
246.         """简单的3D仿真器，使用matplotlib进行可视化"""
247.         self.use_gui = use_gui
248.         
249.         # 用于可视化
250.         self.fig = plt.figure(figsize=(10, 8))
251.         self.ax = self.fig.add_subplot(111, projection='3d')
252.         
253.         # 设置固定的相机位置
254.         self.ax.set_xlim(-1.5, 1.5)
255.         self.ax.set_ylim(-1.5, 1.5)
256.         self.ax.set_zlim(0, 2)
257.         
258.         self.ax.set_xlabel('X')
259.         self.ax.set_ylabel('Y')
260.         self.ax.set_zlabel('Z')
261.         
262.         # 绘制地面
263.         x = np.linspace(-1.5, 1.5, 100)
264.         y = np.linspace(-1.5, 1.5, 100)
265.         X, Y = np.meshgrid(x, y)
266.         Z = np.zeros_like(X)
267.         self.ax.plot_surface(X, Y, Z, alpha=0.3, color='g')
268.         
269.         print("使用简单的3D可视化模拟器")
270.             def update_pose(self, keypoints_3d):
271.         """
272.         根据3D姿态更新仿真模型
273.         
274.         参数:
275.             keypoints_3d: 3D关键点 [33, 3]
276.         """
277.         if keypoints_3d is None:
278.             return
279.             
280.         self.ax.clear()
281.         
282.         # 设置坐标轴范围
283.         self.ax.set_xlim(-1.5, 1.5)
284.         self.ax.set_ylim(-1.5, 1.5)
285.         self.ax.set_zlim(0, 2)
286.         
287.         # 设置坐标轴标签
288.         self.ax.set_xlabel('X')
289.         self.ax.set_ylabel('Y')
290.         self.ax.set_zlabel('Z')
291.         
292.         # 绘制地面
293.         x = np.linspace(-1.5, 1.5, 100)
294.         y = np.linspace(-1.5, 1.5, 100)
295.         X, Y = np.meshgrid(x, y)
296.         Z = np.zeros_like(X)
297.         self.ax.plot_surface(X, Y, Z, alpha=0.3, color='g')
298.         
299.         # 绘制关键点
300.         self.ax.scatter(keypoints_3d[:, 0], keypoints_3d[:, 1], keypoints_3d[:, 2], c='r', s=50)
301.         
302.         # 绘制连接关系
303.         for connection in JOINT_CONNECTIONS:
304.             start_idx, end_idx = connection
305.             if start_idx < len(keypoints_3d) and end_idx < len(keypoints_3d):
306.                 self.ax.plot(
307.                     [keypoints_3d[start_idx, 0], keypoints_3d[end_idx, 0]],
308.                     [keypoints_3d[start_idx, 1], keypoints_3d[end_idx, 1]],
309.                     [keypoints_3d[start_idx, 2], keypoints_3d[end_idx, 2]],
310.                     c='b', linewidth=2
311.                 )
312.         
313.         # 设置视角
314.         self.ax.view_init(elev=30, azim=45)  # 侧视视角
315.         
316.         if self.use_gui:
317.             plt.pause(0.01)
318.    
319.     def render_scene(self, frame_id):
320.         """
321.         渲染当前场景并保存
322.         
323.         参数:
324.             frame_id: 帧ID
325.         """
326.         plt.savefig(f"results/simulations/simulation_frame_{frame_id}.png", dpi=300, bbox_inches='tight')
327. def main(camera_id=0, use_gui=True):
328.     """
329.     完整流程：从摄像头读取到3D仿真
330.    
331.     参数:
332.         camera_id: 摄像头ID，0表示默认摄像头
333.         use_gui: 是否使用GUI模式
334.     """
335.     # 1. 初始化模块
336.     pose_estimator = HumanPoseEstimator()
337.     pose_3d_estimator = Simple3DPoseEstimator()
338.     simulator = SimpleSimulator(use_gui=use_gui)
339.    
340.     # 2. 打开摄像头
341.     cap = cv2.VideoCapture(camera_id)
342.    
343.     # 检查摄像头是否成功打开
344.     if not cap.isOpened():
345.         print(f"无法打开摄像头 {camera_id}")
346.         return
347.    
348.     # 获取摄像头信息
349.     fps = cap.get(cv2.CAP_PROP_FPS)
350.     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
351.     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
352.     print(f"摄像头参数: {width}x{height}, 帧率: {fps}")
353.    
354.     # 创建窗口
355.     cv2.namedWindow("2D Pose Estimation", cv2.WINDOW_NORMAL)
356.     cv2.resizeWindow("2D Pose Estimation", 800, 600)
357.    
358.     frame_id = 0
359.    
360.     # 3. 处理摄像头帧
361.     while True:
362.         ret, frame = cap.read()
363.         if not ret:
364.             print("无法获取帧，退出...")
365.             break
366.             
367.         # 翻转帧，使其成为镜像效果
368.         frame = cv2.flip(frame, 1)
369.         
370.         print(f"处理第{frame_id}帧...")
371.         
372.         # 3.1 2D姿态识别
373.         start_time = time.time()
374.         keypoints_2d, vis_frame = pose_estimator.detect_keypoints(frame)
375.         
376.         # 显示2D姿态结果
377.         cv2.imshow("2D Pose Estimation", vis_frame)
378.         
379.         # 保存2D姿态结果
380.         cv2.imwrite(f"results/2d_poses/2d_pose_frame_{frame_id}.png", vis_frame)
381.         
382.         # 3.2 3D姿态重建
383.         keypoints_3d = pose_3d_estimator.estimate_3d_pose(
384.             keypoints_2d, frame.shape, visualize=False
385.         )
386.         
387.         # 可视化3D姿态
388.         if keypoints_3d is not None:
389.             pose_3d_estimator.visualize_3d_pose(keypoints_3d, frame_id)
390.         
391.         # 3.3 更新3D仿真
392.         simulator.update_pose(keypoints_3d)
393.         
394.         # 3.4 渲染场景
395.         simulator.render_scene(frame_id)
396.         
397.         # 计算处理时间
398.         process_time = time.time() - start_time
399.         print(f"处理时间: {process_time:.3f}秒")
400.         
401.         frame_id += 1
402.         
403.         # 按ESC键退出
404.         key = cv2.waitKey(1)
405.         if key == 27:  # ESC键
406.             break
407.    
408.     # 4. 释放资源
409.     cap.release()
410.     cv2.destroyAllWindows()
411.     print(f"处理完成，共{frame_id}帧，结果保存在results目录")
412. if __name__ == "__main__":
413.     # 运行主程序
414.     main(
415.         camera_id=0,  # 摄像头ID，0表示默认摄像头
416.         use_gui=True  # 是否使用GUI模式
417.     )

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。