Update app.py

app.py

@@ -2,43 +2,22 @@ import os
 import time
 import glob
 import json
-import yaml
-import torch
+import numpy as np
 import trimesh
 import argparse
-import mesh2sdf.core
-import numpy as np
-import skimage.measure
-import seaborn as sns
 from scipy.spatial.transform import Rotation
-from mesh_to_sdf import get_surface_point_cloud
-from accelerate.utils import set_seed
-from accelerate import Accelerator
-from huggingface_hub.file_download import hf_hub_download
-from huggingface_hub import list_repo_files
-
-# Animation-related imports
-import trimesh.transformations as tf
+import PIL.Image
+from PIL import Image
 import math
-import pyglet
-
-from primitive_anything.utils import path_mkdir, count_parameters
-from primitive_anything.utils.logger import print_log
+import trimesh.transformations as tf
+from trimesh.exchange.gltf import export_glb
 
 os.environ['PYOPENGL_PLATFORM'] = 'egl'
 
-import spaces
-
-repo_id = "hyz317/PrimitiveAnything"
-all_files = list_repo_files(repo_id, revision="main")
-for file in all_files:
-    if os.path.exists(file):
-        continue
-    hf_hub_download(repo_id, file, local_dir="./ckpt")
-hf_hub_download("Maikou/Michelangelo", "checkpoints/aligned_shape_latents/shapevae-256.ckpt", local_dir="./ckpt")
+import gradio as gr
 
 def parse_args():
-    parser = argparse.ArgumentParser(description='Process 3D model files with animation')
+    parser = argparse.ArgumentParser(description='Create animations for 3D models')
     
     parser.add_argument(
         '--input',
@@ -58,7 +37,7 @@ def parse_args():
         '--animation_type',
         type=str,
         default='rotate',
-        choices=['rotate', 'float', 'explode', 'assemble'],
+        choices=['rotate', 'float', 'explode', 'assemble', 'pulse', 'swing'],
         help='Type of animation to apply'
     )
     
@@ -93,595 +72,411 @@ os.makedirs(LOG_PATH, exist_ok=True)
 
 print(f"Output directory: {LOG_PATH}")
 
-CODE_SHAPE = {
-    0: 'SM_GR_BS_CubeBevel_001.ply',
-    1: 'SM_GR_BS_SphereSharp_001.ply',
-    2: 'SM_GR_BS_CylinderSharp_001.ply',
-}
-
-shapename_map = {
-    'SM_GR_BS_CubeBevel_001.ply': 1101002001034001,
-    'SM_GR_BS_SphereSharp_001.ply': 1101002001034010,
-    'SM_GR_BS_CylinderSharp_001.ply': 1101002001034002,
-}
-
-#### config
-bs_dir = 'data/basic_shapes_norm'
-config_path = './configs/infer.yml'
-AR_checkpoint_path = './ckpt/mesh-transformer.ckpt.60.pt'
-temperature= 0.0
-#### init model
-mesh_bs = {}
-for bs_path in glob.glob(os.path.join(bs_dir, '*.ply')):
-    bs_name = os.path.basename(bs_path)
-    bs = trimesh.load(bs_path)
-    bs.visual.uv = np.clip(bs.visual.uv, 0, 1)
-    bs.visual = bs.visual.to_color()
-    mesh_bs[bs_name] = bs
-
-def create_model(cfg_model):
-    kwargs = cfg_model
-    name = kwargs.pop('name')
-    model = get_model(name)(**kwargs)
-    print_log("Model '{}' init: nb_params={:,}, kwargs={}".format(name, count_parameters(model), kwargs))
-    return model
-
-from primitive_anything.primitive_transformer import PrimitiveTransformerDiscrete
-def get_model(name):
-    return {
-        'discrete': PrimitiveTransformerDiscrete,
-    }[name]
-
-with open(config_path, mode='r') as fp:
-    AR_train_cfg = yaml.load(fp, Loader=yaml.FullLoader)
-
-AR_checkpoint = torch.load(AR_checkpoint_path)
-
-transformer = create_model(AR_train_cfg['model'])
-transformer.load_state_dict(AR_checkpoint)
-
-device = torch.device('cuda')
-accelerator = Accelerator(
-    mixed_precision='fp16',
-)
-transformer = accelerator.prepare(transformer)
-transformer.eval()
-transformer.bs_pc = transformer.bs_pc.cuda()
-transformer.rotation_matrix_align_coord = transformer.rotation_matrix_align_coord.cuda()
-print('model loaded to device')
-
-
-def sample_surface_points(mesh, number_of_points=500000, surface_point_method='scan', sign_method='normal',
-                          scan_count=100, scan_resolution=400, sample_point_count=10000000, return_gradients=False,
-                          return_surface_pc_normals=False, normalized=False):
-    sample_start = time.time()
-    if surface_point_method == 'sample' and sign_method == 'depth':
-        print("Incompatible methods for sampling points and determining sign, using sign_method='normal' instead.")
-        sign_method = 'normal'
-
-    surface_start = time.time()
-    bound_radius = 1 if normalized else None
-    surface_point_cloud = get_surface_point_cloud(mesh, surface_point_method, bound_radius, scan_count, scan_resolution,
-                                                  sample_point_count,
-                                                  calculate_normals=sign_method == 'normal' or return_gradients)
-
-    surface_end = time.time()
-    print('surface point cloud time cost :', surface_end - surface_start)
-
-    normal_start = time.time()
-    if return_surface_pc_normals:
-        rng = np.random.default_rng()
-        assert surface_point_cloud.points.shape[0] == surface_point_cloud.normals.shape[0]
-        indices = rng.choice(surface_point_cloud.points.shape[0], number_of_points, replace=True)
-        points = surface_point_cloud.points[indices]
-        normals = surface_point_cloud.normals[indices]
-        surface_points = np.concatenate([points, normals], axis=-1)
-    else:
-        surface_points = surface_point_cloud.get_random_surface_points(number_of_points, use_scans=True)
-    normal_end = time.time()
-    print('normal time cost :', normal_end - normal_start)
-    sample_end = time.time()
-    print('sample surface point time cost :', sample_end - sample_start)
-    return surface_points
-
-
-def normalize_vertices(vertices, scale=0.9):
-    bbmin, bbmax = vertices.min(0), vertices.max(0)
-    center = (bbmin + bbmax) * 0.5
-    scale = 2.0 * scale / (bbmax - bbmin).max()
-    vertices = (vertices - center) * scale
-    return vertices, center, scale
-
-
-def export_to_watertight(normalized_mesh, octree_depth: int = 7):
-    """
-        Convert the non-watertight mesh to watertight.
-
-        Args:
-            input_path (str): normalized path
-            octree_depth (int):
-
-        Returns:
-            mesh(trimesh.Trimesh): watertight mesh
-
-        """
-    size = 2 ** octree_depth
-    level = 2 / size
-
-    scaled_vertices, to_orig_center, to_orig_scale = normalize_vertices(normalized_mesh.vertices)
-    sdf = mesh2sdf.core.compute(scaled_vertices, normalized_mesh.faces, size=size)
-    vertices, faces, normals, _ = skimage.measure.marching_cubes(np.abs(sdf), level)
-
-    # watertight mesh
-    vertices = vertices / size * 2 - 1 # -1 to 1
-    vertices = vertices / to_orig_scale + to_orig_center
-    mesh = trimesh.Trimesh(vertices, faces, normals=normals)
-
-    return mesh
-
-
-def process_mesh_to_surface_pc(mesh_list, marching_cubes=False, dilated_offset=0.0, sample_num=10000):
-    # mesh_list : list of trimesh
-    pc_normal_list = []
-    return_mesh_list = []
-    for mesh in mesh_list:
-        if marching_cubes:
-            mesh = export_to_watertight(mesh)
-            print("MC over!")
-        if dilated_offset > 0:
-            new_vertices = mesh.vertices + mesh.vertex_normals * dilated_offset
-            mesh.vertices = new_vertices
-            print("dilate over!")
-
-        mesh.merge_vertices()
-        mesh.update_faces(mesh.unique_faces())
-        mesh.fix_normals()
-
-        return_mesh_list.append(mesh)
-
-        pc_normal = np.asarray(sample_surface_points(mesh, sample_num, return_surface_pc_normals=True))
-        pc_normal_list.append(pc_normal)
-        print("process mesh success")
-    return pc_normal_list, return_mesh_list
-
-
-####    utils
-def euler_to_quat(euler):
-    return Rotation.from_euler('XYZ', euler, degrees=True).as_quat()
-
-def SRT_quat_to_matrix(scale, quat, translation):
-    rotation_matrix = Rotation.from_quat(quat).as_matrix()
-    transform_matrix = np.eye(4)
-    transform_matrix[:3, :3] = rotation_matrix * scale
-    transform_matrix[:3, 3] = translation
-    return transform_matrix
-
+def normalize_mesh(mesh):
+    """Normalize mesh to fit in a unit cube centered at origin"""
+    vertices = mesh.vertices
+    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
+    center = (bounds[0] + bounds[1]) / 2
+    scale = 1.0 / (bounds[1] - bounds[0]).max()
+    
+    # Create a copy to avoid modifying the original
+    normalized_mesh = mesh.copy()
+    normalized_mesh.vertices = (vertices - center) * scale
+    
+    return normalized_mesh, center, scale
 
-# Animation Functions
-def create_rotation_animation(primitive_list, duration=3.0, fps=30):
-    """Create a rotation animation for each primitive"""
+def create_rotation_animation(mesh, duration=3.0, fps=30):
+    """Create a rotation animation around the Y axis"""
     num_frames = int(duration * fps)
     frames = []
     
+    # Normalize the mesh for consistent animation
+    mesh, original_center, original_scale = normalize_mesh(mesh)
+    
     for frame_idx in range(num_frames):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
         angle = t * 2 * math.pi  # Full rotation
         
-        frame_scene = trimesh.Scene()
-        for idx, (primitive, color) in enumerate(primitive_list):
-            # Create a copy of the primitive to animate
-            animated_primitive = primitive.copy()
-            
-            # Apply rotation around Y axis
-            rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0], animated_primitive.centroid)
-            animated_primitive.apply_transform(rotation_matrix)
-            
-            # Add to scene with original color
-            frame_scene.add_geometry(animated_primitive, node_name=f'primitive_{idx}')
+        # Create a copy of the mesh to animate
+        animated_mesh = mesh.copy()
         
-        frames.append(frame_scene)
+        # Apply rotation around Y axis
+        rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0])
+        animated_mesh.apply_transform(rotation_matrix)
+        
+        # Add to frames
+        frames.append(animated_mesh)
     
     return frames
 
-def create_float_animation(primitive_list, duration=3.0, fps=30, amplitude=0.1):
-    """Create a floating animation where primitives move up and down"""
+def create_float_animation(mesh, duration=3.0, fps=30, amplitude=0.2):
+    """Create a floating animation where the mesh moves up and down"""
     num_frames = int(duration * fps)
     frames = []
     
+    # Normalize the mesh for consistent animation
+    mesh, original_center, original_scale = normalize_mesh(mesh)
+    
     for frame_idx in range(num_frames):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-        frame_scene = trimesh.Scene()
         
-        for idx, (primitive, color) in enumerate(primitive_list):
-            # Create a copy of the primitive to animate
-            animated_primitive = primitive.copy()
-            
-            # Apply floating motion (sinusoidal)
-            phase_offset = 2 * math.pi * (idx / len(primitive_list))  # Different phase for each primitive
-            y_offset = amplitude * math.sin(2 * math.pi * t + phase_offset)
-            
-            translation_matrix = tf.translation_matrix([0, y_offset, 0])
-            animated_primitive.apply_transform(translation_matrix)
-            
-            # Add to scene with original color
-            frame_scene.add_geometry(animated_primitive, node_name=f'primitive_{idx}')
+        # Create a copy of the mesh to animate
+        animated_mesh = mesh.copy()
         
-        frames.append(frame_scene)
+        # Apply floating motion (sinusoidal)
+        y_offset = amplitude * math.sin(2 * math.pi * t)
+        translation_matrix = tf.translation_matrix([0, y_offset, 0])
+        animated_mesh.apply_transform(translation_matrix)
+        
+        # Add to frames
+        frames.append(animated_mesh)
     
     return frames
 
-def create_explode_animation(primitive_list, duration=3.0, fps=30, max_distance=0.5):
-    """Create an explode animation where primitives move outward from center"""
+def create_explode_animation(mesh, duration=3.0, fps=30):
+    """Create an explode animation where parts of the mesh move outward"""
     num_frames = int(duration * fps)
     frames = []
     
-    # Calculate center of the model
-    all_vertices = np.vstack([p.vertices for p, _ in primitive_list])
-    center = np.mean(all_vertices, axis=0)
+    # Normalize the mesh for consistent animation
+    mesh, original_center, original_scale = normalize_mesh(mesh)
+    
+    # Split the mesh into components
+    # If the mesh can't be split, we'll just move vertices outward
+    try:
+        components = mesh.split(only_watertight=False)
+        if len(components) <= 1:
+            raise ValueError("Mesh cannot be split into components")
+    except:
+        # If splitting fails, work with the original mesh
+        components = None
     
     for frame_idx in range(num_frames):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-        frame_scene = trimesh.Scene()
         
-        for idx, (primitive, color) in enumerate(primitive_list):
-            # Create a copy of the primitive to animate
-            animated_primitive = primitive.copy()
+        if components:
+            # Create a scene to hold all components
+            scene = trimesh.Scene()
             
-            # Calculate direction from center to primitive centroid
-            primitive_center = primitive.centroid
-            direction = primitive_center - center
-            if np.linalg.norm(direction) < 1e-10:
-                # If primitive is at center, choose random direction
-                direction = np.random.rand(3) - 0.5
+            # Move each component outward from center
+            for component in components:
+                # Create a copy of the component
+                animated_component = component.copy()
+                
+                # Calculate direction from center to component centroid
+                direction = animated_component.centroid
+                if np.linalg.norm(direction) < 1e-10:
+                    # If component is at center, choose random direction
+                    direction = np.random.rand(3) - 0.5
+                
+                direction = direction / np.linalg.norm(direction)
                 
-            direction = direction / np.linalg.norm(direction)
+                # Apply explosion movement
+                translation = direction * t * 0.5  # Scale factor for explosion
+                translation_matrix = tf.translation_matrix(translation)
+                animated_component.apply_transform(translation_matrix)
+                
+                # Add to scene
+                scene.add_geometry(animated_component)
             
-            # Apply explosion movement
-            translation = direction * t * max_distance
-            translation_matrix = tf.translation_matrix(translation)
-            animated_primitive.apply_transform(translation_matrix)
+            # Convert scene to mesh (approximation)
+            animated_mesh = trimesh.util.concatenate(scene.dump())
+        else:
+            # Work with vertices directly if components approach failed
+            animated_mesh = mesh.copy()
+            vertices = animated_mesh.vertices.copy()
             
-            # Add to scene with original color
-            frame_scene.add_geometry(animated_primitive, node_name=f'primitive_{idx}')
+            # Calculate directions from center (0,0,0) to each vertex
+            directions = vertices.copy()
+            norms = np.linalg.norm(directions, axis=1, keepdims=True)
+            mask = norms > 1e-10
+            directions[mask] = directions[mask] / norms[mask]
+            directions[~mask] = np.random.rand(np.sum(~mask), 3) - 0.5
+            
+            # Apply explosion factor
+            vertices += directions * t * 0.3
+            animated_mesh.vertices = vertices
         
-        frames.append(frame_scene)
+        # Add to frames
+        frames.append(animated_mesh)
     
     return frames
 
-def create_assemble_animation(primitive_list, duration=3.0, fps=30, start_distance=1.0):
-    """Create an assembly animation where primitives move inward to form the model"""
+def create_assemble_animation(mesh, duration=3.0, fps=30):
+    """Create an assembly animation (reverse of explode)"""
+    # Get explode animation and reverse it
+    explode_frames = create_explode_animation(mesh, duration, fps)
+    return list(reversed(explode_frames))
+
+def create_pulse_animation(mesh, duration=3.0, fps=30, min_scale=0.8, max_scale=1.2):
+    """Create a pulsing animation where the mesh scales up and down"""
     num_frames = int(duration * fps)
     frames = []
     
-    # Calculate center of the model
-    all_vertices = np.vstack([p.vertices for p, _ in primitive_list])
-    center = np.mean(all_vertices, axis=0)
-    
-    # Store original positions
-    original_primitives = [(p.copy(), c) for p, c in primitive_list]
+    # Normalize the mesh for consistent animation
+    mesh, original_center, original_scale = normalize_mesh(mesh)
     
     for frame_idx in range(num_frames):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-        frame_scene = trimesh.Scene()
         
-        for idx, ((original_primitive, color), (primitive, _)) in enumerate(zip(original_primitives, primitive_list)):
-            # Create a copy of the primitive to animate
-            animated_primitive = original_primitive.copy()
-            
-            # Calculate direction from center to primitive centroid
-            primitive_center = primitive.centroid
-            direction = primitive_center - center
-            if np.linalg.norm(direction) < 1e-10:
-                # If primitive is at center, choose random direction
-                direction = np.random.rand(3) - 0.5
-                
-            direction = direction / np.linalg.norm(direction)
-            
-            # Apply assembly movement (1.0 - t for reverse of explosion)
-            translation = direction * (1.0 - t) * start_distance
-            translation_matrix = tf.translation_matrix(translation)
-            animated_primitive.apply_transform(translation_matrix)
-            
-            # Add to scene with original color
-            frame_scene.add_geometry(animated_primitive, node_name=f'primitive_{idx}')
+        # Create a copy of the mesh to animate
+        animated_mesh = mesh.copy()
+        
+        # Apply pulsing motion (sinusoidal scale)
+        scale_factor = min_scale + (max_scale - min_scale) * (0.5 + 0.5 * math.sin(2 * math.pi * t))
+        scale_matrix = tf.scale_matrix(scale_factor)
+        animated_mesh.apply_transform(scale_matrix)
         
-        frames.append(frame_scene)
+        # Add to frames
+        frames.append(animated_mesh)
     
     return frames
 
-def generate_animated_glb(primitive_list, animation_type='rotate', duration=3.0, fps=30, output_path="animated_model.glb"):
-    """Generate animated GLB file with primitives"""
-    if animation_type == 'rotate':
-        frames = create_rotation_animation(primitive_list, duration, fps)
-    elif animation_type == 'float':
-        frames = create_float_animation(primitive_list, duration, fps)
-    elif animation_type == 'explode':
-        frames = create_explode_animation(primitive_list, duration, fps)
-    elif animation_type == 'assemble':
-        frames = create_assemble_animation(primitive_list, duration, fps)
-    else:
-        raise ValueError(f"Unknown animation type: {animation_type}")
+def create_swing_animation(mesh, duration=3.0, fps=30, max_angle=math.pi/6):
+    """Create a swinging animation where the mesh rotates back and forth"""
+    num_frames = int(duration * fps)
+    frames = []
     
-    # Export animation frames to GLB
-    # For simplicity, we'll export the first frame and last frame
-    # In a production environment, you would use a proper animation exporter
-    first_frame = frames[0]
-    first_frame.export(output_path)
+    # Normalize the mesh for consistent animation
+    mesh, original_center, original_scale = normalize_mesh(mesh)
     
-    # Also create a GIF for preview
-    gif_path = output_path.replace('.glb', '.gif')
-    try:
-        # Simple gif export using pyglet
-        gif_frames = []
-        for frame in frames:
-            img = frame.save_image(resolution=[640, 480])
-            gif_frames.append(img)
+    for frame_idx in range(num_frames):
+        t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
+        
+        # Create a copy of the mesh to animate
+        animated_mesh = mesh.copy()
         
-        # Use PIL to save as GIF
-        from PIL import Image
+        # Apply swinging motion (sinusoidal rotation)
+        angle = max_angle * math.sin(2 * math.pi * t)
+        rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0])
+        animated_mesh.apply_transform(rotation_matrix)
+        
+        # Add to frames
+        frames.append(animated_mesh)
+    
+    return frames
+
+def generate_gif_from_frames(frames, output_path, fps=30, resolution=(640, 480), background_color=(255, 255, 255, 255)):
+    """Generate a GIF from animation frames"""
+    gif_frames = []
+    
+    for frame in frames:
+        # Create a scene with the frame
+        scene = trimesh.Scene(frame)
+        
+        # Set camera and rendering parameters
+        try:
+            # Try to get a good view of the object
+            scene.camera_transform = scene.camera_transform
+        except:
+            # If that fails, use a default camera position
+            scene.camera_transform = tf.translation_matrix([0, 0, 2])
+        
+        # Render the frame
+        try:
+            img = scene.save_image(resolution=resolution, background=background_color)
+            gif_frames.append(Image.open(img))
+        except Exception as e:
+            print(f"Error rendering frame: {str(e)}")
+            # Create a blank image if rendering fails
+            gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
+    
+    # Save as GIF
+    if gif_frames:
         gif_frames[0].save(
-            gif_path,
+            output_path,
             save_all=True,
             append_images=gif_frames[1:],
             optimize=False,
             duration=int(1000 / fps),
             loop=0
         )
+        return output_path
+    else:
+        return None
+
+def create_animation_mesh(input_mesh_path, animation_type='rotate', duration=3.0, fps=30):
+    """Create animation from input mesh based on animation type"""
+    # Load the mesh
+    try:
+        mesh = trimesh.load(input_mesh_path)
     except Exception as e:
-        print(f"Error creating GIF: {str(e)}")
+        print(f"Error loading mesh: {str(e)}")
+        return None, None
     
-    return output_path, gif_path
-
-
-def write_output(primitives, name, animation_type='rotate', duration=3.0, fps=30):
-    out_json = {}
-
-    new_group = []
-    model_scene = trimesh.Scene()
-    primitive_list = []
-    
-    color_map = sns.color_palette("hls", primitives['type_code'].squeeze().shape[0])
-    color_map = (np.array(color_map) * 255).astype("uint8")
-    
-    for idx, (scale, rotation, translation, type_code) in enumerate(zip(
-        primitives['scale'].squeeze().cpu().numpy(),
-        primitives['rotation'].squeeze().cpu().numpy(),
-        primitives['translation'].squeeze().cpu().numpy(),
-        primitives['type_code'].squeeze().cpu().numpy()
-    )):
-        if type_code == -1:
-            break
-        bs_name = CODE_SHAPE[type_code]
-        new_block = {}
-        new_block['type_id'] = shapename_map[bs_name]
-        new_block['data'] = {}
-        new_block['data']['location'] = translation.tolist()
-        new_block['data']['rotation'] = euler_to_quat(rotation).tolist()
-        new_block['data']['scale'] = scale.tolist()
-        new_group.append(new_block)
-
-        trans = SRT_quat_to_matrix(scale, euler_to_quat(rotation), translation)
-        bs = mesh_bs[bs_name].copy().apply_transform(trans)
-        new_vertex_colors = np.repeat(color_map[idx:idx+1], bs.visual.vertex_colors.shape[0], axis=0)
-        bs.visual.vertex_colors[:, :3] = new_vertex_colors
-        vertices = bs.vertices.copy()
-        vertices[:, 1] = bs.vertices[:, 2]
-        vertices[:, 2] = -bs.vertices[:, 1]
-        bs.vertices = vertices
-        
-        # Add to primitive list for animation
-        primitive_list.append((bs, color_map[idx]))
-        model_scene.add_geometry(bs)
+    # Generate animation frames based on animation type
+    if animation_type == 'rotate':
+        frames = create_rotation_animation(mesh, duration, fps)
+    elif animation_type == 'float':
+        frames = create_float_animation(mesh, duration, fps)
+    elif animation_type == 'explode':
+        frames = create_explode_animation(mesh, duration, fps)
+    elif animation_type == 'assemble':
+        frames = create_assemble_animation(mesh, duration, fps)
+    elif animation_type == 'pulse':
+        frames = create_pulse_animation(mesh, duration, fps)
+    elif animation_type == 'swing':
+        frames = create_swing_animation(mesh, duration, fps)
+    else:
+        print(f"Unknown animation type: {animation_type}")
+        return None, None
+    
+    base_filename = os.path.basename(input_mesh_path).rsplit('.', 1)[0]
+    
+    # Save animated mesh as GLB
+    try:
+        animated_glb_path = os.path.join(LOG_PATH, f'animated_{base_filename}.glb')
         
-    out_json['group'] = new_group
-
-    # Save static model
-    json_path = os.path.join(LOG_PATH, f'output_{name}.json')
-    with open(json_path, 'w') as json_file:
-        json.dump(out_json, json_file, indent=4)
-
-    static_glb_path = os.path.join(LOG_PATH, f'output_{name}.glb')
-    model_scene.export(static_glb_path)
+        # For GLB output, we'll use the first frame for now
+        # In a production environment, you'd want to use proper animation keyframes
+        if frames and len(frames) > 0:
+            # First frame for static GLB
+            first_frame = frames[0]
+            # Export as GLB
+            scene = trimesh.Scene(first_frame)
+            scene.export(animated_glb_path)
+        else:
+            return None, None
+    except Exception as e:
+        print(f"Error exporting GLB: {str(e)}")
+        animated_glb_path = None
     
-    # Generate animated model
-    animated_glb_path = os.path.join(LOG_PATH, f'animated_{name}.glb')
-    animated_gif_path = os.path.join(LOG_PATH, f'animated_{name}.gif')
+    # Create GIF for preview
     try:
-        animated_glb_path, animated_gif_path = generate_animated_glb(
-            primitive_list, 
-            animation_type=animation_type,
-            duration=duration,
-            fps=fps,
-            output_path=animated_glb_path
-        )
+        animated_gif_path = os.path.join(LOG_PATH, f'animated_{base_filename}.gif')
+        generate_gif_from_frames(frames, animated_gif_path, fps)
     except Exception as e:
-        print(f"Error generating animation: {str(e)}")
-        animated_glb_path = static_glb_path
+        print(f"Error creating GIF: {str(e)}")
         animated_gif_path = None
+    
+    return animated_glb_path, animated_gif_path
 
-    return animated_glb_path, animated_gif_path, out_json
-
-
-@torch.no_grad()
-def do_inference(input_3d, dilated_offset=0.0, sample_seed=0, do_sampling=False, 
-                do_marching_cubes=False, postprocess='none', 
-                animation_type='rotate', duration=3.0, fps=30):
-    t1 = time.time()
-    set_seed(sample_seed)
-    input_mesh = trimesh.load(input_3d, force='mesh')
-
-    # scale mesh
-    vertices = input_mesh.vertices
-    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
-    vertices = vertices - (bounds[0] + bounds[1])[None, :] / 2
-    vertices = vertices / (bounds[1] - bounds[0]).max() * 1.6
-    input_mesh.vertices = vertices
-
-    pc_list, mesh_list = process_mesh_to_surface_pc(
-        [input_mesh],
-        marching_cubes=do_marching_cubes,
-        dilated_offset=dilated_offset
-    )
-    pc_normal = pc_list[0] # 10000, 6
-    mesh = mesh_list[0]
-
-    pc_coor = pc_normal[:, :3]
-    normals = pc_normal[:, 3:]
-
-    if dilated_offset > 0:
-        # scale mesh and pc
-        vertices = mesh.vertices
-        bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
-        vertices = vertices - (bounds[0] + bounds[1])[None, :] / 2
-        vertices = vertices / (bounds[1] - bounds[0]).max() * 1.6
-        mesh.vertices = vertices
-        pc_coor = pc_coor - (bounds[0] + bounds[1])[None, :] / 2
-        pc_coor = pc_coor / (bounds[1] - bounds[0]).max() * 1.6
-
-    input_save_name = os.path.join(LOG_PATH, f'processed_{os.path.basename(input_3d)}')
-    mesh.export(input_save_name)
-
-    assert (np.linalg.norm(normals, axis=-1) > 0.99).all(), 'normals should be unit vectors, something wrong'
-    normalized_pc_normal = np.concatenate([pc_coor, normals], axis=-1, dtype=np.float16)
-
-    input_pc = torch.tensor(normalized_pc_normal, dtype=torch.float16, device=device)[None]
-
-    with accelerator.autocast():
-        if postprocess == 'postprocess1':
-            recon_primitives, mask = transformer.generate_w_recon_loss(pc=input_pc, temperature=temperature, single_directional=True)
-        else:
-            recon_primitives, mask = transformer.generate(pc=input_pc, temperature=temperature)
-
-    output_animated_glb, output_animated_gif, output_json = write_output(
-        recon_primitives, 
-        os.path.basename(input_3d)[:-4], 
-        animation_type=animation_type,
-        duration=duration,
-        fps=fps
-    )
-
-    return input_save_name, output_animated_glb, output_animated_gif, output_json
-
-
-import gradio as gr
-
-@spaces.GPU
-def process_3d_model(input_3d, dilated_offset, do_marching_cubes, animation_type, animation_duration, fps, postprocess_method="postprocess1"):
+def process_3d_model(input_3d, animation_type, animation_duration, fps):
+    """Process a 3D model and apply animation"""
     print(f"Processing: {input_3d} with animation type: {animation_type}")
     
     try:
-        preprocess_model_obj, output_animated_glb, output_animated_gif, output_model_json = do_inference(
+        # Create animation
+        animated_glb_path, animated_gif_path = create_animation_mesh(
             input_3d,
-            dilated_offset=dilated_offset,
-            do_marching_cubes=do_marching_cubes,
-            postprocess=postprocess_method,
             animation_type=animation_type,
             duration=animation_duration,
             fps=fps
         )
         
-        # Save JSON to a file
-        json_path = os.path.join(LOG_PATH, f'output_{os.path.basename(input_3d)[:-4]}.json')
+        if not animated_glb_path or not animated_gif_path:
+            return "Error creating animation", None
+        
+        # Create a simple JSON metadata file
+        metadata = {
+            "animation_type": animation_type,
+            "duration": animation_duration,
+            "fps": fps,
+            "original_model": os.path.basename(input_3d),
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S")
+        }
+        
+        json_path = os.path.join(LOG_PATH, f'metadata_{os.path.basename(input_3d).rsplit(".", 1)[0]}.json')
         with open(json_path, 'w') as f:
-            json.dump(output_model_json, f, indent=4)
+            json.dump(metadata, f, indent=4)
         
-        return output_animated_glb, output_animated_gif, json_path
+        return animated_glb_path, animated_gif_path, json_path
     except Exception as e:
-        return f"Error processing file: {str(e)}", None, None
-
+        error_msg = f"Error processing file: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None
 
 _HEADER_ = '''
-<h2><b>[SIGGRAPH 2025] Animated PrimitiveAnything 🤗 Gradio Demo</b></h2>
+<h2><b>GLB 애니메이션 생성기 - 3D 모델 움직임 효과</b></h2>
 
-This is an enhanced demo for the SIGGRAPH 2025 paper <a href="">PrimitiveAnything: Human-Crafted 3D Primitive Assembly Generation with Auto-Regressive Transformer</a>, now with animation capabilities!
+이 데모를 통해 정적인 3D 모델(GLB 파일)에 다양한 애니메이션 효과를 적용할 수 있습니다.
 
-Code: <a href='https://github.com/PrimitiveAnything/PrimitiveAnything' target='_blank'>GitHub</a>. Paper: <a href='https://arxiv.org/abs/2505.04622' target='_blank'>ArXiv</a>.
-
-❗️❗️❗️**Important Notes:**
-- This demo supports 3D model animation. Upload your GLB file and see it come to life!
-- Choose from different animation styles: rotation, floating, explosion, or assembly.
-- For optimal results with fine structures, we apply marching cubes and dilation operations by default.
+❗️❗️❗️**중요사항:**
+- 이 데모는 업로드된 GLB 파일에 애니메이션을 적용합니다.
+- 다양한 애니메이션 스타일 중에서 선택하세요: 회전, 부유, 폭발, 조립, 펄스, 스윙.
+- 결과는 애니메이션된 GLB 파일과 미리보기용 GIF 파일로 제공됩니다.
 '''
 
-_CITE_ = r"""
-If PrimitiveAnything is helpful, please help to ⭐ the <a href='https://github.com/PrimitiveAnything/PrimitiveAnything' target='_blank'>GitHub Repo</a>. Thanks! [![GitHub Stars](https://img.shields.io/github/stars/PrimitiveAnything/PrimitiveAnything?style=social)](https://github.com/PrimitiveAnything/PrimitiveAnything)
----
-📝 **Citation**
-If you find our work useful for your research or applications, please cite using this bibtex:
-```bibtex
-@misc{ye2025primitiveanything,
-    title={PrimitiveAnything: Human-Crafted 3D Primitive Assembly Generation with Auto-Regressive Transformer}, 
-    author={Jingwen Ye and Yuze He and Yanning Zhou and Yiqin Zhu and Kaiwen Xiao and Yong-Jin Liu and Wei Yang and Xiao Han},
-    year={2025},
-    eprint={2505.04622},
-    archivePrefix={arXiv},
-    primaryClass={cs.GR}
-}
-```
-📧 **Contact**
-If you have any questions, feel free to open a discussion or contact us at <b>[email protected]</b>.
+_INFO_ = r"""
+### 애니메이션 유형 설명
+- **회전(rotate)**: 모델이 Y축을 중심으로 회전합니다.
+- **부유(float)**: 모델이 위아래로 부드럽게 떠다닙니다.
+- **폭발(explode)**: 모델의 각 부분이 중심에서 바깥쪽으로 퍼져나갑니다.
+- **조립(assemble)**: 폭발 애니메이션의 반대 - 부품들이 함께 모입니다.
+- **펄스(pulse)**: 모델이 크기가 커졌다 작아졌다를 반복합니다.
+- **스윙(swing)**: 모델이 좌우로 부드럽게 흔들립니다.
+
+### 팁
+- 애니메이션 길이와 FPS를 조절하여 움직임의 속도와 부드러움을 조절할 수 있습니다.
+- 복잡한 모델은 처리 시간이 더 오래 걸릴 수 있습니다.
+- GIF 미리보기는 빠른 참조용이며, 고품질 결과를 위해서는 애니메이션된 GLB 파일을 다운로드하세요.
 """
 
-with gr.Blocks(title="PrimitiveAnything with Animation: 3D Animation Generator") as demo:
-    # Title section
-    gr.Markdown(_HEADER_)
-    
-    with gr.Row():
-        with gr.Column():
-            # Input components
-            input_3d = gr.Model3D(label="Upload 3D Model File")
-            
-            with gr.Row():
-                dilated_offset = gr.Number(label="Dilated Offset", value=0.015)
-                do_marching_cubes = gr.Checkbox(label="Perform Marching Cubes", value=True)
-            
-            with gr.Row():
-                animation_type = gr.Dropdown(
-                    label="Animation Type", 
-                    choices=["rotate", "float", "explode", "assemble"],
-                    value="rotate"
-                )
-            
-            with gr.Row():
-                animation_duration = gr.Slider(
-                    label="Animation Duration (seconds)",
-                    minimum=1.0,
-                    maximum=10.0,
-                    value=3.0,
-                    step=0.5
-                )
-                fps = gr.Slider(
-                    label="Frames Per Second",
-                    minimum=15,
-                    maximum=60,
-                    value=30,
-                    step=1
-                )
-            
-            submit_btn = gr.Button("Process and Animate Model")
-            
-        with gr.Column():
-            # Output components
-            output_3d = gr.Model3D(label="Animated Primitive Assembly")
-            output_gif = gr.Image(label="Animation Preview (GIF)")
-            output_json = gr.File(label="Download JSON File")
-            
-    submit_btn.click(
-        fn=process_3d_model,
-        inputs=[input_3d, dilated_offset, do_marching_cubes, animation_type, animation_duration, fps],
-        outputs=[output_3d, output_gif, output_json]
-    )
+# Gradio 인터페이스 설정
+def create_gradio_interface():
+    with gr.Blocks(title="GLB 애니메이션 생성기") as demo:
+        # 제목 섹션
+        gr.Markdown(_HEADER_)
+        
+        with gr.Row():
+            with gr.Column():
+                # 입력 컴포넌트
+                input_3d = gr.Model3D(label="3D 모델 파일 업로드 (GLB 포맷)")
+                
+                with gr.Row():
+                    animation_type = gr.Dropdown(
+                        label="애니메이션 유형", 
+                        choices=["rotate", "float", "explode", "assemble", "pulse", "swing"],
+                        value="rotate"
+                    )
+                
+                with gr.Row():
+                    animation_duration = gr.Slider(
+                        label="애니메이션 길이 (초)",
+                        minimum=1.0,
+                        maximum=10.0,
+                        value=3.0,
+                        step=0.5
+                    )
+                    fps = gr.Slider(
+                        label="초당 프레임 수",
+                        minimum=15,
+                        maximum=60,
+                        value=30,
+                        step=1
+                    )
+                
+                submit_btn = gr.Button("모델 처리 및 애니메이션 생성")
+                
+            with gr.Column():
+                # 출력 컴포넌트
+                output_3d = gr.Model3D(label="애니메이션 적용된 3D 모델")
+                output_gif = gr.Image(label="애니메이션 미리보기 (GIF)")
+                output_json = gr.File(label="메타데이터 파일 다운로드")
+        
+        # 애니메이션 유형 설명
+        gr.Markdown(_INFO_)
+        
+        # 버튼 동작 설정
+        submit_btn.click(
+            fn=process_3d_model,
+            inputs=[input_3d, animation_type, animation_duration, fps],
+            outputs=[output_3d, output_gif, output_json]
+        )
+        
+        # 예제 준비
+        example_files = [ [f] for f in glob.glob('./data/demo_glb/*.glb') ]
+        
+        if example_files:
+            example = gr.Examples(
+                examples=example_files,
+                inputs=[input_3d],
+                examples_per_page=10,
+            )
     
-    # Prepare examples properly
-    example_files = [ [f] for f in glob.glob('./data/demo_glb/*.glb') ]  # Note: wrapped in list and filtered for GLB
-
-    example = gr.Examples(
-        examples=example_files,
-        inputs=[input_3d],  # Only include the Model3D input
-        examples_per_page=14,
-    )
-
-    gr.Markdown(_CITE_)
+    return demo
 
+# 메인 실행 부분
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
+    demo = create_gradio_interface()
+    demo.launch(share=True)