Update app.py

app.py

@@ -19,6 +19,62 @@ 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 생성 - 렌더링 실패 시 대체용"""
     try:
@@ -107,13 +163,152 @@ 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 파일 생성
+    """
+    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")
+        
+        # 원본 모델 로드
+        scene = trimesh.load(input_glb_path)
+        print(f"Loaded GLB: {type(scene)}")
+        
+        # 애니메이션 유형에 따라 처리
+        if animation_type == 'rotate':
+            # 시계방향 45도 회전
+            angle = math.pi / 4
+            axis = [0, 1, 0]  # Y축 (수직축)
+        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
+        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]
+        
+        # 회전 적용 (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)
+        
+        # 결과 저장
+        scene.export(output_glb_path)
+        print(f"Saved animated GLB to {output_glb_path}")
+        return output_glb_path
+    except Exception as e:
+        print(f"Error creating animated GLB: {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
+        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:
-        # 텍스트 기반 애니메이션 GIF 생성 (렌더링 실패를 우려하여 항상 생성)
+        # 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(
@@ -124,18 +319,7 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
             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 Exception as e:
-            print(f"Error copying GLB: {e}")
-            animated_glb_path = input_3d
-        
-        # 메타데이터 생성
+        # 3. 메타데이터 생성
         metadata = {
             "animation_type": animation_type,
             "duration": animation_duration,