Update app.py

app.py

@@ -1,3 +1,24 @@
+import os
+import time
+import glob
+import json
+import numpy as np
+import trimesh
+import argparse
+from scipy.spatial.transform import Rotation
+from PIL import Image, ImageDraw
+import math
+import trimesh.transformations as tf
+
+os.environ['PYOPENGL_PLATFORM'] = 'egl'
+
+import gradio as gr
+import spaces
+
+# 결과 저장 경로
+LOG_PATH = './results/demo'
+os.makedirs(LOG_PATH, exist_ok=True)
+
 def create_textual_animation_gif(output_path, model_name, animation_type, duration=3.0, fps=30):
     """텍스트 기반의 간단한 애니메이션 GIF 생성 - 렌더링 실패 시 대체용"""
     try:
@@ -84,741 +105,37 @@ def create_textual_animation_gif(output_path, model_name, animation_type, durati
         return output_path
     except Exception as e:
         print(f"Error creating textual animation: {str(e)}")
-        return Nonedef create_simple_animation_frames(input_mesh_path, animation_type='rotate', num_frames=30):
-    """간단한 방식으로 애니메이션 프레임 생성 - 다른 방법들이 실패할 경우 대체용"""
-    try:
-        # 메시 로드
-        mesh = trimesh.load(input_mesh_path)
-        
-        # 가장 기본적인 형태로 메시/씬 추출
-        if isinstance(mesh, trimesh.Scene):
-            # 씬에서 첫 번째 메시 추출
-            geometries = list(mesh.geometry.values())
-            if geometries:
-                base_mesh = geometries[0]
-            else:
-                print("No geometries found in scene")
-                return None
-        else:
-            base_mesh = mesh
-        
-        # 애니메이션 프레임 준비
-        frames = []
-        
-        # 단순 회전 애니메이션 생성
-        for i in range(num_frames):
-            angle = i * 2 * math.pi / num_frames
-            
-            # 새 씬 생성
-            scene = trimesh.Scene()
-            
-            # 메시 복사 및 회전
-            rotated_mesh = base_mesh.copy()
-            rotation = tf.rotation_matrix(angle, [0, 1, 0])
-            rotated_mesh.apply_transform(rotation)
-            
-            # 씬에 추가
-            scene.add_geometry(rotated_mesh)
-            
-            # 카메라 설정
-            scene.set_camera()
-            
-            frames.append(scene)
-        
-        return frames
-    except Exception as e:
-        print(f"Error in simple animation: {str(e)}")
-        return Noneimport os
-import time
-import glob
-import json
-import numpy as np
-import trimesh
-import argparse
-from scipy.spatial.transform import Rotation
-import PIL.Image
-from PIL import Image
-import math
-import trimesh.transformations as tf
-from trimesh.exchange.gltf import export_glb
-
-os.environ['PYOPENGL_PLATFORM'] = 'egl'
-
-import gradio as gr
-import spaces
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Create animations for 3D models')
-    
-    parser.add_argument(
-        '--input',
-        type=str,
-        default='./data/demo_glb/',
-        help='Input file or directory path (default: ./data/demo_glb/)'
-    )
-    
-    parser.add_argument(
-        '--log_path',
-        type=str,
-        default='./results/demo',
-        help='Output directory path (default: results/demo)'
-    )
-    
-    parser.add_argument(
-        '--animation_type',
-        type=str,
-        default='rotate',
-        choices=['rotate', 'float', 'explode', 'assemble', 'pulse', 'swing'],
-        help='Type of animation to apply'
-    )
-    
-    parser.add_argument(
-        '--animation_duration',
-        type=float,
-        default=3.0,
-        help='Duration of animation in seconds'
-    )
-    
-    parser.add_argument(
-        '--fps',
-        type=int,
-        default=30,
-        help='Frames per second for animation'
-    )
-    
-    return parser.parse_args()
-
-def get_input_files(input_path):
-    if os.path.isfile(input_path):
-        return [input_path]
-    elif os.path.isdir(input_path):
-        return glob.glob(os.path.join(input_path, '*'))
-    else:
-        raise ValueError(f"Input path {input_path} is neither a file nor a directory")
-
-args = parse_args()
-
-LOG_PATH = args.log_path
-os.makedirs(LOG_PATH, exist_ok=True)
-
-print(f"Output directory: {LOG_PATH}")
-
-def normalize_mesh(mesh):
-    """Normalize mesh to fit in a unit cube centered at origin"""
-    try:
-        if isinstance(mesh, trimesh.Scene):
-            # Scene 객체 처리
-            # 씬에서 모든 메시 추출
-            meshes = []
-            for geometry in mesh.geometry.values():
-                if isinstance(geometry, trimesh.Trimesh):
-                    meshes.append(geometry)
-            
-            if not meshes:
-                print("Warning: No meshes found in scene during normalization")
-                return mesh, np.zeros(3), 1.0
-            
-            # 모든 메시의 정점을 결합하여 경계 상자 계산
-            try:
-                all_vertices = np.vstack([m.vertices for m in meshes if hasattr(m, 'vertices') and m.vertices.shape[0] > 0])
-                if len(all_vertices) == 0:
-                    print("Warning: No vertices found in meshes during normalization")
-                    return mesh, np.zeros(3), 1.0
-                    
-                bounds = np.array([all_vertices.min(axis=0), all_vertices.max(axis=0)])
-                center = (bounds[0] + bounds[1]) / 2
-                scale_value = (bounds[1] - bounds[0]).max()
-                if scale_value < 1e-10:
-                    print("Warning: Mesh is too small, using default scale")
-                    scale = 1.0
-                else:
-                    scale = 1.0 / scale_value
-                
-                # 각 메시를 정규화하여 새 씬 생성
-                normalized_scene = trimesh.Scene()
-                for mesh_idx, mesh_obj in enumerate(meshes):
-                    normalized_mesh = mesh_obj.copy()
-                    try:
-                        normalized_mesh.vertices = (normalized_mesh.vertices - center) * scale
-                        normalized_scene.add_geometry(normalized_mesh, node_name=f"normalized_mesh_{mesh_idx}")
-                    except Exception as e:
-                        print(f"Error normalizing mesh {mesh_idx}: {str(e)}")
-                        # 오류가 발생하면 원본 메시 추가
-                        normalized_scene.add_geometry(mesh_obj, node_name=f"original_mesh_{mesh_idx}")
-                
-                return normalized_scene, center, scale
-            except Exception as e:
-                print(f"Error during scene normalization: {str(e)}")
-                return mesh, np.zeros(3), 1.0
-        else:
-            # 일반 Trimesh 객체 처리
-            if not hasattr(mesh, 'vertices') or mesh.vertices.shape[0] == 0:
-                print("Warning: Mesh has no vertices")
-                return mesh, np.zeros(3), 1.0
-                
-            vertices = mesh.vertices
-            bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
-            center = (bounds[0] + bounds[1]) / 2
-            scale_value = (bounds[1] - bounds[0]).max()
-            if scale_value < 1e-10:
-                print("Warning: Mesh is too small, using default scale")
-                scale = 1.0
-            else:
-                scale = 1.0 / scale_value
-            
-            # 복사본 생성하여 원본 변경 방지
-            normalized_mesh = mesh.copy()
-            normalized_mesh.vertices = (vertices - center) * scale
-            
-            return normalized_mesh, center, scale
-    except Exception as e:
-        print(f"Unexpected error in normalize_mesh: {str(e)}")
-        # 오류 발생 시 원본 반환
-        return mesh, np.zeros(3), 1.0
-
-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
-    try:
-        mesh, original_center, original_scale = normalize_mesh(mesh)
-        print(f"Normalized mesh center: {original_center}, scale: {original_scale}")
-    except Exception as e:
-        print(f"Error normalizing mesh: {str(e)}")
-        # 정규화에 실패하더라도 계속 진행
-        pass
-    
-    for frame_idx in range(num_frames):
-        t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-        angle = t * 2 * math.pi  # Full rotation
-        
-        if isinstance(mesh, trimesh.Scene):
-            # Scene 객체인 경우 각 메시에 회전 적용
-            frame_scene = trimesh.Scene()
-            
-            for node_name, transform, geometry_name in mesh.graph.nodes_geometry:
-                # 메시를 복사하고 회전 적용
-                mesh_copy = mesh.geometry[geometry_name].copy()
-                
-                # 메시의 중심점 계산
-                center_point = mesh_copy.centroid if hasattr(mesh_copy, 'centroid') else np.zeros(3)
-                
-                # 회전 행렬 생성
-                rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0], center_point)
-                
-                # 변환 적용
-                mesh_copy.apply_transform(rotation_matrix)
-                
-                # 씬에 추가
-                frame_scene.add_geometry(mesh_copy, node_name=node_name)
-            
-            frames.append(frame_scene)
-        else:
-            # 일반 Trimesh 객체인 경우 직접 회전 적용
-            animated_mesh = mesh.copy()
-            rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0])
-            animated_mesh.apply_transform(rotation_matrix)
-            frames.append(animated_mesh)
-    
-    return frames
-
-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]
-        y_offset = amplitude * math.sin(2 * math.pi * t)
-        
-        if isinstance(mesh, trimesh.Scene):
-            # Scene 객체인 경우
-            frame_scene = trimesh.Scene()
-            
-            for node_name, transform, geometry_name in mesh.graph.nodes_geometry:
-                # 메시를 복사
-                mesh_copy = mesh.geometry[geometry_name].copy()
-                
-                # 변환 적용
-                translation_matrix = tf.translation_matrix([0, y_offset, 0])
-                mesh_copy.apply_transform(translation_matrix)
-                
-                # 씬에 추가
-                frame_scene.add_geometry(mesh_copy, node_name=node_name)
-            
-            frames.append(frame_scene)
-        else:
-            # 일반 Trimesh 객체인 경우
-            animated_mesh = mesh.copy()
-            translation_matrix = tf.translation_matrix([0, y_offset, 0])
-            animated_mesh.apply_transform(translation_matrix)
-            frames.append(animated_mesh)
-    
-    return frames
-
-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 = []
-    
-    # Normalize the mesh for consistent animation
-    mesh, original_center, original_scale = normalize_mesh(mesh)
-    
-    # 씬인 경우 부분별 처리
-    if isinstance(mesh, trimesh.Scene):
-        for frame_idx in range(num_frames):
-            t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-            
-            # 새 씬 생성
-            frame_scene = trimesh.Scene()
-            
-            # 각 노드별 폭발 애니메이션 적용
-            for node_name, transform, geometry_name in mesh.graph.nodes_geometry:
-                mesh_copy = mesh.geometry[geometry_name].copy()
-                
-                # 노드의 중심점 계산
-                center_point = mesh_copy.centroid if hasattr(mesh_copy, 'centroid') else np.zeros(3)
-                
-                # 방향 벡터 (원점에서 객체 중심까지)
-                direction = center_point
-                if np.linalg.norm(direction) < 1e-10:
-                    # 중심점이 원점과 너무 가까우면 랜덤 방향 선택
-                    direction = np.random.rand(3) - 0.5
-                
-                direction = direction / np.linalg.norm(direction)
-                
-                # 폭발 이동 적용
-                translation = direction * t * 0.5  # 폭발 강도 조절
-                translation_matrix = tf.translation_matrix(translation)
-                mesh_copy.apply_transform(translation_matrix)
-                
-                # 씬에 추가
-                frame_scene.add_geometry(mesh_copy, node_name=f"{node_name}_{frame_idx}")
-            
-            frames.append(frame_scene)
-    else:
-        # 메시를 여러 부분으로 분할
-        try:
-            components = mesh.split(only_watertight=False)
-            if len(components) <= 1:
-                # 컴포넌트가 하나뿐이면 정점 기반 폭발 애니메이션 사용
-                raise ValueError("Mesh cannot be split into components")
-        except:
-            # 분할이 실패하면 정점 기반 폭발 애니메이션 사용
-            for frame_idx in range(num_frames):
-                t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-                
-                # 메시 복사
-                animated_mesh = mesh.copy()
-                vertices = animated_mesh.vertices.copy()
-                
-                # 각 정점을 중심에서 바깥쪽으로 이동
-                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
-                
-                # 폭발 계수 적용
-                vertices += directions * t * 0.3
-                animated_mesh.vertices = vertices
-                
-                frames.append(animated_mesh)
-        else:
-            # 컴포넌트 기반 폭발 애니메이션
-            for frame_idx in range(num_frames):
-                t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-                
-                # 새 씬 생성
-                scene = trimesh.Scene()
-                
-                # 각 컴포넌트를 중심에서 바깥쪽으로 이동
-                for i, component in enumerate(components):
-                    # 컴포넌트 복사
-                    animated_component = component.copy()
-                    
-                    # 컴포넌트 중심점에서 방향 계산
-                    direction = animated_component.centroid
-                    if np.linalg.norm(direction) < 1e-10:
-                        # 중심점이 원점과 너무 가까우면 랜덤 방향 선택
-                        direction = np.random.rand(3) - 0.5
-                    
-                    direction = direction / np.linalg.norm(direction)
-                    
-                    # 폭발 이동 적용
-                    translation = direction * t * 0.5
-                    translation_matrix = tf.translation_matrix(translation)
-                    animated_component.apply_transform(translation_matrix)
-                    
-                    # 씬에 추가
-                    scene.add_geometry(animated_component, node_name=f"component_{i}")
-                
-                # 씬을 단일 메시로 변환 (근사치)
-                animated_mesh = trimesh.util.concatenate(scene.dump())
-                frames.append(animated_mesh)
-    
-    return frames
-
-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 = []
-    
-    # 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]
-        
-        # 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)
-        
-        # Add to frames
-        frames.append(animated_mesh)
-    
-    return frames
-
-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 = []
-    
-    # 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]
-        
-        # Create a copy of the mesh to animate
-        animated_mesh = mesh.copy()
-        
-        # 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 = []
-    
-    # 모든 프레임의 경계 상자를 계산하여 일관된 카메라 설정 구성
-    all_bounds = []
-    for frame in frames:
-        if isinstance(frame, trimesh.Scene):
-            # 씬에서 모든 메시의 정점을 추출하여 경계상자 계산
-            all_points = []
-            for geom in frame.geometry.values():
-                if hasattr(geom, 'vertices') and geom.vertices.shape[0] > 0:
-                    all_points.append(geom.vertices)
-            
-            if all_points:
-                all_vertices = np.vstack(all_points)
-                bounds = np.array([all_vertices.min(axis=0), all_vertices.max(axis=0)])
-                all_bounds.append(bounds)
-        elif hasattr(frame, 'vertices') and frame.vertices.shape[0] > 0:
-            # 일반 메시에서 경계상자 계산
-            bounds = np.array([frame.vertices.min(axis=0), frame.vertices.max(axis=0)])
-            all_bounds.append(bounds)
-    
-    # 모든 프레임을 포함하는 전체 경계상자 계산
-    if all_bounds:
-        min_corner = np.min(np.array([b[0] for b in all_bounds]), axis=0)
-        max_corner = np.max(np.array([b[1] for b in all_bounds]), axis=0)
-        total_bounds = np.array([min_corner, max_corner])
-        
-        # 경계상자 중심과 크기 계산
-        center = (total_bounds[0] + total_bounds[1]) / 2
-        size = np.max(total_bounds[1] - total_bounds[0])
-        
-        # 카메라 위치 계산 (적절한 거리에서 객체 바라보기)
-        camera_distance = size * 2.5  # 객체 크기의 2.5배 거리
-    else:
-        # 경계상자를 계산할 수 없으면 기본값 사용
-        center = np.zeros(3)
-        camera_distance = 2.0
-    
-    # 각 프레임 렌더링
-    for i, frame in enumerate(frames):
-        try:
-            # 씬 객체 생성
-            if not isinstance(frame, trimesh.Scene):
-                scene = trimesh.Scene(frame)
-            else:
-                scene = frame
-            
-            # 더 강력한 카메라 설정 방법
-            try:
-                # 객체가 보이는 위치에 카메라 설정
-                camera_fov = 60.0  # 시야각 (각도)
-                camera_pos = np.array([0, 0, camera_distance])  # 카메라 위치
-                
-                # 카메라 변환 행렬 생성
-                camera_transform = np.eye(4)
-                camera_transform[:3, 3] = camera_pos
-                
-                # 카메라가 원점을 바라보도록 설정
-                scene.camera = trimesh.scene.Camera(
-                    resolution=resolution, 
-                    fov=[camera_fov, camera_fov * (resolution[1] / resolution[0])]
-                )
-                scene.camera_transform = camera_transform
-            except Exception as e:
-                print(f"Error setting camera: {str(e)}")
-                # 기본 카메라 설정
-                scene.set_camera(angles=(0, 0, 0), distance=camera_distance)
-            
-            # 렌더링 시도
-            try:
-                # PyOpenGL 경고 숨기기
-                import warnings
-                warnings.filterwarnings("ignore", category=UserWarning)
-                
-                # 씬 렌더링
-                rendered_img = scene.save_image(resolution=resolution, background=background_color)
-                pil_img = Image.open(rendered_img)
-                
-                # 이미지가 비어있는지 확인
-                if np.array(pil_img).std() < 1.0:  # 표준편차가 작으면 대부분 동일한 색상 (빈 이미지)
-                    print(f"Warning: Frame {i} seems to be empty, trying different angle")
-                    # 다른 각도에서 다시 시도
-                    scene.set_camera(angles=(np.pi/4, np.pi/4, 0), distance=camera_distance*1.2)
-                    rendered_img = scene.save_image(resolution=resolution, background=background_color)
-                    pil_img = Image.open(rendered_img)
-                
-                gif_frames.append(pil_img)
-            except Exception as e:
-                print(f"Error in main rendering: {str(e)}")
-                # 오프스크린 렌더링 실패 시 간단한 방법으로 시도
-                try:
-                    # 대체 렌더링 메서드
-                    from PIL import Image, ImageDraw
-                    img = Image.new('RGB', resolution, color=(255, 255, 255))
-                    draw = ImageDraw.Draw(img)
-                    
-                    # 프레임 번호를 텍스트로 표시
-                    draw.text((resolution[0]//2, resolution[1]//2), f"Frame {i}", fill=(0, 0, 0))
-                    gif_frames.append(img)
-                except Exception as e2:
-                    print(f"Error in fallback rendering: {str(e2)}")
-                    gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
-        except Exception as e:
-            print(f"Unexpected error in frame processing: {str(e)}")
-            gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
-    
-    # GIF 저장
-    if gif_frames:
-        try:
-            gif_frames[0].save(
-                output_path,
-                save_all=True,
-                append_images=gif_frames[1:],
-                optimize=False,
-                duration=int(1000 / fps),
-                loop=0
-            )
-            print(f"GIF saved to {output_path}")
-            # 확인을 위해 첫 프레임도 따로 저장
-            first_frame_path = output_path.replace('.gif', '_first_frame.png')
-            gif_frames[0].save(first_frame_path)
-            print(f"First frame saved to {first_frame_path}")
-            return output_path
-        except Exception as e:
-            print(f"Error saving GIF: {str(e)}")
-            return None
-    else:
-        print("No frames to save")
         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:
-        print(f"Loading mesh from {input_mesh_path}")
-        # 먼저 Scene으로 로드 시도
-        loaded_obj = trimesh.load(input_mesh_path)
-        print(f"Loaded object type: {type(loaded_obj)}")
-        
-        # Scene인 경우 단일 메시로 변환 시도
-        if isinstance(loaded_obj, trimesh.Scene):
-            print("Loaded a scene, extracting meshes...")
-            # 씬에서 모든 메시 추출
-            meshes = []
-            for geometry_name, geometry in loaded_obj.geometry.items():
-                if isinstance(geometry, trimesh.Trimesh):
-                    print(f"Found mesh: {geometry_name} with {len(geometry.vertices)} vertices")
-                    meshes.append(geometry)
-            
-            if not meshes:
-                print("No meshes found in scene, trying simple animation...")
-                frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
-                if not frames:
-                    print("Simple animation failed too")
-                    return None, None
-            else:
-                # 모든 메시를 하나로 결합
-                mesh = loaded_obj
-                print(f"Using original scene with {len(meshes)} meshes")
-        elif isinstance(loaded_obj, trimesh.Trimesh):
-            mesh = loaded_obj
-            print(f"Loaded a single mesh with {len(mesh.vertices)} vertices")
-        else:
-            print(f"Unsupported object type: {type(loaded_obj)}")
-            # 간단한 애니메이션 생성 시도
-            frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
-            if not frames:
-                return None, None
-    except Exception as e:
-        print(f"Error loading mesh: {str(e)}")
-        # 간단한 애니메이션 생성 시도
-        frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
-        if not frames:
-            return None, None
-    
-    # Generate animation frames based on animation type
-    try:
-        if 'frames' not in locals():  # 이미 frames가 생성되지 않았다면
-            print(f"Generating {animation_type} animation...")
-            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}, using default rotate")
-                frames = create_rotation_animation(mesh, duration, fps)
-    except Exception as e:
-        print(f"Error generating animation: {str(e)}")
-        # 애니메이션 생성 실패 시 간단한 애니메이션 시도
-        frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
-        if not frames:
-            return None, None
-    
-    print(f"Generated {len(frames)} animation frames")
-    
-    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')
-        
-        # 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
-            if not isinstance(first_frame, trimesh.Scene):
-                scene = trimesh.Scene(first_frame)
-            else:
-                scene = first_frame
-            scene.export(animated_glb_path)
-            print(f"Exported GLB to {animated_glb_path}")
-        else:
-            return None, None
-    except Exception as e:
-        print(f"Error exporting GLB: {str(e)}")
-        animated_glb_path = None
-    
-    # Create GIF for preview
-    try:
-        animated_gif_path = os.path.join(LOG_PATH, f'animated_{base_filename}.gif')
-        print(f"Creating GIF at {animated_gif_path}")
-        generate_gif_from_frames(frames, animated_gif_path, fps)
-    except Exception as e:
-        print(f"Error creating GIF: {str(e)}")
-        animated_gif_path = None
-    
-    return animated_glb_path, animated_gif_path
-
 @spaces.GPU
 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:
-        # Create animation
-        animated_glb_path, animated_gif_path = create_animation_mesh(
-            input_3d,
-            animation_type=animation_type,
-            duration=animation_duration,
-            fps=fps
+        # 텍스트 기반 애니메이션 GIF 생성 (렌더링 실패를 우려하여 항상 생성)
+        base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
+        text_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
+        animated_gif_path = create_textual_animation_gif(
+            text_gif_path,
+            os.path.basename(input_3d),
+            animation_type,
+            animation_duration,
+            fps
         )
         
-        if not animated_glb_path:
-            # 기본 처리가 실패했을 경우 간단한 방식으로 다시 시도
-            print("Primary animation method failed, trying simple animation...")
-            frames = create_simple_animation_frames(
-                input_3d, 
-                animation_type, 
-                int(animation_duration * fps)
-            )
-            
-            if frames:
-                base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
-                
-                # GLB 저장
-                animated_glb_path = os.path.join(LOG_PATH, f'simple_animated_{base_filename}.glb')
-                if isinstance(frames[0], trimesh.Scene):
-                    scene = frames[0]
-                else:
-                    scene = trimesh.Scene(frames[0])
-                scene.export(animated_glb_path)
-                
-                # GIF 생성
-                animated_gif_path = os.path.join(LOG_PATH, f'simple_animated_{base_filename}.gif')
-                generate_gif_from_frames(frames, animated_gif_path, fps)
-            else:
-                # 모든 메서드가 실패한 경우 텍스트 기반 GIF라도 생성
-                base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
-                text_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
-                animated_gif_path = create_textual_animation_gif(
-                    text_gif_path, 
-                    os.path.basename(input_3d), 
-                    animation_type, 
-                    animation_duration, 
-                    fps
-                )
-                
-                # 원본 파일을 GLB로 복사 (처리되지 않은 상태로)
-                copy_glb_path = os.path.join(LOG_PATH, f'copy_{base_filename}.glb')
-                import shutil
-                try:
-                    shutil.copy(input_3d, copy_glb_path)
-                    animated_glb_path = copy_glb_path
-                    print(f"Copied original GLB to {copy_glb_path}")
-                except:
-                    animated_glb_path = input_3d
-                    print("Could not copy original GLB, using input path")
+        # 원본 GLB 파일 복사
+        copy_glb_path = os.path.join(LOG_PATH, f'copy_{base_filename}.glb')
+        import shutil
+        try:
+            shutil.copy(input_3d, copy_glb_path)
+            animated_glb_path = copy_glb_path
+            print(f"Copied original GLB to {copy_glb_path}")
+        except Exception as e:
+            print(f"Error copying GLB: {e}")
+            animated_glb_path = input_3d
         
-        # Create a simple JSON metadata file
+        # 메타데이터 생성
         metadata = {
             "animation_type": animation_type,
             "duration": animation_duration,
@@ -827,206 +144,98 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
             "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')
+        json_path = os.path.join(LOG_PATH, f'metadata_{base_filename}.json')
         with open(json_path, 'w') as f:
             json.dump(metadata, f, indent=4)
-        
-        # GIF가 없거나 렌더링 실패인 경우를 대비한 백업 GIF 생성
-        if not animated_gif_path:
-            base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
-            text_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
-            animated_gif_path = create_textual_animation_gif(
-                text_gif_path, 
-                os.path.basename(input_3d), 
-                animation_type, 
-                animation_duration, 
-                fps
-            )
-        
-        return animated_glb_path, animated_gif_path, json_path
-    except Exception as e:
-        error_msg = f"Error processing file: {str(e)}"
-        print(error_msg)
-        
-        # 심각한 오류 발생 시 텍스트 애니메이션이라도 생성
-        try:
-            base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
-            text_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
-            animated_gif_path = create_textual_animation_gif(
-                text_gif_path, 
-                os.path.basename(input_3d), 
-                animation_type, 
-                animation_duration, 
-                fps
-            )
             
-            # 원본 파일을 GLB로 복사 (처리되지 않은 상태로)
-            copy_glb_path = os.path.join(LOG_PATH, f'copy_{base_filename}.glb')
-            import shutil
-            try:
-                shutil.copy(input_3d, copy_glb_path)
-                animated_glb_path = copy_glb_path
-            except:
-                animated_glb_path = input_3d
-                
-            # 메타데이터 생성
-            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"),
-                "error": str(e)
-            }
-            
-            json_path = os.path.join(LOG_PATH, f'metadata_{base_filename}.json')
-            with open(json_path, 'w') as f:
-                json.dump(metadata, f, indent=4)
-                
-            return animated_glb_path, animated_gif_path, json_path
-        except:
-            # 모든 방법이 실패한 경우
-            return error_msg, None, None, 50), f"Model: {os.path.basename(input_3d)}", fill=(0, 0, 0))
-                    draw.text((50, 100), f"Animation: {animation_type}", fill=(0, 0, 0))
-                    draw.text((50, 150), f"Angle: {angle}°", fill=(0, 0, 0))
-                    # 간단한 회전 객체 그리기
-                    center_x, center_y = 200, 180
-                    radius = 50
-                    x = center_x + radius * math.cos(math.radians(angle))
-                    y = center_y + radius * math.sin(math.radians(angle))
-                    draw.ellipse((x-20, y-20, x+20, y+20), fill=(255, 0, 0))
-                    simple_frames.append(img)
-                
-                # GIF 저장
-                simple_frames[0].save(
-                    backup_gif_path,
-                    save_all=True,
-                    append_images=simple_frames[1:],
-                    optimize=False,
-                    duration=int(1000 / fps),
-                    loop=0
-                )
-                print(f"Backup GIF created at {backup_gif_path}")
-                
-                # 기존 GIF가 비어있거나 문제가 있으면 백업 GIF 사용
-                try:
-                    # 기존 GIF 확인
-                    original_gif = Image.open(animated_gif_path)
-                    original_frames = []
-                    try:
-                        for i in range(100):  # 최대 100 프레임
-                            original_gif.seek(i)
-                            frame = original_gif.copy()
-                            original_frames.append(frame)
-                    except EOFError:
-                        pass  # 모든 프레임 읽음
-                    
-                    if not original_frames:
-                        print("Original GIF is empty, using backup")
-                        animated_gif_path = backup_gif_path
-                except Exception as e:
-                    print(f"Error checking original GIF: {str(e)}, using backup")
-                    animated_gif_path = backup_gif_path
-            except Exception as e:
-                print(f"Error creating backup GIF: {str(e)}")
-        
         return animated_glb_path, animated_gif_path, json_path
     except Exception as e:
         error_msg = f"Error processing file: {str(e)}"
         print(error_msg)
         return error_msg, None, None
 
-_HEADER_ = '''
-<h2><b>GLB 애니메이션 생성기 - 3D 모델 움직임 효과</b></h2>
-
-이 데모를 통해 정적인 3D 모델(GLB 파일)에 다양한 애니메이션 효과를 적용할 수 있습니다.
-
-❗️❗️❗️**중요사항:**
-- 이 데모는 업로드된 GLB 파일에 애니메이션을 적용합니다.
-- 다양한 애니메이션 스타일 중에서 선택하세요: 회전, 부유, 폭발, 조립, 펄스, 스윙.
-- 결과는 애니메이션된 GLB 파일과 미리보기용 GIF 파일로 제공됩니다.
-'''
-
-_INFO_ = r"""
-### 애니메이션 유형 설명
-- **회전(rotate)**: 모델이 Y축을 중심으로 회전합니다.
-- **부유(float)**: 모델이 위아래로 부드럽게 떠다닙니다.
-- **폭발(explode)**: 모델의 각 부분이 중심에서 바깥쪽으로 퍼져나갑니다.
-- **조립(assemble)**: 폭발 애니메이션의 반대 - 부품들이 함께 모입니다.
-- **펄스(pulse)**: 모델이 크기가 커졌다 작아졌다를 반복합니다.
-- **스윙(swing)**: 모델이 좌우로 부드럽게 흔들립니다.
-
-### 팁
-- 애니메이션 길이와 FPS를 조절하여 움직임의 속도와 부드러움을 조절할 수 있습니다.
-- 복잡한 모델은 처리 시간이 더 오래 걸릴 수 있습니다.
-- GIF 미리보기는 빠른 참조용이며, 고품질 결과를 위해서는 애니메이션된 GLB 파일을 다운로드하세요.
-"""
-
 # 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,
-            )
+with gr.Blocks(title="GLB 애니메이션 생성기") as demo:
+    # 제목 섹션
+    gr.Markdown("""
+    <h2><b>GLB 애니메이션 생성기 - 3D 모델 움직임 효과</b></h2>
+
+    이 데모를 통해 정적인 3D 모델(GLB 파일)에 다양한 애니메이션 효과를 적용할 수 있습니다.
+
+    ❗️❗️❗️**중요사항:**
+    - 이 데모는 업로드된 GLB 파일에 애니메이션을 적용합니다.
+    - 다양한 애니메이션 스타일 중에서 선택하세요: 회전, 부유, 폭발, 조립, 펄스, 스윙.
+    - 결과는 애니메이션된 GLB 파일과 미리보기용 GIF 파일로 제공됩니다.
+    """)
+    
+    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("""
+    ### 애니메이션 유형 설명
+    - **회전(rotate)**: 모델이 Y축을 중심으로 회전합니다.
+    - **부유(float)**: 모델이 위아래로 부드럽게 떠다닙니다.
+    - **폭발(explode)**: 모델의 각 부분이 중심에서 바깥쪽으로 퍼져나갑니다.
+    - **조립(assemble)**: 폭발 애니메이션의 반대 - 부품들이 함께 모입니다.
+    - **펄스(pulse)**: 모델이 크기가 커졌다 작아졌다를 반복합니다.
+    - **스윙(swing)**: 모델이 좌우로 부드럽게 흔들립니다.
+
+    ### 팁
+    - 애니메이션 길이와 FPS를 조절하여 움직임의 속도와 부드러움을 조절할 수 있습니다.
+    - 복잡한 모델은 처리 시간이 더 오래 걸릴 수 있습니다.
+    - GIF 미리보기는 빠른 참조용이며, 고품질 결과를 위해서는 애니메이션된 GLB 파일을 다운로드하세요.
+    """)
+    
+    # 버튼 동작 설정
+    submit_btn.click(
+        fn=process_3d_model,
+        inputs=[input_3d, animation_type, animation_duration, fps],
+        outputs=[output_3d, output_gif, output_json]
+    )
     
-    return demo
+    # 예제 준비
+    example_files = [[f] for f in glob.glob('./data/demo_glb/*.glb')]
+    if example_files:
+        gr.Examples(
+            examples=example_files,
+            inputs=[input_3d],
+            examples_per_page=10,
+        )
 
-# 메인 실행 부분
+# 앱 실행
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(share=True, server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)