app.py

def create_textual_animation_gif(output_path, model_name, animation_type, duration=3.0, fps=30):
    """텍스트 기반의 간단한 애니메이션 GIF 생성 - 렌더링 실패 시 대체용"""
    try:
        # 간단한 프레임 시퀀스 생성
        frames = []
        num_frames = int(duration * fps)
        if num_frames > 60:  # 너무 많은 프레임은 효율적이지 않음
            num_frames = 60
            
        for i in range(num_frames):
            t = i / (num_frames - 1)  # 0~1 범위
            angle = t * 360  # 전체 회전
            
            # 새 이미지 생성
            img = Image.new('RGB', (640, 480), color=(240, 240, 240))
            draw = ImageDraw.Draw(img)
            
            # 정보 텍스트
            draw.text((50, 50), f"Model: {os.path.basename(model_name)}", fill=(0, 0, 0))
            draw.text((50, 100), f"Animation Type: {animation_type}", fill=(0, 0, 0))
            draw.text((50, 150), f"Frame: {i+1}/{num_frames}", fill=(0, 0, 0))
            
            # 애니메이션 유형에 따른 시각적 효과
            center_x, center_y = 320, 240
            if animation_type == 'rotate':
                # 회전하는 사각형
                radius = 100
                x = center_x + radius * math.cos(math.radians(angle))
                y = center_y + radius * math.sin(math.radians(angle))
                draw.rectangle((x-40, y-40, x+40, y+40), outline=(0, 0, 0), fill=(255, 0, 0))
                
            elif animation_type == 'float':
                # 위아래로 움직이는 원
                offset_y = 50 * math.sin(2 * math.pi * t)
                draw.ellipse((center_x-50, center_y-50+offset_y, center_x+50, center_y+50+offset_y), 
                            outline=(0, 0, 0), fill=(0, 0, 255))
                
            elif animation_type == 'explode' or animation_type == 'assemble':
                # 바깥쪽/안쪽으로 움직이는 여러 도형
                scale = t if animation_type == 'explode' else 1 - t
                for j in range(8):
                    angle_j = j * 45
                    dist = 120 * scale
                    x = center_x + dist * math.cos(math.radians(angle_j))
                    y = center_y + dist * math.sin(math.radians(angle_j))
                    
                    if j % 3 == 0:
                        draw.rectangle((x-20, y-20, x+20, y+20), outline=(0, 0, 0), fill=(255, 0, 0))
                    elif j % 3 == 1:
                        draw.ellipse((x-20, y-20, x+20, y+20), outline=(0, 0, 0), fill=(0, 255, 0))
                    else:
                        draw.polygon([(x, y-20), (x+20, y+20), (x-20, y+20)], outline=(0, 0, 0), fill=(0, 0, 255))
                        
            elif animation_type == 'pulse':
                # 크기가 변하는 원
                scale = 0.5 + 0.5 * math.sin(2 * math.pi * t)
                radius = 100 * scale
                draw.ellipse((center_x-radius, center_y-radius, center_x+radius, center_y+radius), 
                           outline=(0, 0, 0), fill=(0, 255, 0))
                
            elif animation_type == 'swing':
                # 좌우로 움직이는 삼각형
                angle_offset = 30 * math.sin(2 * math.pi * t)
                points = [
                    (center_x + 100 * math.cos(math.radians(angle_offset)), center_y - 80),
                    (center_x + 100 * math.cos(math.radians(120 + angle_offset)), center_y + 40),
                    (center_x + 100 * math.cos(math.radians(240 + angle_offset)), center_y + 40)
                ]
                draw.polygon(points, outline=(0, 0, 0), fill=(255, 165, 0))
            
            # 프레임 추가
            frames.append(img)
        
        # GIF로 저장
        frames[0].save(
            output_path,
            save_all=True,
            append_images=frames[1:],
            optimize=False,
            duration=int(1000 / fps),
            loop=0
        )
        print(f"Created textual animation GIF at {output_path}")
        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
        )
        
        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")
        
        # 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(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,
            )
    
    return demo

# 메인 실행 부분
if __name__ == "__main__":
    demo = create_gradio_interface()
    demo.launch(share=True, server_name="0.0.0.0", server_port=7860)