利用OpenPose计算视频中人体骨骼的角度

Question

免责声明：这个问题是关于OpenPose的，但这里的关键实际上是要如何使用输出（坐标存储在JSON中），而不是如何使用OpenSoad，所以请考虑将其读完。p>

我有一段视频，是一个人骑在自行车的侧面（他坐着的侧面，我们看到了右侧）。我使用OpenPose提取骨架的坐标。OpenPose在JSON文件中提供的坐标如下所示（参见文档中的explanation）：

{
  "version": 1.3,
  "people": [
    {
      "person_id": [
        -1
      ],
      "pose_keypoints_2d": [
        594.071,
        214.017,
        0.917187,
        523.639,
        216.025,
        0.797579,
        519.661,
        212.063,
        0.856948,
        539.251,
        294.394,
        0.873084,
        619.546,
        304.215,
        0.897219,
        531.424,
        221.854,
        0.694434,
        550.986,
        310.036,
        0.787151,
        625.477,
        339.436,
        0.845077,
        423.656,
        319.878,
        0.660646,
        404.111,
        321.807,
        0.650697,
        484.434,
        437.41,
        0.85125,
        404.13,
        556.854,
        0.791542,
        443.261,
        319.801,
        0.601241,
        541.241,
        370.793,
        0.921286,
        502.02,
        494.141,
        0.799306,
        592.138,
        198.429,
        0.943879,
        0,
        0,
        0,
        562.742,
        182.698,
        0.914112,
        0,
        0,
        0,
        537.25,
        504.024,
        0.530087,
        535.323,
        500.073,
        0.526998,
        486.351,
        500.042,
        0.615485,
        449.168,
        594.093,
        0.700363,
        431.482,
        594.156,
        0.693443,
        386.46,
        560.803,
        0.803862
      ],
      "face_keypoints_2d": [],
      "hand_left_keypoints_2d": [],
      "hand_right_keypoints_2d": [],
      "pose_keypoints_3d": [],
      "face_keypoints_3d": [],
      "hand_left_keypoints_3d": [],
      "hand_right_keypoints_3d": []
    }
  ]
}

据我所知，每个JSON都是一个视频帧

我的目标是检测特定坐标的角度，如右膝、右臂等。例如：

openpose_angles = [(9, 10, 11, "right_knee"),
                   (2, 3, 4,   "right_arm")]

这基于以下OpenPose骨架虚拟对象：

我所做的是计算三个坐标之间的角度（使用Python）：

temp_df = json.load(open(os.path.join(jsons_dir, file)))
listPoints = list(zip(*[iter(temp_df['people'][person_number]['pose_keypoints_2d'])] * 3))

count = 0
lmList2 = {}
for x,y,c in listPoints:
    lmList2[count]=(x,y,c)
    count+=1

p1=angle_cords[0]
p2=angle_cords[1]
p3=angle_cords[2]
x1, y1 ,c1= lmList2[p1]
x2, y2, c2 = lmList2[p2]
x3, y3, c3 = lmList2[p3]

# Calculate the angle
angle = math.degrees(math.atan2(y3 - y2, x3 - x2) -
                     math.atan2(y1 - y2, x1 - x2))
if angle < 0:
    angle += 360

我在一些博客上看到过这种方法（我忘了在哪里了），但它与OpenCV相关，而不是OpenPose（不确定是否有区别），但看到的角度没有意义。我们向老师展示了它，他建议我们使用向量来计算角度，而不是使用math.atan2。但我们对如何实现这一点感到困惑

总之，这里有一个问题——计算角度的最佳方法是什么？如何使用向量计算它们

Answer 1

你的老师是对的。我怀疑问题在于，根据顺序，3个点可以组成3个不同的角度。只需考虑三角形中的角度。另外，您似乎忽略了第三个坐标

重建骨骼

在图片中，表示骨架的边/骨骼是

edges = {(0, 1), (0, 15), (0, 16), (1, 2), (1, 5), (1, 8), (2, 3), (3, 4), (5, 6), (6, 7), (8, 9), (8, 12), (9, 10), (10, 11), (11, 22), (11, 24), (12, 13), (13, 14), (14, 19), (14, 21), (15, 17), (16, 18), (19, 20), (22, 23)}

我通过使用

np.array(pose['people'][0]['pose_keypoints_2d']).reshape(-1,3)

现在，我画出忽略第三个组件的图，以了解我在使用什么。请注意，这不会对比例有太大的改变，因为第三个组件与其他组件相比确实很小。

你肯定能认出一个倒立的人。我注意到似乎存在某种伪影，但我怀疑这只是识别中的一个错误，在另一个框架中会更好

计算角度

回想一下，点积除以范数的乘积得到的是角度的余弦。见the wikipedia article on dot product。我将包括那篇文章中的相关图片现在我可以得到两条连接边的角度，像这样

def get_angle(edge1,  edge2):
    assert tuple(sorted(edge1)) in edges
    assert tuple(sorted(edge2)) in edges
    edge1 = set(edge1)
    edge2 = set(edge2)
    mid_point = edge1.intersection(edge2).pop()
    a = (edge1-edge2).pop()
    b = (edge2-edge1).pop()
    v1 = points[mid_point]-points[a]
    v2 = points[mid_point]-points[b]

    angle = (math.degrees(np.arccos(np.dot(v1,v2)
                                    /(np.linalg.norm(v1)*np.linalg.norm(v2)))))
    return angle

例如，如果你想要肘部角度，你可以这样做

get_angle((3, 4), (2, 3))
get_angle((5, 6), (6, 7))

给你

110.35748420197164
124.04586139643376

这对我来说是有意义的，当我看到我的骨架图片时。这不仅仅是一个直角

如果我必须计算不共享一个点的两个向量之间的角度会怎样

在这种情况下，你必须更加小心，因为在这种情况下，向量的方向很重要。首先，这里是代码

def get_oriented_angle(edge1,  edge2):    
    assert tuple(sorted(edge1)) in edges
    assert tuple(sorted(edge2)) in edges
    
    v1 = points[edge1[0]]-points[edge1[1]]
    v2 = points[edge2[0]]-points[edge2[1]]
    angle = (math.degrees(np.arccos(np.dot(v1,v2)   
                              /(np.linalg.norm(v1)*np.linalg.norm(v2)))))
    return angle

正如你所看到的，代码更简单，因为我没有为你点积分。但这是危险的，因为两个向量之间有两个角度（如果你不考虑它们的方向）。确保两个向量都指向考虑角度的点的方向（两个方向都相反）

这里是与上面相同的示例

get_oriented_angle((3, 4), (2, 3)) -> 69.64251579802836

如您所见，这与get_angle((3, 4), (2, 3))不符！如果你想要相同的结果，你必须在两种情况下都把3放在第一位（或最后一位）

如果你这样做

get_oriented_angle((3, 4), (3, 2)) -> 110.35748420197164

这是与上面相同的角度