Upload 2 files

body_angular_constraints.py

@@ -0,0 +1,67 @@
+from scipy.spatial.transform import Rotation as R
+import torch, numpy as np
+
+BOF_body = np.array([
+    [-120.0, -130.0,  -80.0, # left shoulder
+     -120.0,   0.0,  -80.0, # right shoulder
+     -180.0, -160.0, -180.0, # left elbow
+     -180.0,  0.0,  -180.0, # right elbow
+     -120.0,  -50.0,  -90.0, # left wrist
+     -120.0,  -50.0,  -90.0, # right wrist
+     ],
+     [90.0,    0.0,   80.0, # left shoulder
+      90.0, 130.0,   80.0, # right shoulder
+      180.0,    0.0,   180.0, # left elbow
+      180.0,  160.0,    180.0, # right elbow
+      90.0,   50.0,   90.0, # left wrist
+      90.0,   50.0,   90.0]]) / 180 * np.pi
+
+
+def _to_numpy_flat_last3(x: torch.Tensor):
+    dev, dt = x.device, x.dtype
+    x_np = x.detach().cpu().numpy().reshape(-1, 3)
+    return x_np, x.shape, dev, dt
+
+def _from_numpy(x_np: np.ndarray, shape, dev, dt):
+    y = torch.from_numpy(x_np.reshape(*shape))
+    if dt in (torch.float32, torch.float64): y = y.to(dt)
+    return y.to(dev)
+
+
+
+def euler_XYZ_to_axis_angle_scipy(e: torch.Tensor, degrees: bool = False) -> torch.Tensor:
+    e_np, shape, dev, dt = _to_numpy_flat_last3(e)
+    aa_np = R.from_euler('XYZ', e_np, degrees=degrees).as_rotvec()
+    return _from_numpy(aa_np, shape, dev, dt)
+
+def axis_angle_to_euler_XYZ_scipy(aa: torch.Tensor):
+    aa_np, shape, dev, dt = _to_numpy_flat_last3(aa)
+    e_np  = R.from_rotvec(aa_np).as_euler('XYZ', degrees=False)
+    return _from_numpy(e_np, shape, dev, dt)
+
+
+
+
+def apply_angular_constraints(body_pose):  # body_pose: (B, 63) axis-angle for 21 joints
+    device = body_pose.device
+    B = body_pose.shape[0]
+    body_pose = body_pose.view(B, 21, 3)
+
+    # your bounds (6×3) in radians, defined for joints [15..20] in intrinsic 'XYZ'
+    minC = torch.tensor(BOF_body[0], dtype=body_pose.dtype, device=device).view(6,3)
+    maxC = torch.tensor(BOF_body[1], dtype=body_pose.dtype, device=device).view(6,3)
+
+    aa_arms = body_pose[:, 15:, :]
+    
+    e_arms  = axis_angle_to_euler_XYZ_scipy(aa_arms)       # (B,6,3) intrinsic 'XYZ'
+
+    e_clamp = torch.clamp(e_arms, minC, maxC)
+
+    aa_new = euler_XYZ_to_axis_angle_scipy(e_clamp)
+
+    body_pose[:, 15:, :] = aa_new
+    
+    return body_pose.view(B, -1)
+
+
+

hand_angular_constraints.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+import torch
+import os
+import numpy as np
+import trimesh
+from common.utils.utils_hand import batch_euler2matzxy, coordtrans
+
+from kornia.geometry.conversions import axis_angle_to_rotation_matrix, quaternion_to_rotation_matrix, euler_from_quaternion, rotation_matrix_to_quaternion, quaternion_from_euler, rotation_matrix_to_axis_angle
+
+
+euler_coordtrans_RIGHT = np.array([
+       [   15,  -6,  10,
+           15,   1,  -5,
+           15, -15,   0,
+           0,  20,   2,
+           0,  10,  -2,
+           0,  10,  10,
+           15,  25,  10,
+           10,  37,   8,
+           7,  35,   8,
+           0,  12,   5,
+           0,  25,  -5,
+           0,  25,  15,
+          -30, -75, -35,
+          -30, -45, -30,
+          -30, -45, -30]]) / 180 * np.pi
+euler_coordtrans_LEFT = np.array([
+       [   15,   6, -10,
+           15,  -1,   5,
+           15,  15,   0,
+           0, -20,  -2,
+           0, -10,   2,
+           0, -10, -10,
+          15, -25, -10,
+          10, -37,  -8,
+          7, -35,  -8,
+           0, -12,  -5,
+           0, -25,   5,
+           0, -25, -15,
+          -30,  75,  35,
+          -30,  45,  30,
+          -30,  45,  30]]) / 180 * np.pi
+
+# range of motion
+
+BOF_RIGHT = np.array([
+       [ 
+           0, -30, -40, # index0
+           0,   0,   0, # index1
+           0,   0, -5, # index2
+
+           0, -22.5, -40, # middle0
+           0,   0,   0, # middle1
+           0,   0, -5, # middle2
+
+           0, -25, -40, # pinky0
+           0,   0,   0, # pinky1
+           0,   0, -5, # pinky2
+           
+           0, -22.5, -40, # ring0
+           0,   0,   0, # ring1
+           0,   0, -5, # ring2
+           
+           -180, -60, -15, # thumb0
+           -180,-5,  -180, # thumb1
+           -180, -5,  -10], # thumb0
+
+         # MAX VALUES  
+        [
+         
+           0,   30,  90, # index0
+           0,   0, 110, # index1
+           0,   0,  90, # index2
+
+           0,  22.5, 90, # middle0
+           0,   0, 110, # middle1
+           0,   0,  90, # middle2
+
+           0,  25, 90, # pinky0
+           0,   0, 135, # pinky1
+           0,   0,  90, # pinky2
+
+           0,  22.5,  90, # ring0
+           0,   0, 120, # ring1
+           0,   0,  90, # ring2
+
+           180,  60,  90, # thumb0
+           180,   5,   80,  # thumb1
+           180,  5,   80]])
+
+BOF_LEFT = np.array([
+        [
+         
+           0,  -30, -90, # index0
+           0,   0,-110, # index1
+           0,   0, -90, # index2
+
+           0, -22.5, -90, # middle0
+           0,  0,  -110, # middle1
+           0, 0,  -90, # middle2
+           
+           0, -25, -90, # pinky0
+           0, 0, -135, # pinky1
+           0,  0, -90, # pinky2
+           
+           0, -22.5,  -90, # ring0
+           0,   0,   -120, # ring1
+           0,   0, -90, # ring2
+           
+           -180, -60, -90, # thumb0
+           -180, -5,   -80, # thumb1
+           -180, -5,   -80], # thumb2
+
+        [ 
+         
+           0,  30,   40, # index0
+           0,   0,   0, # index1
+           0,   0,   5, # index2
+
+           0,  22.5, 40, # middle0
+           0,   0,   0, # middle1
+           0,   0,   5, # middle2
+           
+           0,  25,   40, # pinky0
+           0,   0,   0, # pinky1
+           0,   0,   5, # pinky2
+
+           0,  22.5,  40, # ring0
+           0,   0,   0, # ring1
+           0,   0,   5, # ring2
+
+           180,  60,  15, # thumb0
+           180,  5,   180, # thumb1
+           180,  5,   10], # thumb2
+        ])
+
+def do_clipping(input_angles, side, rotation_type):
+
+    device = input_angles.device
+
+    if side == "LEFT":
+        max = torch.tensor(BOF_LEFT[1,:], dtype=torch.float32).reshape(15,3).to(device)
+        min = torch.tensor(BOF_LEFT[0,:], dtype=torch.float32).reshape(15,3).to(device)
+        min_np = torch.deg2rad(min) # shape (N, 3)
+        max_np = torch.deg2rad(max)
+
+    elif side == "RIGHT":
+        max = torch.tensor(BOF_RIGHT[1,:], dtype=torch.float32).reshape(15,3).to(device)
+        min = torch.tensor(BOF_RIGHT[0,:], dtype=torch.float32).reshape(15,3).to(device)
+        min_np = torch.deg2rad(min)  # shape (N, 3)
+        max_np = torch.deg2rad(max)
+
+    input_angles = input_angles.reshape(-1,15,3)
+
+    B, J, N = input_angles.shape
+        
+    if rotation_type == "quat":
+
+        org_mats = quaternion_to_rotation_matrix(input_angles).float()
+
+    elif rotation_type == "aa":
+
+        org_mats = axis_angle_to_rotation_matrix(input_angles.reshape(-1, 3)).float()
+
+        if len(org_mats.shape)!=4:
+
+            org_mats = org_mats.unsqueeze(0)
+
+    rotmat_mano = org_mats.clone()
+
+    rotmat_mano = rotmat_mano.view(-1,15,3,3)
+
+    name = f"euler_coordtrans_{side.upper()}"
+    mat = globals()[name]   
+
+    local2global = torch.from_numpy(mat).type(torch.float32).to(device)
+
+    local2global = batch_euler2matzxy(local2global.view(-1,3)).view(-1,15,3,3).expand(1,-1,-1,-1)
+
+    anatom_space_mats = coordtrans(rotmat_mano, local2global, 0)
+
+    mat_to_quat = rotation_matrix_to_quaternion(anatom_space_mats)
+
+    roll, pitch, yaw = euler_from_quaternion(mat_to_quat[:, :, 0], mat_to_quat[:, :, 1], mat_to_quat[:, :, 2], mat_to_quat[:, :, 3])
+
+    euler_from_quat = torch.stack([roll, pitch, yaw], dim=-1)  # shape (1, 15, 3)
+
+    euler_from_quat = torch.clip(euler_from_quat, min_np, max_np)  # root joint is always zero
+
+    qw, qx, qy, qz = quaternion_from_euler(euler_from_quat[:,:, 0], euler_from_quat[:,:, 1], euler_from_quat[:,:, 2])
+
+    rots_anat = torch.stack([qw, qx, qy, qz], dim=-1)  # shape (1, 15, 4)
+
+    anat_mats = quaternion_to_rotation_matrix(rots_anat)
+
+    corrected_mano_space = coordtrans(anat_mats, local2global, 1)
+
+    corrected_aa = rotation_matrix_to_axis_angle(corrected_mano_space).reshape(B, J*3)
+
+    return corrected_aa
+