app.py

import os
import time
import glob
import json
import numpy as np
import trimesh
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:
        frames = []
        num_frames = int(duration * fps)
        if num_frames > 60:
            num_frames = 60
            
        for i in range(num_frames):
            t = i / (num_frames - 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 in ['explode', '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)
        
        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 None

def modify_glb_file(input_glb_path, output_glb_path, animation_type='rotate'):
    """업로드된 GLB 파일을 수정하여 애니메이션 효과를 주는 함수"""
    try:
        # 간단한 방법: 원본 파일을 그대로 로드하여 단일 변환 적용 후 저장
        # 여러 단계로 나누어 처리하여 각 단계에서 오류를 확인할 수 있도록 함
        
        print(f"Step 1: Loading GLB file '{input_glb_path}'")
        scene = trimesh.load(input_glb_path)
        print(f"Loaded GLB file, type: {type(scene)}")
        
        print(f"Step 2: Preparing transformation for animation type: {animation_type}")
        # 단순화된 변환 준비 - 애니메이션 유형별로 다른 변환 적용
        transform = np.eye(4)  # 기본 항등 변환 (아무 변화 없음)
        
        if animation_type == 'rotate':
            # Y축 기준 45도 회전
            transform = tf.rotation_matrix(math.pi/4, [0, 1, 0])
        elif animation_type == 'float':
            # 위로 이동
            transform = tf.translation_matrix([0, 0.5, 0])
        elif animation_type == 'pulse':
            # 크기 확대
            transform = tf.scale_matrix(1.2)
        elif animation_type == 'explode':
            # X축 방향으로 약간 이동
            transform = tf.translation_matrix([0.5, 0, 0])
        elif animation_type == 'assemble':
            # X축 방향으로 약간 이동 (반대 방향)
            transform = tf.translation_matrix([-0.5, 0, 0])
        elif animation_type == 'swing':
            # Z축 기준 약간 회전
            transform = tf.rotation_matrix(math.pi/8, [0, 0, 1])
        
        print(f"Step 3: Applying transformation to scene")
        if isinstance(scene, trimesh.Scene):
            # Scene인 경우 직접 변환 적용
            scene.apply_transform(transform)
            print(f"Applied transform to scene")
        else:
            print(f"Scene is not trimesh.Scene, but {type(scene)}")
        
        print(f"Step 4: Exporting modified scene to '{output_glb_path}'")
        scene.export(output_glb_path)
        print(f"Successfully exported modified GLB to '{output_glb_path}'")
        
        return output_glb_path
    
    except Exception as e:
        print(f"Error modifying GLB file: {str(e)}")
        
        # 오류 발생 시 원본 파일 복사
        try:
            import shutil
            print(f"Copying original GLB file as fallback")
            shutil.copy(input_glb_path, output_glb_path)
            print(f"Successfully copied original GLB to '{output_glb_path}'")
            return output_glb_path
        except Exception as copy_error:
            print(f"Error copying GLB: {copy_error}")
            return input_glb_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:
        # 파일명 준비
        base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
        animated_glb_path = os.path.join(LOG_PATH, f'animated_{base_filename}.glb')
        animated_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
        json_path = os.path.join(LOG_PATH, f'metadata_{base_filename}.json')
        
        # 1. GLB 파일 수정
        print(f"Modifying GLB file")
        modified_glb = modify_glb_file(input_3d, animated_glb_path, animation_type)
        
        # 2. 애니메이션 GIF 생성 (어떤 경우에도 항상 생성)
        print(f"Creating animation GIF")
        animated_gif = create_textual_animation_gif(
            animated_gif_path,
            os.path.basename(input_3d),
            animation_type,
            animation_duration,
            fps
        )
        
        # 3. 메타데이터 생성
        print(f"Creating metadata")
        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")
        }
        
        with open(json_path, 'w') as f:
            json.dump(metadata, f, indent=4)
        
        print(f"Processing complete, returning results")
        return modified_glb, animated_gif, json_path
        
    except Exception as e:
        print(f"Error in process_3d_model: {str(e)}")
        # 심각한 오류 발생 시 원본 파일과 기본 GIF 반환
        try:
            base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
            animated_gif_path = os.path.join(LOG_PATH, f'text_animated_{base_filename}.gif')
            create_textual_animation_gif(
                animated_gif_path,
                os.path.basename(input_3d),
                animation_type,
                animation_duration,
                fps
            )
            return input_3d, animated_gif_path, None
        except:
            return f"Error processing file: {str(e)}", None, None

# Gradio 인터페이스 설정
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]
    )
    
    # 예제 준비
    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.launch(server_name="0.0.0.0", server_port=7860)