Revert "add external GLB processor for bone renaming"

This reverts commit 5a054025c45371ec5fc98c4a7fc1e8ca49a799bd.

app.py

@@ -2,7 +2,7 @@ import shutil
 import subprocess
 import time
 from pathlib import Path
-from typing import Tuple, Optional
+from typing import Tuple
 
 import gradio as gr
 import lightning as L
@@ -280,53 +280,14 @@ def merge_results_python(source_file: str, target_file: str, output_file: str) -
     
     return str(output_path.resolve())
 
-def rename_bones_post_processing(input_file: str, config_file: str = "configs/skeleton/mixamo.yaml") -> str:
-    """
-    Post-processing step to rename bones in GLB files.
-    
-    Args:
-        input_file: Path to the input GLB file
-        config_file: Path to the skeleton configuration file
-        
-    Returns:
-        Path to the processed file (same as input if successful)
-    """
-    try:
-        from src.inference.bone_renamer import rename_bones_in_glb
-        
-        # Only process GLB files
-        if not str(input_file).lower().endswith('.glb'):
-            print(f"Skipping bone renaming for non-GLB file: {input_file}")
-            return input_file
-        
-        # Create output path (same directory, with _renamed suffix)
-        input_path = Path(input_file)
-        output_path = input_path.parent / f"{input_path.stem}_renamed{input_path.suffix}"
-        
-        # Rename bones
-        success = rename_bones_in_glb(str(input_file), str(output_path), config_file)
-        
-        if success:
-            print(f"Successfully renamed bones in {input_file} -> {output_path}")
-            return str(output_path)
-        else:
-            print(f"Failed to rename bones in {input_file}, keeping original")
-            return input_file
-            
-    except Exception as e:
-        print(f"Warning: Bone renaming failed: {e}")
-        print("Continuing with original file...")
-        return input_file
-
 @spaces.GPU()
-def main(input_file: str, seed: int = 12345, bone_renaming: str = "none") -> Tuple[str, list]:
+def main(input_file: str, seed: int = 12345) -> Tuple[str, list]:
     """
     Run the rigging pipeline based on selected mode.
     
     Args:
         input_file: Path to the input 3D model file
         seed: Random seed for reproducible results
-        bone_renaming: Bone renaming option ("none", "mixamo", "vroid")
         
     Returns:
         Tuple of (final_file_path, list_of_intermediate_files)
@@ -370,16 +331,6 @@ def main(input_file: str, seed: int = 12345, bone_renaming: str = "none") -> Tup
     run_inference_python(intermediate_skeleton_file, intermediate_skin_file, "skin")
     merge_results_python(intermediate_skin_file, input_file, final_skin_file)
     
-    # Step 3: Apply bone renaming if requested (post-processing)
-    if bone_renaming != "none":
-        config_file = f"configs/skeleton/{bone_renaming}.yaml"
-        if Path(config_file).exists():
-            print(f"Applying {bone_renaming} bone renaming as post-processing...")
-            final_skeleton_file = rename_bones_post_processing(str(final_skeleton_file), config_file)
-            final_skin_file = rename_bones_post_processing(str(final_skin_file), config_file)
-        else:
-            print(f"Warning: Configuration file {config_file} not found. Skipping bone renaming.")
-    
     final_file = str(final_skin_file)
     output_files = [str(final_skeleton_file), str(final_skin_file)]
 
@@ -420,13 +371,6 @@ def create_app():
                         )
                         random_btn = gr.Button("🔄 Random Seed", variant="secondary", scale=1)
                 
-                bone_renaming = gr.Dropdown(
-                    choices=["none", "mixamo", "vroid"],
-                    value="none",
-                    label="Bone Renaming",
-                    info="Choose bone naming convention (only works with GLB output, none = keep generic names)"
-                )
-                
                 pipeline_btn = gr.Button("🎯 Start Processing", variant="primary", size="lg")
             
             with gr.Column():
@@ -440,7 +384,7 @@ def create_app():
         
         pipeline_btn.click(
             fn=main,
-            inputs=[input_3d_model, seed, bone_renaming],
+            inputs=[input_3d_model, seed],
             outputs=[pipeline_skeleton_out, files_to_download]
         )
         

src/inference/bone_renamer.py

@@ -1,252 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple script to rename bones in GLB/GLTF files by directly manipulating the JSON structure.
-This approach doesn't require Blender or complex 3D libraries.
-"""
-
-import json
-import yaml
-import gzip
-import struct
-from pathlib import Path
-import logging
-from typing import Dict, List, Optional
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class GLBProcessor:
-    def __init__(self, config_path: str = "configs/skeleton/mixamo.yaml"):
-        """Initialize with skeleton configuration."""
-        self.bone_names = self._load_bone_config(config_path)
-        
-    def _load_bone_config(self, config_path: str) -> List[str]:
-        """Load bone names from configuration."""
-        with open(config_path, 'r') as f:
-            config = yaml.safe_load(f)
-        
-        bone_names = []
-        parts_order = config.get('parts_order', [])
-        
-        for part in parts_order:
-            if part in config.get('parts', {}):
-                bone_names.extend(config['parts'][part])
-        
-        logger.info(f"Loaded {len(bone_names)} bone names from {config_path}")
-        return bone_names
-    
-    def read_glb(self, filepath: str) -> tuple:
-        """Read GLB file and return JSON and binary data."""
-        with open(filepath, 'rb') as f:
-            # Read GLB header
-            magic = f.read(4)
-            if magic != b'glTF':
-                raise ValueError("Not a valid GLB file")
-            
-            version = struct.unpack('<I', f.read(4))[0]
-            length = struct.unpack('<I', f.read(4))[0]
-            
-            # Read JSON chunk
-            json_length = struct.unpack('<I', f.read(4))[0]
-            json_type = f.read(4)
-            if json_type != b'JSON':
-                raise ValueError("Invalid JSON chunk")
-            
-            json_data = f.read(json_length)
-            gltf_json = json.loads(json_data.decode('utf-8'))
-            
-            # Read binary chunk if present
-            binary_data = None
-            if f.tell() < length:
-                binary_length = struct.unpack('<I', f.read(4))[0]
-                binary_type = f.read(4)
-                if binary_type == b'BIN\x00':
-                    binary_data = f.read(binary_length)
-            
-            return gltf_json, binary_data
-    
-    def write_glb(self, filepath: str, gltf_json: dict, binary_data: Optional[bytes] = None):
-        """Write GLB file with JSON and binary data."""
-        json_str = json.dumps(gltf_json, separators=(',', ':'))
-        json_bytes = json_str.encode('utf-8')
-        
-        # Pad JSON to 4-byte boundary
-        json_padding = (4 - (len(json_bytes) % 4)) % 4
-        json_bytes += b' ' * json_padding
-        
-        # Calculate total length
-        total_length = 12 + 8 + len(json_bytes)  # header + JSON chunk header + JSON data
-        if binary_data:
-            binary_padding = (4 - (len(binary_data) % 4)) % 4
-            binary_data += b'\x00' * binary_padding
-            total_length += 8 + len(binary_data)  # binary chunk header + binary data
-        
-        with open(filepath, 'wb') as f:
-            # Write GLB header
-            f.write(b'glTF')
-            f.write(struct.pack('<I', 2))  # version 2
-            f.write(struct.pack('<I', total_length))
-            
-            # Write JSON chunk
-            f.write(struct.pack('<I', len(json_bytes)))
-            f.write(b'JSON')
-            f.write(json_bytes)
-            
-            # Write binary chunk if present
-            if binary_data:
-                f.write(struct.pack('<I', len(binary_data)))
-                f.write(b'BIN\x00')
-                f.write(binary_data)
-    
-    def rename_bones(self, gltf_json: dict, bone_mapping: Dict[str, str]) -> dict:
-        """Rename bones in GLTF JSON structure."""
-        # Create a copy to avoid modifying the original
-        new_gltf = json.loads(json.dumps(gltf_json))
-        
-        # Rename bones in nodes
-        if 'nodes' in new_gltf:
-            for node in new_gltf['nodes']:
-                if 'name' in node and node['name'] in bone_mapping:
-                    old_name = node['name']
-                    new_name = bone_mapping[old_name]
-                    node['name'] = new_name
-                    logger.debug(f"Renamed node: {old_name} -> {new_name}")
-        
-        # Rename bones in skins
-        if 'skins' in new_gltf:
-            for skin in new_gltf['skins']:
-                if 'joints' in skin:
-                    for i, joint_index in enumerate(skin['joints']):
-                        if joint_index < len(new_gltf.get('nodes', [])):
-                            node = new_gltf['nodes'][joint_index]
-                            if 'name' in node and node['name'] in bone_mapping:
-                                old_name = node['name']
-                                new_name = bone_mapping[old_name]
-                                node['name'] = new_name
-                                logger.debug(f"Renamed skin joint: {old_name} -> {new_name}")
-        
-        # Rename bones in animations
-        if 'animations' in new_gltf:
-            for anim in new_gltf['animations']:
-                if 'channels' in anim:
-                    for channel in anim['channels']:
-                        if 'target' in channel and 'node' in channel['target']:
-                            node_index = channel['target']['node']
-                            if node_index < len(new_gltf.get('nodes', [])):
-                                node = new_gltf['nodes'][node_index]
-                                if 'name' in node and node['name'] in bone_mapping:
-                                    old_name = node['name']
-                                    new_name = bone_mapping[old_name]
-                                    node['name'] = new_name
-                                    logger.debug(f"Renamed animation target: {old_name} -> {new_name}")
-        
-        return new_gltf
-    
-    def process_glb(self, input_path: str, output_path: str, bone_mapping: Optional[Dict[str, str]] = None) -> bool:
-        """Process GLB file to rename bones."""
-        try:
-            # Read GLB file
-            logger.info(f"Reading GLB file: {input_path}")
-            gltf_json, binary_data = self.read_glb(input_path)
-            
-            # Extract current bone names
-            current_bones = []
-            if 'nodes' in gltf_json:
-                for node in gltf_json['nodes']:
-                    if 'name' in node:
-                        current_bones.append(node['name'])
-            
-            logger.info(f"Found {len(current_bones)} nodes in GLB file")
-            
-            # Create bone mapping if not provided
-            if bone_mapping is None:
-                bone_mapping = self._create_bone_mapping(current_bones)
-            
-            # Rename bones
-            logger.info("Renaming bones...")
-            new_gltf = self.rename_bones(gltf_json, bone_mapping)
-            
-            # Write updated GLB file
-            logger.info(f"Writing updated GLB file: {output_path}")
-            self.write_glb(output_path, new_gltf, binary_data)
-            
-            logger.info("Bone renaming completed successfully!")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error processing GLB file: {e}")
-            import traceback
-            logger.error(f"Traceback: {traceback.format_exc()}")
-            return False
-    
-    def _create_bone_mapping(self, current_bones: List[str]) -> Dict[str, str]:
-        """Create mapping from current bone names to standard names."""
-        bone_mapping = {}
-        sorted_current_bones = sorted(current_bones)
-        
-        for i, current_name in enumerate(sorted_current_bones):
-            if i < len(self.bone_names):
-                standard_name = self.bone_names[i]
-                bone_mapping[current_name] = standard_name
-                logger.info(f"Mapping {current_name} -> {standard_name}")
-            else:
-                bone_mapping[current_name] = current_name
-                logger.warning(f"No standard name for {current_name}, keeping original")
-        
-        return bone_mapping
-
-
-def rename_bones_in_glb(input_file: str, output_file: str, config_file: str = "configs/skeleton/mixamo.yaml") -> bool:
-    """
-    Convenience function to rename bones in a GLB file.
-    
-    Args:
-        input_file: Path to input GLB file
-        output_file: Path to output GLB file
-        config_file: Path to skeleton configuration file
-        
-    Returns:
-        True if successful, False otherwise
-    """
-    processor = GLBProcessor(config_file)
-    return processor.process_glb(input_file, output_file)
-
-
-if __name__ == "__main__":
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Rename bones in GLB file to standard names")
-    parser.add_argument("input", help="Input GLB file path")
-    parser.add_argument("output", help="Output GLB file path")
-    parser.add_argument("--config", default="configs/skeleton/mixamo.yaml", 
-                       help="Path to skeleton configuration file")
-    parser.add_argument("--mapping", help="JSON file with custom bone name mapping")
-    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose logging")
-    
-    args = parser.parse_args()
-    
-    if args.verbose:
-        logging.getLogger().setLevel(logging.DEBUG)
-    
-    # Initialize processor
-    processor = GLBProcessor(args.config)
-    
-    # Load custom mapping if provided
-    bone_mapping = None
-    if args.mapping:
-        try:
-            with open(args.mapping, 'r') as f:
-                bone_mapping = json.load(f)
-            logger.info(f"Loaded custom bone mapping from: {args.mapping}")
-        except Exception as e:
-            logger.error(f"Failed to load custom mapping: {e}")
-            exit(1)
-    
-    # Process the GLB file
-    success = processor.process_glb(args.input, args.output, bone_mapping)
-    
-    if success:
-        exit(0)
-    else:
-        exit(1)