Update app.py

app.py

@@ -1,298 +1,222 @@
-import os
-import time
-import glob
-import json
+"""
+GLB 애니메이션 생성기 – 업로드한 3D 모델을 직접 렌더링해 GIF·GLB로 내보냅니다.
+(Gradio + Trimesh 오프스크린 렌더링)
+
+※ 주요 변경
+1. create_model_animation_gif : 모델을 실제 렌더링해 프레임 생성
+2. process_3d_model 내부에서 새 GIF 함수 사용
+3. 예외 처리·주석 일부 보강
+"""
+
+import os, io, time, glob, json, math
 import numpy as np
 import trimesh
-from PIL import Image, ImageDraw
-import math
+from PIL import Image
 import trimesh.transformations as tf
 
-os.environ['PYOPENGL_PLATFORM'] = 'egl'
+os.environ["PYOPENGL_PLATFORM"] = "egl"  # 모니터 없이 렌더링
 
 import gradio as gr
 import spaces
 
-# 결과 저장 경로
-LOG_PATH = './results/demo'
+# 결과 저장 디렉터리
+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 파일을 수정하여 애니메이션 효과를 주는 함수"""
+# ------------------------------------------------------------------
+# 1) 실제 GLB 모델을 렌더링해 GIF 생성
+# ------------------------------------------------------------------
+def create_model_animation_gif(
+    output_path: str,
+    input_glb_path: str,
+    animation_type: str,
+    duration: float = 3.0,
+    fps: int = 30,
+    resolution=(640, 480),
+):
+    """
+    업로드된 GLB 모델을 오프스크린으로 렌더링해 애니메이션 GIF 생성
+    """
+    # (1) 모델 로드
+    scene = trimesh.load(input_glb_path)
+    if isinstance(scene, trimesh.Trimesh):
+        scene = trimesh.Scene(scene)
+
+    frames, num_frames = [], min(int(duration * fps), 60)
+    for i in range(num_frames):
+        t = i / (num_frames - 1)
+
+        # (2) 프레임마다 변환 적용
+        scene_i = scene.copy()
+        if animation_type == "rotate":
+            M = tf.rotation_matrix(2 * math.pi * t, [0, 1, 0])
+        elif animation_type == "float":
+            M = tf.translation_matrix([0, 0.5 * math.sin(2 * math.pi * t), 0])
+        elif animation_type == "pulse":
+            M = tf.scale_matrix(0.8 + 0.4 * math.sin(2 * math.pi * t))
+        elif animation_type == "explode":
+            M = tf.translation_matrix([0.5 * t, 0, 0])
+        elif animation_type == "assemble":
+            M = tf.translation_matrix([0.5 * (1 - t), 0, 0])
+        elif animation_type == "swing":
+            M = tf.rotation_matrix(math.pi / 6 * math.sin(2 * math.pi * t), [0, 0, 1])
+        else:
+            M = np.eye(4)
+
+        scene_i.apply_transform(M)
+
+        # (3) 오프스크린 렌더 → PNG 바이트
+        png_bytes = scene_i.save_image(resolution=resolution, visible=True)
+        frame = Image.open(io.BytesIO(png_bytes)).convert("RGB")
+        frames.append(frame)
+
+    # (4) GIF 저장
+    frames[0].save(
+        output_path,
+        save_all=True,
+        append_images=frames[1:],
+        optimize=False,
+        duration=int(1000 / fps),
+        loop=0,
+    )
+    print(f"Created model animation GIF at {output_path}")
+    return output_path
+
+
+# ------------------------------------------------------------------
+# 2) GLB 파일에 단순 변환 적용해 저장
+# ------------------------------------------------------------------
+def modify_glb_file(input_glb_path, output_glb_path, animation_type="rotate"):
+    """
+    업로드된 GLB 파일에 단일 변환(회전·이동·스케일)을 적용해 새 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':
-            # 위로 이동
+        if not isinstance(scene, trimesh.Scene):
+            scene = trimesh.Scene(scene)
+
+        # 변환 매트릭스 결정
+        if animation_type == "rotate":
+            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':
-            # 크기 확대
+        elif animation_type == "pulse":
             transform = tf.scale_matrix(1.2)
-        elif animation_type == 'explode':
-            # X축 방향으로 약간 이동
+        elif animation_type == "explode":
             transform = tf.translation_matrix([0.5, 0, 0])
-        elif animation_type == 'assemble':
-            # X축 방향으로 약간 이동 (반대 방향)
+        elif animation_type == "assemble":
             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")
+        elif animation_type == "swing":
+            transform = tf.rotation_matrix(math.pi / 8, [0, 0, 1])
         else:
-            print(f"Scene is not trimesh.Scene, but {type(scene)}")
-        
-        print(f"Step 4: Exporting modified scene to '{output_glb_path}'")
+            transform = np.eye(4)
+
+        scene.apply_transform(transform)
         scene.export(output_glb_path)
-        print(f"Successfully exported modified GLB to '{output_glb_path}'")
-        
+        print(f"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  # 원본 파일 경로 반환
+        print("Error modifying GLB:", e)
+        # 실패 시 원본 복사
+        import shutil
+
+        shutil.copy(input_glb_path, output_glb_path)
+        print(f"Copied original GLB to {output_glb_path}")
+        return output_glb_path
+
 
+# ------------------------------------------------------------------
+# 3) Gradio에서 호출할 메인 파이프라인
+# ------------------------------------------------------------------
 @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}")
-    
+    """
+    ① GLB 변환 → ② GIF 렌더 → ③ 메타데이터 JSON 저장
+    """
     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),
+        base = os.path.splitext(os.path.basename(input_3d))[0]
+        animated_glb = os.path.join(LOG_PATH, f"animated_{base}.glb")
+        animated_gif = os.path.join(LOG_PATH, f"preview_{base}.gif")
+        json_path = os.path.join(LOG_PATH, f"metadata_{base}.json")
+
+        # 1) GLB 변형
+        modify_glb_file(input_3d, animated_glb, animation_type)
+
+        # 2) 실제 모델 기반 GIF
+        create_model_animation_gif(
+            animated_gif,
+            input_3d,
             animation_type,
             animation_duration,
-            fps
+            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:
+
+        # 3) 메타데이터 기록
+        metadata = dict(
+            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
-        
+
+        return animated_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
+        # 치명적 오류 시: 원본 모델 + 빈 GIF
+        print("Error in process_3d_model:", e)
+        fallback_gif = os.path.join(LOG_PATH, "error.gif")
+        Image.new("RGB", (640, 480), (255, 0, 0)).save(fallback_gif)
+        return input_3d, fallback_gif, None
 
-# Gradio 인터페이스 설정
+
+# ------------------------------------------------------------------
+# 4) Gradio UI
+# ------------------------------------------------------------------
 with gr.Blocks(title="GLB 애니메이션 생성기") as demo:
-    # 제목 섹션
-    gr.Markdown("""
-    <h2><b>GLB 애니메이션 생성기 - 3D 모델 움직임 효과</b></h2>
-
-    이 데모를 통해 정적인 3D 모델(GLB 파일)에 다양한 애니메이션 효과를 적용할 수 있습니다.
-
-    ❗️❗️❗️**중요사항:**
-    - 이 데모는 업로드된 GLB 파일에 애니메이션을 적용합니다.
-    - 다양한 애니메이션 스타일 중에서 선택하세요: 회전, 부유, 폭발, 조립, 펄스, 스윙.
-    - 결과는 애니메이션된 GLB 파일과 미리보기용 GIF 파일로 제공됩니다.
-    """)
-    
+    gr.Markdown(
+        """
+<h2><b>GLB 애니메이션 생성기 - 3D 모델 움직임 효과</b></h2>
+정적인 3D 모델(GLB)에 회전·부유·폭발 등 애니메이션을 적용합니다.
+"""
+    )
+
     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("모델 처리 및 애니메이션 생성")
-            
+            input_3d = gr.Model3D(label="3D 모델 업로드 (GLB)")
+            animation_type = gr.Dropdown(
+                label="애니메이션 유형",
+                choices=["rotate", "float", "explode", "assemble", "pulse", "swing"],
+                value="rotate",
+            )
+            animation_duration = gr.Slider(
+                label="애니메이션 길이 (초)", minimum=1.0, maximum=10.0, value=3.0, step=0.5
+            )
+            fps = gr.Slider(label="FPS", 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 파일을 다운로드하세요.
-    """)
-    
-    # 버튼 동작 설정
+            output_3d = gr.Model3D(label="애니메이션된 GLB")
+            output_gif = gr.Image(label="미리보기 GIF")
+            output_json = gr.File(label="메타데이터 JSON")
+
     submit_btn.click(
         fn=process_3d_model,
         inputs=[input_3d, animation_type, animation_duration, fps],
-        outputs=[output_3d, output_gif, output_json]
+        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,
-        )
 
-# 앱 실행
+    # 예제 GLB 폴더가 있다면 자동 등록
+    example_glbs = [[f] for f in glob.glob("./data/demo_glb/*.glb")]
+    if example_glbs:
+        gr.Examples(examples=example_glbs, inputs=[input_3d])
+
+# ------------------------------------------------------------------
+# 5) 앱 실행
+# ------------------------------------------------------------------
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)