Upload src/data/skeleton_graph.py with huggingface_hub

src/data/skeleton_graph.py

@@ -101,46 +101,109 @@ class SkeletonGraph:
         return dist.astype(np.float32)
 
     def _infer_side_tags(self) -> list[str]:
-        """Infer left/right/center from joint names."""
+        """Infer left/right/center from joint names.
+
+        Handles diverse naming conventions:
+          - 'left'/'right' anywhere: LeftArm, left_hip, RightFoot
+          - '_L'/'_R' suffix: Shoulder_L, UpperArm_R
+          - '_l_'/'_r_' infix: Bip01_L_Thigh, BN_Tai_R_01
+          - 'L'/'R' prefix before uppercase: LHipJoint, RThumb
+          - '_L'/'_R' suffix before numbers: Leg_L_30_
+        """
+        import re
         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')
+            n = name  # preserve case for regex
+            nl = name.lower()
+
+            side = 'center'
+            # Priority 1: explicit 'left'/'right'
+            if 'left' in nl or 'lft' in nl:
+                side = 'left'
+            elif 'right' in nl or 'rgt' in nl:
+                side = 'right'
+            # Priority 2: _L / _R suffix (with optional trailing digits/underscores)
+            elif re.search(r'[_]L(?:[_\d]|$)', n):
+                side = 'left'
+            elif re.search(r'[_]R(?:[_\d]|$)', n):
+                side = 'right'
+            # Priority 3: _l_ / _r_ infix
+            elif '_l_' in nl or nl.startswith('l_'):
+                side = 'left'
+            elif '_r_' in nl or nl.startswith('r_'):
+                side = 'right'
+            # Priority 4: L/R prefix before uppercase (LHipJoint, RThumb)
+            elif re.match(r'^L[A-Z]', n):
+                side = 'left'
+            elif re.match(r'^R[A-Z]', n):
+                side = 'right'
+            # Priority 5: prefix_L / prefix_R patterns
+            # NPC_LLeg1, NPC_RArm1, BN_LWing01, BN_RWing01, ArmL, ArmR, LegR, etc.
+            elif re.search(r'(?:NPC|BN|Bn)_L[A-Z]', n):
+                side = 'left'
+            elif re.search(r'(?:NPC|BN|Bn)_R[A-Z]', n):
+                side = 'right'
+            # Priority 6: {Word}L{Upper} or {Word}R{Upper} pattern
+            # Catches: ArmLClaw, ElkLFemur, ElkRScapula, LegR_01_, etc.
+            elif re.search(r'[a-z0-9]L[A-Z_]', n) or re.search(r'[a-z0-9]L$', n):
+                side = 'left'
+            elif re.search(r'[a-z0-9]R[A-Z_]', n) or re.search(r'[a-z0-9]R$', n):
+                side = 'right'
+
+            tags.append(side)
 
         return tags
 
     def _find_symmetry_pairs(self) -> list[tuple[int, int]]:
-        """Find symmetric joint pairs based on naming conventions."""
+        """Find symmetric joint pairs based on naming conventions.
+
+        Handles: Left↔Right, _L↔_R, _l_↔_r_, L-prefix↔R-prefix.
+        """
+        import re
         pairs = []
         used = set()
 
+        # Build replacement rules: (pattern, left_repl, right_repl)
+        swap_rules = [
+            # Full words
+            (r'(?i)left', 'left', 'right'),
+            (r'(?i)right', 'right', 'left'),
+            # _L / _R suffix (preserving case/context)
+            (r'_L(?=[_\d]|$)', '_L', '_R'),
+            (r'_R(?=[_\d]|$)', '_R', '_L'),
+            # _l_ / _r_ infix
+            (r'_l_', '_l_', '_r_'),
+            (r'_r_', '_r_', '_l_'),
+            # L/R prefix before uppercase
+            (r'^L(?=[A-Z])', 'L', 'R'),
+            (r'^R(?=[A-Z])', 'R', 'L'),
+            # BN_L/BN_R prefix (BN_LWing01 ↔ BN_RWing01)
+            (r'BN_L(?=[A-Z])', 'BN_L', 'BN_R'),
+            (r'BN_R(?=[A-Z])', 'BN_R', 'BN_L'),
+            (r'Bn_L(?=[A-Z])', 'Bn_L', 'Bn_R'),
+            (r'Bn_R(?=[A-Z])', 'Bn_R', 'Bn_L'),
+            # NPC_L/NPC_R prefix (NPC_LLeg1 ↔ NPC_RLeg1)
+            (r'NPC_L(?=[A-Z_])', 'NPC_L', 'NPC_R'),
+            (r'NPC_R(?=[A-Z_])', 'NPC_R', 'NPC_L'),
+            # {word}L{Upper} ↔ {word}R{Upper} (ElkLFemur↔ElkRFemur, ArmL↔ArmR)
+            (r'(?<=[a-z0-9])L(?=[A-Z_]|$)', 'L', 'R'),
+            (r'(?<=[a-z0-9])R(?=[A-Z_]|$)', 'R', 'L'),
+        ]
+
         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 pattern, from_str, to_str in swap_rules:
+                if re.search(pattern, name_i):
+                    mirror_name = re.sub(pattern, to_str, name_i, count=1)
+                    break
+
+            if mirror_name and mirror_name != name_i:
+                mirror_lower = mirror_name.lower()
                 for j, name_j in enumerate(self.joint_names):
-                    if j != i and j not in used and name_j.lower() == mirror_name:
+                    if j != i and j not in used and name_j.lower() == mirror_lower:
                         pairs.append((i, j))
                         used.add(i)
                         used.add(j)