KinCharModel

class JointType(enum.Enum):
    ROOT = 0       # Root joint (no DOF)
    HINGE = 1      # 1-DOF revolute joint
    SPHERICAL = 2  # 3-DOF ball joint
    FIXED = 3      # Fixed joint (no DOF)

class GeomType(enum.Enum):
    BOX = 0
    SPHERE = 1
    CAPSULE = 2
    CYLINDER = 3
    MESH = 4

Joint(name: str, joint_type: JointType, axis: torch.Tensor, limits=None)

get_dof_dim() -> int

dof_to_rot(dof: torch.Tensor) -> torch.Tensor

rot_to_dof(rot: torch.Tensor) -> torch.Tensor

Geom(
    shape_type: GeomType,
    offset: torch.Tensor | list,
    dims: torch.Tensor | list,
    device,
    quat=None,
    radius=None,
    mesh_name=None,
    name=None
)

KinCharModel(device)

init(
    body_names: list[str],
    parent_indices: list[int] | torch.Tensor,
    local_translation: list | torch.Tensor,
    local_rotation: list | torch.Tensor,
    joints: list[Joint],
    geoms: list[list[Geom]] = None,
    contact_body_names: list[str] = None
)

load_char_file(char_file: str)

forward_kinematics(
    root_pos: torch.Tensor,
    root_rot: torch.Tensor,
    joint_rot: torch.Tensor
) -> tuple[torch.Tensor, torch.Tensor]

dof_to_rot(dof: torch.Tensor) -> torch.Tensor

rot_to_dof(rot: torch.Tensor) -> torch.Tensor

compute_dof_vel(
    joint_rot0: torch.Tensor,
    joint_rot1: torch.Tensor,
    dt: float
) -> torch.Tensor

compute_frame_dof_vel(
    joint_rot: torch.Tensor,
    dt: float
) -> torch.Tensor

apply_joint_dof_limits(joint_dofs: torch.Tensor) -> torch.Tensor

construct_frame_data(
    root_pos: torch.Tensor,
    root_rot_quat: torch.Tensor,
    joint_rot: torch.Tensor
) -> torch.Tensor

get_num_bodies() -> int

get_num_joints() -> int

get_num_non_root_joints() -> int

get_dof_size() -> int

get_body_names() -> list[str]

get_body_name(body_id: int) -> str

get_body_id(body_name: str) -> int

get_joint_id(body_name: str) -> int

get_joint(j: int) -> Joint

get_parent_id(j: int) -> int

get_joint_dof_idx(j: int) -> int

get_joint_dof_dim(j: int) -> int

get_num_contact_bodies() -> int

is_contact_body(body_name: str) -> bool

get_contact_body_id(body_name: str) -> int

get_contact_body_ids() -> torch.Tensor

get_contact_body_name(body_id: int) -> str

create_full_contact_tensor(contact_tensor: torch.Tensor) -> torch.Tensor

get_geoms(body_id: int) -> list[Geom]

get_body_geom_names() -> list[str]

find_lowest_point(
    body_pos: torch.Tensor,
    body_rot: torch.Tensor
) -> torch.Tensor

get_bone_length(body: int | str) -> float

set_bone_length(
    body: int | str,
    new_length: float,
    update_original: bool = True,
    update_geoms: bool = True
)

scale_bone_length(
    body: int | str,
    scale: float,
    update_original: bool = True,
    update_geoms: bool = True
)

get_copy(new_device=None) -> KinCharModel

output_xml(output_file: str)

import torch
from parc.anim.kin_char_model import KinCharModel

# Create and load character model
char_model = KinCharModel(device="cuda:0")
char_model.load_char_file("path/to/character.xml")

# Query character properties
print(f"Number of bodies: {char_model.get_num_bodies()}")
print(f"Number of joints: {char_model.get_num_joints()}")
print(f"DOF size: {char_model.get_dof_size()}")
print(f"Body names: {char_model.get_body_names()}")

import torch

# Define root pose and joint rotations
batch_size = 10
num_joints = char_model.get_num_joints() - 1

root_pos = torch.zeros(batch_size, 3, device="cuda:0")
root_pos[:, 2] = 1.0  # 1 meter above ground

root_rot = torch.tensor([0, 0, 0, 1], device="cuda:0").expand(batch_size, 4)
joint_rot = torch.zeros(batch_size, num_joints, 4, device="cuda:0")
joint_rot[..., 3] = 1.0  # Identity quaternions

# Compute forward kinematics
body_pos, body_rot = char_model.forward_kinematics(root_pos, root_rot, joint_rot)

print(f"Body positions shape: {body_pos.shape}")  # [10, num_bodies, 3]
print(f"Body rotations shape: {body_rot.shape}")  # [10, num_bodies, 4]

# Convert joint rotations to DOF values
dof_values = char_model.rot_to_dof(joint_rot)
print(f"DOF shape: {dof_values.shape}")  # [10, dof_size]

# Apply joint limits
clamped_dofs = char_model.apply_joint_dof_limits(dof_values)

# Convert back to rotations
joint_rot_new = char_model.dof_to_rot(clamped_dofs)

# Get contact body information
num_contact = char_model.get_num_contact_bodies()
contact_ids = char_model.get_contact_body_ids()

print(f"Number of contact bodies: {num_contact}")
for i in range(num_contact):
    name = char_model.get_contact_body_name(i)
    print(f"Contact body {i}: {name}")

# Expand contact tensor to all bodies
contact_labels = torch.randn(batch_size, num_contact, device="cuda:0")
full_contacts = char_model.create_full_contact_tensor(contact_labels)
print(f"Full contact tensor shape: {full_contacts.shape}")  # [10, num_bodies]

# Get current bone length
body_name = "left_shin"
original_length = char_model.get_bone_length(body_name)
print(f"Original length: {original_length:.3f}m")

# Scale the bone
char_model.scale_bone_length(body_name, scale=1.2)
new_length = char_model.get_bone_length(body_name)
print(f"New length: {new_length:.3f}m")

# Or set absolute length
char_model.set_bone_length(body_name, new_length=0.5)

# Create two consecutive frames
num_frames = 100
joint_rot_sequence = torch.randn(num_frames, num_joints, 4, device="cuda:0")
joint_rot_sequence = joint_rot_sequence / joint_rot_sequence.norm(dim=-1, keepdim=True)

# Compute velocities for entire sequence
dt = 1.0 / 30.0  # 30 FPS
dof_vel = char_model.compute_frame_dof_vel(joint_rot_sequence, dt)
print(f"DOF velocities shape: {dof_vel.shape}")  # [100, dof_size]

# Get body poses from forward kinematics
body_pos, body_rot = char_model.forward_kinematics(root_pos, root_rot, joint_rot)

# Find the lowest point (useful for ground contact)
lowest_point = char_model.find_lowest_point(body_pos, body_rot)
print(f"Lowest point: {lowest_point}")
print(f"Height above ground: {lowest_point[..., 2]}")