Upload src/data/skeleton_graph.py with huggingface_hub

src/data/skeleton_graph.py

@@ -0,0 +1,306 @@
+"""
+Skeleton graph representation for topology-agnostic motion processing.
+
+Each skeleton is represented as a directed tree graph with:
+- Joint features: rest offset, bone length, depth, degree, parent type, side tag
+- Edge features: parent-child relations, geodesic distances
+- Joint name embeddings: CLIP-encoded semantic features
+
+This is the foundation for the TopoSlots slot assignment module.
+"""
+
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class SkeletonGraph:
+    """Unified skeleton graph representation for arbitrary topologies."""
+
+    # Basic structure
+    joint_names: list[str]  # [J] joint names
+    parent_indices: list[int]  # [J] parent index (-1 for root)
+    rest_offsets: np.ndarray  # [J, 3] rest-pose offsets from parent
+
+    # Derived features (computed in __post_init__)
+    num_joints: int = 0
+    bone_lengths: np.ndarray = field(default_factory=lambda: np.array([]))  # [J]
+    depths: np.ndarray = field(default_factory=lambda: np.array([]))  # [J] tree depth
+    degrees: np.ndarray = field(default_factory=lambda: np.array([]))  # [J] num children
+    adjacency: np.ndarray = field(default_factory=lambda: np.array([]))  # [J, J] binary
+    geodesic_dist: np.ndarray = field(default_factory=lambda: np.array([]))  # [J, J]
+    side_tags: list[str] = field(default_factory=list)  # [J] 'left'/'right'/'center'
+    symmetry_pairs: list[tuple[int, int]] = field(default_factory=list)
+
+    # Semantic features (filled by encode_joint_names)
+    name_embeddings: Optional[np.ndarray] = None  # [J, D_clip]
+
+    def __post_init__(self):
+        self.num_joints = len(self.joint_names)
+        J = self.num_joints
+
+        if J == 0:
+            return
+
+        # Bone lengths
+        self.bone_lengths = np.linalg.norm(self.rest_offsets, axis=-1)  # [J]
+
+        # Tree depth via BFS from root
+        self.depths = np.zeros(J, dtype=np.int32)
+        for j in range(J):
+            d = 0
+            p = self.parent_indices[j]
+            while p >= 0:
+                d += 1
+                p = self.parent_indices[p]
+            self.depths[j] = d
+
+        # Degree (number of children)
+        self.degrees = np.zeros(J, dtype=np.int32)
+        for j in range(J):
+            p = self.parent_indices[j]
+            if p >= 0:
+                self.degrees[p] += 1
+
+        # Adjacency matrix (undirected)
+        self.adjacency = np.zeros((J, J), dtype=np.float32)
+        for j in range(J):
+            p = self.parent_indices[j]
+            if p >= 0:
+                self.adjacency[j, p] = 1.0
+                self.adjacency[p, j] = 1.0
+
+        # Geodesic distances via BFS
+        self.geodesic_dist = self._compute_geodesic_distances()
+
+        # Side tags from joint names
+        self.side_tags = self._infer_side_tags()
+
+        # Symmetry pairs
+        self.symmetry_pairs = self._find_symmetry_pairs()
+
+    def _compute_geodesic_distances(self) -> np.ndarray:
+        """BFS-based geodesic distance on skeleton tree."""
+        J = self.num_joints
+        dist = np.full((J, J), fill_value=J + 1, dtype=np.int32)
+        np.fill_diagonal(dist, 0)
+
+        for i in range(J):
+            # BFS from joint i
+            queue = [i]
+            visited = {i}
+            while queue:
+                curr = queue.pop(0)
+                for j in range(J):
+                    if self.adjacency[curr, j] > 0 and j not in visited:
+                        dist[i, j] = dist[i, curr] + 1
+                        visited.add(j)
+                        queue.append(j)
+
+        return dist.astype(np.float32)
+
+    def _infer_side_tags(self) -> list[str]:
+        """Infer left/right/center from joint names."""
+        tags = []
+        left_keywords = ['left', 'l_', '_l', 'lft']
+        right_keywords = ['right', 'r_', '_r', 'rgt']
+
+        for name in self.joint_names:
+            name_lower = name.lower()
+            if any(kw in name_lower for kw in left_keywords):
+                tags.append('left')
+            elif any(kw in name_lower for kw in right_keywords):
+                tags.append('right')
+            else:
+                tags.append('center')
+
+        return tags
+
+    def _find_symmetry_pairs(self) -> list[tuple[int, int]]:
+        """Find symmetric joint pairs based on naming conventions."""
+        pairs = []
+        used = set()
+
+        for i, name_i in enumerate(self.joint_names):
+            if i in used:
+                continue
+            name_lower = name_i.lower()
+
+            # Try to find mirror
+            mirror_name = None
+            if 'left' in name_lower:
+                mirror_name = name_lower.replace('left', 'right')
+            elif 'right' in name_lower:
+                mirror_name = name_lower.replace('right', 'left')
+            elif '_l_' in name_lower:
+                mirror_name = name_lower.replace('_l_', '_r_')
+            elif '_r_' in name_lower:
+                mirror_name = name_lower.replace('_r_', '_l_')
+
+            if mirror_name:
+                for j, name_j in enumerate(self.joint_names):
+                    if j != i and j not in used and name_j.lower() == mirror_name:
+                        pairs.append((i, j))
+                        used.add(i)
+                        used.add(j)
+                        break
+
+        return pairs
+
+    def get_edge_list(self) -> list[tuple[int, int]]:
+        """Return parent-child edge list."""
+        edges = []
+        for j in range(self.num_joints):
+            p = self.parent_indices[j]
+            if p >= 0:
+                edges.append((p, j))
+        return edges
+
+    def get_joint_features(self) -> np.ndarray:
+        """
+        Compute per-joint feature vector for skeleton encoder input.
+        Returns: [J, D] where D = 3 (offset) + 1 (bone_len) + 1 (depth) + 1 (degree) + 3 (side one-hot)
+        """
+        J = self.num_joints
+
+        # Side tags as one-hot: [left, right, center]
+        side_onehot = np.zeros((J, 3), dtype=np.float32)
+        for j, tag in enumerate(self.side_tags):
+            if tag == 'left':
+                side_onehot[j, 0] = 1.0
+            elif tag == 'right':
+                side_onehot[j, 1] = 1.0
+            else:
+                side_onehot[j, 2] = 1.0
+
+        # Normalize rest offsets
+        max_offset = np.max(np.abs(self.rest_offsets)) + 1e-8
+        norm_offsets = self.rest_offsets / max_offset
+
+        # Normalize bone lengths
+        max_bone = np.max(self.bone_lengths) + 1e-8
+        norm_bones = (self.bone_lengths / max_bone).reshape(-1, 1)
+
+        # Normalize depth/degree
+        max_depth = max(self.depths.max(), 1)
+        norm_depths = (self.depths / max_depth).reshape(-1, 1).astype(np.float32)
+        max_degree = max(self.degrees.max(), 1)
+        norm_degrees = (self.degrees / max_degree).reshape(-1, 1).astype(np.float32)
+
+        features = np.concatenate([
+            norm_offsets,     # [J, 3]
+            norm_bones,       # [J, 1]
+            norm_depths,      # [J, 1]
+            norm_degrees,     # [J, 1]
+            side_onehot,      # [J, 3]
+        ], axis=-1)  # [J, 9]
+
+        return features
+
+    def to_dict(self) -> dict:
+        """Serialize to dict for saving."""
+        return {
+            'joint_names': self.joint_names,
+            'parent_indices': self.parent_indices,
+            'rest_offsets': self.rest_offsets,
+            'bone_lengths': self.bone_lengths,
+            'depths': self.depths,
+            'degrees': self.degrees,
+            'adjacency': self.adjacency,
+            'geodesic_dist': self.geodesic_dist,
+            'side_tags': self.side_tags,
+            'symmetry_pairs': self.symmetry_pairs,
+            'name_embeddings': self.name_embeddings,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> 'SkeletonGraph':
+        """Deserialize from dict."""
+        sg = cls(
+            joint_names=d['joint_names'],
+            parent_indices=d['parent_indices'],
+            rest_offsets=d['rest_offsets'],
+        )
+        if d.get('name_embeddings') is not None:
+            sg.name_embeddings = d['name_embeddings']
+        return sg
+
+
+# ============================================================
+# Joint name normalization (alias table)
+# ============================================================
+
+JOINT_NAME_ALIASES = {
+    # Mixamo naming
+    'mixamorig:hips': 'pelvis',
+    'mixamorig:spine': 'spine',
+    'mixamorig:spine1': 'spine1',
+    'mixamorig:spine2': 'chest',
+    'mixamorig:neck': 'neck',
+    'mixamorig:head': 'head',
+    'mixamorig:leftshoulder': 'left shoulder',
+    'mixamorig:leftarm': 'left upper arm',
+    'mixamorig:leftforearm': 'left forearm',
+    'mixamorig:lefthand': 'left hand',
+    'mixamorig:rightshoulder': 'right shoulder',
+    'mixamorig:rightarm': 'right upper arm',
+    'mixamorig:rightforearm': 'right forearm',
+    'mixamorig:righthand': 'right hand',
+    'mixamorig:leftupleg': 'left upper leg',
+    'mixamorig:leftleg': 'left lower leg',
+    'mixamorig:leftfoot': 'left foot',
+    'mixamorig:lefttoebase': 'left toe',
+    'mixamorig:rightupleg': 'right upper leg',
+    'mixamorig:rightleg': 'right lower leg',
+    'mixamorig:rightfoot': 'right foot',
+    'mixamorig:righttoebase': 'right toe',
+    # SMPL naming
+    'pelvis': 'pelvis',
+    'l_hip': 'left hip',
+    'r_hip': 'right hip',
+    'spine1': 'lower spine',
+    'l_knee': 'left knee',
+    'r_knee': 'right knee',
+    'spine2': 'upper spine',
+    'l_ankle': 'left ankle',
+    'r_ankle': 'right ankle',
+    'spine3': 'chest',
+    'l_foot': 'left foot',
+    'r_foot': 'right foot',
+    'neck': 'neck',
+    'l_collar': 'left collar',
+    'r_collar': 'right collar',
+    'head': 'head',
+    'l_shoulder': 'left shoulder',
+    'r_shoulder': 'right shoulder',
+    'l_elbow': 'left elbow',
+    'r_elbow': 'right elbow',
+    'l_wrist': 'left wrist',
+    'r_wrist': 'right wrist',
+    # Common animal naming
+    'hips': 'pelvis',
+    'spine': 'spine',
+    'chest': 'chest',
+    'leftforeleg': 'left fore leg',
+    'rightforeleg': 'right fore leg',
+    'lefthindleg': 'left hind leg',
+    'righthindleg': 'right hind leg',
+    'tail': 'tail',
+    'tail1': 'tail base',
+    'tail2': 'tail mid',
+    'tail3': 'tail tip',
+}
+
+
+def normalize_joint_name(name: str) -> str:
+    """Normalize joint name to a canonical human-readable form."""
+    key = name.lower().strip().replace(' ', '')
+    if key in JOINT_NAME_ALIASES:
+        return JOINT_NAME_ALIASES[key]
+
+    # Fallback: split camelCase and add spaces
+    import re
+    result = re.sub(r'([a-z])([A-Z])', r'\1 \2', name)
+    result = re.sub(r'[_:]', ' ', result)
+    return result.lower().strip()