HOT3DHUGGFACE/data_loaders/mano_layer.py

# 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 os
from typing import List, Optional

SMPLX_IMPORT_SUCCEEDED = False  # default suppose we can't import SMPLX

try:
    import smplx

    SMPLX_IMPORT_SUCCEEDED = True
except ImportError:
    print(
        "INFO: HOT3D hands requires smplx (See our GitHub repository for more information on its installation)."
    )

import torch

mano_joint_mapping = [
    16,
    17,
    18,
    19,
    20,
    0,
    14,
    15,
    1,
    2,
    3,
    4,
    5,
    6,
    10,
    11,
    12,
    7,
    8,
    9,
]


class MANOHandModel:
    #一只手有 778 个 3D 顶点
    N_VERT = 778
    N_LANDMARKS = 21
    #每一个手指N_VERT中的index分区
    MANO_FINGERTIP_VERT_INDICES = {
        "thumb": 744,
        "index": 320,
        "middle": 443,
        "ring": 554,
        "pinky": 671,
    }

    def __init__(
        self,
        mano_model_files_dir: str,
        ##手部关节索引列表：index list，也就是“索引列表”
        joint_mapper: Optional[List] = mano_joint_mapping,
    ):
        mano_left_filename = os.path.join(mano_model_files_dir, "MANO_LEFT.pkl")
        mano_right_filename = os.path.join(mano_model_files_dir, "MANO_RIGHT.pkl")

        #PCA 全称是 Principal Component Analysis，中文通常叫 主成分分析
        #降维方法，把很多手部参数，压缩成更少的几个重要参数。
        #使用PCA，15个参数描述手部姿势变化，10 个参数描述手的形状
        self.use_pose_pca = True
        self.num_pose_coeffs = 15
        self.num_shape_params = 10
        self.device = "cpu"
        self.dtype = torch.float32
        self.joint_mapper = joint_mapper

        #smplx.create创建 mano左手模型，一个 PyTorch 模型对象
        self.mano_layer_left = smplx.create(
            mano_left_filename,
            "mano",
            use_pca=self.use_pose_pca,
            is_rhand=False,
            num_pca_comps=self.num_pose_coeffs,
        )
        self.mano_layer_left.to(self.device)

        self.mano_layer_right = smplx.create(
            mano_right_filename,
            "mano",
            use_pca=self.use_pose_pca,
            is_rhand=True,
            num_pca_comps=self.num_pose_coeffs,
        )
        self.mano_layer_right.to(self.device)

        #左右手同向bug
        # fix MANO shapedirs of the left hand bug (https://github.com/vchoutas/smplx/issues/48)
        if (
            torch.sum(
                torch.abs(
                    self.mano_layer_left.shapedirs[:, 0, :]
                    - self.mano_layer_right.shapedirs[:, 0, :]
                )
            )
            < 1
        ):
            self.mano_layer_left.shapedirs[:, 0, :] *= -1

    def forward_kinematics(
        self,
        shape_params: torch.Tensor,
        #手指怎么弯、怎么张开
        joint_angles: torch.Tensor,
        #手的方向
        global_xfrom: torch.Tensor,
        is_right_hand: torch.Tensor,
        #tuple元组，固定结构的返回值，x, y = get_result()
    ) -> tuple[torch.Tensor, torch.Tensor]:
        assert shape_params.shape[0] == self.num_shape_params
        #在第 0 维前面加一个新维度，统一成 batch 格式。
        is_batched = len(joint_angles.shape) == 2
        if len(global_xfrom.shape) == 1:
            global_xfrom = torch.unsqueeze(global_xfrom, 0)
            
        assert global_xfrom.shape[1] == 6
        if len(joint_angles.shape) == 1:
            joint_angles = torch.unsqueeze(joint_angles, 0)
            
        if self.use_pose_pca:
            assert joint_angles.shape[1] == self.num_pose_coeffs
        assert is_right_hand.shape[0] == joint_angles.shape[0]

        num_frames = joint_angles.shape[0]

        # Left hand FK
        if torch.any(torch.logical_not(is_right_hand)):
            #取出左手的 global_xfrom 和 joint_angles
            left_global_xform = global_xfrom[torch.logical_not(is_right_hand)]
            left_joint_angles = joint_angles[torch.logical_not(is_right_hand)]
            #调用之前的left hand模型
            left_mano_output = self.mano_layer_left(
                #复制shape_params匹配batch大小
                betas=shape_params[None]
                .repeat(left_global_xform.shape[0], 1)
                .to(self.dtype),
                #手的朝向
                global_orient=left_global_xform[:, :3].to(self.dtype),
                hand_pose=left_joint_angles.to(self.dtype),
                #整只手的平移
                transl=left_global_xform[:, 3:].to(self.dtype),
                #返回手部 mesh 顶点
                return_verts=True,  # MANO doesn't return landmarks as well if this is false
            )

        # Right hand FK
        if torch.any(is_right_hand):
            right_global_xform = global_xfrom[is_right_hand]
            right_joint_angles = joint_angles[is_right_hand]
            right_mano_output = self.mano_layer_right(
                betas=shape_params[None]
                .repeat(right_global_xform.shape[0], 1)
                .to(self.dtype),
                global_orient=right_global_xform[:, :3].to(self.dtype),
                hand_pose=right_joint_angles.to(self.dtype),
                transl=right_global_xform[:, 3:].to(self.dtype),
                return_verts=True,  # MANO doesn't return landmarks as well if this is false
            )

        # Merge the left and right hand outputs
        #把左右手的顶点和关节合并到一起(mesh)
        out_vertices = torch.zeros(
            (
                num_frames,
                self.N_VERT,
                3,
            )
        ).to(self.device)
        if torch.any(torch.logical_not(is_right_hand)):
            out_vertices[torch.logical_not(is_right_hand)] = left_mano_output.vertices
        if torch.sum(is_right_hand) > 0:
            out_vertices[is_right_hand] = right_mano_output.vertices

        #把左右手的顶点和关节合并到一起(points)
        out_landmarks = torch.zeros(
            (
                num_frames,
                self.N_LANDMARKS,
                3,
            )
        ).to(self.device)
        if torch.any(torch.logical_not(is_right_hand)):
            if left_mano_output.joints.shape[1] != self.N_LANDMARKS:
                extra_joints = torch.index_select(
                    left_mano_output.vertices,
                    1,
                    torch.tensor(
                        list(self.MANO_FINGERTIP_VERT_INDICES.values()),
                        dtype=torch.long,
                    ),
                )
                joints = torch.cat([left_mano_output.joints, extra_joints], dim=1)
            else:
                joints = left_mano_output.joints
            out_landmarks[torch.logical_not(is_right_hand)] = joints
        if torch.sum(is_right_hand) > 0:
            if right_mano_output.joints.shape[1] != self.N_LANDMARKS:
                extra_joints = torch.index_select(
                    right_mano_output.vertices,
                    1,
                    torch.tensor(
                        list(self.MANO_FINGERTIP_VERT_INDICES.values()),
                        dtype=torch.long,
                    ),
                )
                joints = torch.cat([right_mano_output.joints, extra_joints], dim=1)
            else:
                joints = right_mano_output.joints
            out_landmarks[is_right_hand] = joints

        assert out_landmarks.shape[1] == self.N_LANDMARKS

        if self.joint_mapper is not None:
            out_landmarks = out_landmarks[:, self.joint_mapper]
            
        if not is_batched:
            out_vertices = torch.squeeze(out_vertices, 0)
            out_landmarks = torch.squeeze(out_landmarks, 0)

        return out_vertices, out_landmarks

    #简化版本，只有shape参数，pose参数和global xform都设为0
    #pose_params = 0-->手指不弯曲，global_xform = 0 --> 手的朝向是默认的
    #pose_xform = 0 --> 手的朝向是默认的，手的位置也是默认的
    
    def shape_only_forward_kinematics(
        self,
        shape_params: torch.Tensor,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        """
        Method to get the vertices and landmarks of the hand using only the shape
        parameters and passing 0s for pose params and global xform.

        Args:
            shape_params: N x 6 (N is the number of frames) or 6,
        """

        is_batched = len(shape_params.shape) == 2
        if is_batched:
            assert shape_params.shape[1] == self.num_shape_params
            num_frames = shape_params.shape[0]
        else:
            assert shape_params.shape[0] == self.num_shape_params
            shape_params = shape_params.unsqueeze(0)
            num_frames = 1

        # create zero pose params
        pose_params = torch.zeros((num_frames, 15))
        pose_xform = torch.zeros((num_frames, 6))

        # FK
        left_mano_output = self.mano_layer_left(
            betas=shape_params.to(self.dtype),
            global_orient=pose_xform[:, :3].to(self.dtype),
            hand_pose=pose_params.to(self.dtype),
            transl=pose_xform[:, 3:].to(self.dtype),
            return_verts=True,  # MANO doesn't return landmarks as well if this is false
        )

        # Merge the left and right hand outputs
        out_vertices = left_mano_output.vertices

        if left_mano_output.joints.shape[1] != self.N_LANDMARKS:
            extra_joints = torch.index_select(
                left_mano_output.vertices,
                1,
                torch.tensor(
                    list(self.MANO_FINGERTIP_VERT_INDICES.values()),
                    dtype=torch.long,
                ),
            )
            joints = torch.cat([left_mano_output.joints, extra_joints], dim=1)
        else:
            joints = left_mano_output.joints
        out_landmarks = joints

        assert out_landmarks.shape[1] == self.N_LANDMARKS

        if self.joint_mapper is not None:
            out_landmarks = out_landmarks[:, self.joint_mapper]

        if not is_batched:
            out_vertices = torch.squeeze(out_vertices, 0)
            out_landmarks = torch.squeeze(out_landmarks, 0)

        return out_vertices, out_landmarks


def loadManoHandModel(
    mano_model_files_dir: Optional[str],
) -> MANOHandModel:
    if not SMPLX_IMPORT_SUCCEEDED or mano_model_files_dir is None:
        return None

    return MANOHandModel(mano_model_files_dir)