Update app.py

app.py

@@ -4,8 +4,6 @@ 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
@@ -19,101 +17,37 @@ import spaces
 LOG_PATH = './results/demo'
 os.makedirs(LOG_PATH, exist_ok=True)
 
-def create_simple_rotation_animation(input_glb_path, output_glb_path, num_frames=30):
-    """
-    원본 GLB 파일에 회전 애니메이션을 적용한 새로운 GLB 파일 생성
-    """
-    try:
-        # GLB 파일 로드
-        scene = trimesh.load(input_glb_path)
-        
-        if isinstance(scene, trimesh.Scene):
-            # 애니메이션 적용 (첫 번째 프레임만 사용)
-            angle = math.pi / 4  # 45도 회전
-            
-            # 씬의 모든 메시에 회전 적용
-            for node_name, transform, geometry_name in scene.graph.nodes_geometry:
-                # 원본 위치 백업
-                original_transform = scene.graph[node_name][0]
-                
-                # 회전 변환 계산
-                rotation = tf.rotation_matrix(angle, [0, 1, 0])
-                
-                # 새 변환 = 원본 변환 * 회전 변환
-                new_transform = np.dot(original_transform, rotation)
-                
-                # 변환 적용
-                scene.graph[node_name] = new_transform
-            
-            # 회전된 GLB 저장
-            scene.export(output_glb_path)
-            print(f"Saved animated GLB to {output_glb_path}")
-            return output_glb_path
-            
-        elif isinstance(scene, trimesh.Trimesh):
-            # 단일 메시인 경우
-            new_scene = trimesh.Scene()
-            
-            # 메시에 회전 적용
-            angle = math.pi / 4  # 45도 회전
-            rotation = tf.rotation_matrix(angle, [0, 1, 0])
-            scene.apply_transform(rotation)
-            
-            # 회전된 메시를 씬에 추가
-            new_scene.add_geometry(scene)
-            
-            # 씬을 GLB로 저장
-            new_scene.export(output_glb_path)
-            print(f"Saved animated GLB to {output_glb_path}")
-            return output_glb_path
-            
-        else:
-            print(f"Unsupported format: {type(scene)}")
-            return None
-            
-    except Exception as e:
-        print(f"Error creating animation: {str(e)}")
-        return None
-
 def create_textual_animation_gif(output_path, model_name, animation_type, duration=3.0, fps=30):
-    """텍스트 기반의 간단한 애니메이션 GIF 생성 - 렌더링 실패 시 대체용"""
+    """텍스트 기반의 간단한 애니메이션 GIF 생성"""
     try:
-        # 간단한 프레임 시퀀스 생성
         frames = []
         num_frames = int(duration * fps)
-        if num_frames > 60:  # 너무 많은 프레임은 효율적이지 않음
+        if num_frames > 60:
             num_frames = 60
             
         for i in range(num_frames):
-            t = i / (num_frames - 1)  # 0~1 범위
-            angle = t * 360  # 전체 회전
+            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 == 'explode' or animation_type == 'assemble':
-                # 바깥쪽/안쪽으로 움직이는 여러 도형
+                           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
@@ -127,16 +61,12 @@ def create_textual_animation_gif(output_path, model_name, animation_type, durati
                         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),
@@ -145,10 +75,8 @@ def create_textual_animation_gif(output_path, model_name, animation_type, durati
                 ]
                 draw.polygon(points, outline=(0, 0, 0), fill=(255, 165, 0))
             
-            # 프레임 추가
             frames.append(img)
         
-        # GIF로 저장
         frames[0].save(
             output_path,
             save_all=True,
@@ -163,136 +91,66 @@ def create_textual_animation_gif(output_path, model_name, animation_type, durati
         print(f"Error creating textual animation: {str(e)}")
         return None
 
-def create_glb_with_animation(input_glb_path, animation_type, duration=3.0, fps=30):
-    """
-    업로드된 GLB 파일에 애니메이션을 적용한 새로운 GLB 파일 생성
-    """
+def modify_glb_file(input_glb_path, output_glb_path, animation_type='rotate'):
+    """업로드된 GLB 파일을 수정하여 애니메이션 효과를 주는 함수"""
     try:
-        base_filename = os.path.basename(input_glb_path).rsplit('.', 1)[0]
-        output_glb_path = os.path.join(LOG_PATH, f"animated_{base_filename}.glb")
+        # 간단한 방법: 원본 파일을 그대로 로드하여 단일 변환 적용 후 저장
+        # 여러 단계로 나누어 처리하여 각 단계에서 오류를 확인할 수 있도록 함
         
-        # 원본 모델 로드
+        print(f"Step 1: Loading GLB file '{input_glb_path}'")
         scene = trimesh.load(input_glb_path)
-        print(f"Loaded GLB: {type(scene)}")
+        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':
-            # 시계방향 45도 회전
-            angle = math.pi / 4
-            axis = [0, 1, 0]  # Y축 (수직축)
+            # Y축 기준 45도 회전
+            transform = tf.rotation_matrix(math.pi/4, [0, 1, 0])
         elif animation_type == 'float':
-            # 수직으로 움직임
-            angle = 0
-            axis = [0, 1, 0]
-            # Y축 방향으로 이동
-            if isinstance(scene, trimesh.Scene):
-                for node_name, transform, geometry_name in scene.graph.nodes_geometry:
-                    # 가볍게 위로 이동
-                    translation = tf.translation_matrix([0, 0.2, 0])
-                    original_transform = scene.graph[node_name][0]
-                    new_transform = np.dot(original_transform, translation)
-                    scene.graph[node_name] = new_transform
-            elif isinstance(scene, trimesh.Trimesh):
-                translation = tf.translation_matrix([0, 0.2, 0])
-                scene.apply_transform(translation)
-        elif animation_type == 'explode':
-            # 각 부분의 중심에서 약간 멀어지게
-            angle = 0
-            axis = [0, 1, 0]
-            # 오브젝트가 여러 개일 경우 중심에서 바깥쪽으로 이동
-            if isinstance(scene, trimesh.Scene):
-                # 씬의 중심점 계산
-                all_vertices = []
-                for geometry_name, geometry in scene.geometry.items():
-                    if hasattr(geometry, 'vertices') and len(geometry.vertices) > 0:
-                        all_vertices.append(geometry.vertices)
-                
-                if all_vertices:
-                    all_points = np.vstack(all_vertices)
-                    center = np.mean(all_points, axis=0)
-                    
-                    for node_name, transform, geometry_name in scene.graph.nodes_geometry:
-                        # 각 부분의 중심점 계산
-                        geometry = scene.geometry[geometry_name]
-                        if hasattr(geometry, 'centroid'):
-                            part_center = geometry.centroid
-                            # 중심에서 객체 방향 계산
-                            direction = part_center - center
-                            if np.linalg.norm(direction) > 0.001:
-                                direction = direction / np.linalg.norm(direction)
-                                # 방향으로 이동
-                                translation = tf.translation_matrix(direction * 0.2)
-                                original_transform = scene.graph[node_name][0]
-                                new_transform = np.dot(original_transform, translation)
-                                scene.graph[node_name] = new_transform
+            # 위로 이동
+            transform = tf.translation_matrix([0, 0.5, 0])
         elif animation_type == 'pulse':
-            # 모델을 약간 키움
-            scale_factor = 1.2
-            
-            if isinstance(scene, trimesh.Scene):
-                # 씬의 중심점 계산
-                all_vertices = []
-                for geometry_name, geometry in scene.geometry.items():
-                    if hasattr(geometry, 'vertices') and len(geometry.vertices) > 0:
-                        all_vertices.append(geometry.vertices)
-                
-                if all_vertices:
-                    all_points = np.vstack(all_vertices)
-                    center = np.mean(all_points, axis=0)
-                    
-                    for node_name, transform, geometry_name in scene.graph.nodes_geometry:
-                        # 중심 기준 스케일링
-                        translate_to_center = tf.translation_matrix(-center)
-                        scale = np.eye(4)
-                        scale[:3, :3] *= scale_factor
-                        translate_back = tf.translation_matrix(center)
-                        
-                        # 변환 적용
-                        original_transform = scene.graph[node_name][0]
-                        new_transform = np.dot(translate_back, np.dot(scale, np.dot(translate_to_center, original_transform)))
-                        scene.graph[node_name] = new_transform
-            elif isinstance(scene, trimesh.Trimesh):
-                # 메시 중심 기준 스케일링
-                center = scene.centroid
-                translate_to_center = tf.translation_matrix(-center)
-                scale = tf.scale_matrix(scale_factor)
-                translate_back = tf.translation_matrix(center)
-                scene.apply_transform(np.dot(translate_back, np.dot(scale, translate_to_center)))
-        else:
-            # 기본적으로 회전 적용
-            angle = math.pi / 4
-            axis = [0, 1, 0]
+            # 크기 확대
+            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])
         
-        # 회전 적용 (float, explode, pulse 아닌 경우)
-        if angle != 0:
-            if isinstance(scene, trimesh.Scene):
-                # 씬의 모든 부분에 회전 적용
-                for node_name, transform, geometry_name in scene.graph.nodes_geometry:
-                    rotation = tf.rotation_matrix(angle, axis)
-                    original_transform = scene.graph[node_name][0]
-                    new_transform = np.dot(original_transform, rotation)
-                    scene.graph[node_name] = new_transform
-            elif isinstance(scene, trimesh.Trimesh):
-                # 단일 메시에 회전 적용
-                rotation = tf.rotation_matrix(angle, axis)
-                scene.apply_transform(rotation)
+        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"Saved animated GLB to {output_glb_path}")
+        print(f"Successfully exported modified GLB to '{output_glb_path}'")
+        
         return output_glb_path
+    
     except Exception as e:
-        print(f"Error creating animated GLB: {str(e)}")
+        print(f"Error modifying GLB file: {str(e)}")
+        
         # 오류 발생 시 원본 파일 복사
         try:
             import shutil
-            output_path = os.path.join(LOG_PATH, f"copy_{os.path.basename(input_glb_path)}")
-            shutil.copy(input_glb_path, output_path)
-            print(f"Copied original GLB to {output_path}")
-            return output_path
+            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  # 원본 경로 반환
+            return input_glb_path  # 원본 파일 경로 반환
 
 @spaces.GPU
 def process_3d_model(input_3d, animation_type, animation_duration, fps):
@@ -300,19 +158,20 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
     print(f"Processing: {input_3d} with animation type: {animation_type}")
     
     try:
-        # 1. 업로드된 GLB 파일에 실제 애니메이션 적용
-        animated_glb_path = create_glb_with_animation(
-            input_3d,
-            animation_type,
-            animation_duration,
-            fps
-        )
-        
-        # 2. 텍스트 기반 애니메이션 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,
+        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,
@@ -320,6 +179,7 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
         )
         
         # 3. 메타데이터 생성
+        print(f"Creating metadata")
         metadata = {
             "animation_type": animation_type,
             "duration": animation_duration,
@@ -328,15 +188,28 @@ 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_{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
+        
+        print(f"Processing complete, returning results")
+        return modified_glb, animated_gif, json_path
+        
     except Exception as e:
-        error_msg = f"Error processing file: {str(e)}"
-        print(error_msg)
-        return error_msg, None, None
+        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: