File size: 7,025 Bytes
dbf8921 | 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 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 | # Copyright (c) Meta Platforms, Inc. and affiliates.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
from dataclasses import dataclass
from typing import Any, Dict, List, Optional
import numpy as np
import torch
from data_loaders.HandDataProviderBase import HandDataProviderBase
from data_loaders.loader_hand_poses import Handedness, HandPose
from data_loaders.umetrack_layer import get_skinning_weights, skin_points
@dataclass
class UmeTrackHandModelData:
joint_rotation_axes: torch.Tensor
joint_rest_positions: torch.Tensor
joint_frame_index: torch.Tensor
joint_parent: torch.Tensor
joint_first_child: torch.Tensor
joint_next_sibling: torch.Tensor
landmark_rest_positions: torch.Tensor
landmark_rest_bone_weights: torch.Tensor
landmark_rest_bone_indices: torch.Tensor
hand_scale: Optional[torch.Tensor] = None
mesh_vertices: Optional[torch.Tensor] = None
mesh_triangles: Optional[torch.Tensor] = None
dense_bone_weights: Optional[torch.Tensor] = None
joint_limits: Optional[torch.Tensor] = None
def from_dict(j: Dict[str, Any]) -> UmeTrackHandModelData:
model = UmeTrackHandModelData(**{k: torch.tensor(v) for k, v in j.items()})
MM_TO_M = 1e-3
model.joint_rest_positions *= MM_TO_M
model.landmark_rest_positions *= MM_TO_M
if model.mesh_vertices is not None:
model.mesh_vertices *= MM_TO_M
return model
def load_hand_model_from_file(filename: str) -> Optional[UmeTrackHandModelData]:
with open(filename, "rb") as f:
hand_model_dict = json.load(f)
if "hand_model" in hand_model_dict.keys():
return from_dict(hand_model_dict["hand_model"])
return None
class UmeTrackHandDataProvider(HandDataProviderBase):
def __init__(
self, hand_pose_trajectory_filepath: str, hand_profile_filepath: str
) -> None:
super().__init__()
super()._init_hand_poses(hand_pose_trajectory_filepath)
# Hand profile
self._hand_model = (
None
if len(self._hand_poses) == 0
else load_hand_model_from_file(hand_profile_filepath)
)
def get_hand_mesh_vertices(
self, hand_wrist_data: HandPose
) -> Optional[torch.Tensor]:
"""
Return the hand mesh corresponding to given HandPose
"""
if hand_wrist_data.wrist_pose is not None and self._hand_model is not None:
hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
# self._hand_model is defined for the Left hand,
# flipping here the pose X axis is moving the Left Hand to a Right Hand
if hand_wrist_data.handedness == Handedness.Right:
hand_wrist_pose_tensor[:, 0] *= -1
mesh_vertices = skin_vertices(
self._hand_model,
torch.Tensor(hand_wrist_data.joint_angles),
hand_wrist_pose_tensor,
)
return mesh_vertices
return None
def get_hand_mesh_faces_and_normals(
self, hand_wrist_data: HandPose
) -> Optional[List[np.ndarray]]:
"""
Return the hand mesh faces and normals
"""
if self._hand_model is not None and self._hand_model.mesh_triangles is not None:
hand_triangles = self._hand_model.mesh_triangles.int().numpy()
vertices = self.get_hand_mesh_vertices(hand_wrist_data)
assert vertices is not None
normals = HandDataProviderBase.get_triangular_mesh_normals(
vertices.float().numpy(), hand_triangles
)
return [hand_triangles, normals]
else:
return None
def get_hand_landmarks(self, hand_wrist_data: HandPose) -> Optional[torch.Tensor]:
"""
Return the hand joint landmarks corresponding to given HandPose
See how to map the vertices together to represent a Hand as linked lines using LANDMARK_CONNECTIVITY
"""
if self._hand_model is not None and self._hand_model.mesh_triangles is not None:
hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
# self._hand_model is defined for the Left hand,
# flipping here the pose X axis is moving the Left Hand to a Right Hand
if hand_wrist_data.handedness == Handedness.Right:
hand_wrist_pose_tensor[:, 0] *= -1
hand_landmarks = skin_landmarks(
self._hand_model,
torch.Tensor(hand_wrist_data.joint_angles),
hand_wrist_pose_tensor,
)
return hand_landmarks
return None
NUM_JOINT_FRAMES: int = 1 + 1 + 3 * 5 # root + wrist + finger frames * 5
def skin_landmarks(
hand_model: UmeTrackHandModelData,
joint_angles: torch.Tensor,
wrist_transforms: torch.Tensor,
) -> torch.Tensor:
leading_dims = joint_angles.shape[:-1]
numel = torch.flatten(joint_angles, end_dim=-2).shape[0] if len(leading_dims) else 1
max_weights = hand_model.landmark_rest_bone_indices.shape[-1]
skin_mat = get_skinning_weights(
hand_model.landmark_rest_bone_indices.reshape(numel, -1, max_weights),
hand_model.landmark_rest_bone_weights.reshape(numel, -1, max_weights),
NUM_JOINT_FRAMES,
)
return skin_points(
hand_model.joint_rest_positions.double(),
hand_model.joint_rotation_axes.double(),
skin_mat.double(),
joint_angles.double(),
hand_model.landmark_rest_positions.double(),
wrist_transforms.double(),
)
def skin_vertices(
hand_model: UmeTrackHandModelData,
joint_angles: torch.Tensor,
wrist_transforms: Optional[torch.Tensor] = None,
) -> torch.Tensor:
assert hand_model.mesh_vertices is not None, "mesh vertices should not be none"
assert hand_model.dense_bone_weights is not None, (
"dense bone weights should not be none"
)
vertices = skin_points(
hand_model.joint_rest_positions.double(),
hand_model.joint_rotation_axes.double(),
hand_model.dense_bone_weights.double(),
joint_angles.double(),
hand_model.mesh_vertices.double(),
wrist_transforms.double(),
)
leading_dims = joint_angles.shape[:-1]
vertices = vertices.reshape(list(leading_dims) + list(vertices.shape[-2:]))
return vertices
|