Update app.py

app.py

@@ -75,16 +75,43 @@ print(f"Output directory: {LOG_PATH}")
 
 def normalize_mesh(mesh):
     """Normalize mesh to fit in a unit cube centered at origin"""
-    vertices = mesh.vertices
-    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
-    center = (bounds[0] + bounds[1]) / 2
-    scale = 1.0 / (bounds[1] - bounds[0]).max()
-    
-    # Create a copy to avoid modifying the original
-    normalized_mesh = mesh.copy()
-    normalized_mesh.vertices = (vertices - center) * scale
-    
-    return normalized_mesh, center, scale
+    if isinstance(mesh, trimesh.Scene):
+        # Scene 객체 처리
+        # 씬에서 모든 메시 추출
+        meshes = []
+        for geometry in mesh.geometry.values():
+            if isinstance(geometry, trimesh.Trimesh):
+                meshes.append(geometry)
+        
+        if not meshes:
+            raise ValueError("No meshes found in scene")
+        
+        # 모든 메시의 정점을 결합하여 경계 상자 계산
+        all_vertices = np.vstack([m.vertices for m in meshes])
+        bounds = np.array([all_vertices.min(axis=0), all_vertices.max(axis=0)])
+        center = (bounds[0] + bounds[1]) / 2
+        scale = 1.0 / (bounds[1] - bounds[0]).max()
+        
+        # 각 메시를 정규화하여 새 씬 생성
+        normalized_scene = trimesh.Scene()
+        for mesh_obj in meshes:
+            normalized_mesh = mesh_obj.copy()
+            normalized_mesh.vertices = (normalized_mesh.vertices - center) * scale
+            normalized_scene.add_geometry(normalized_mesh)
+        
+        return normalized_scene, center, scale
+    else:
+        # 일반 Trimesh 객체 처리
+        vertices = mesh.vertices
+        bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
+        center = (bounds[0] + bounds[1]) / 2
+        scale = 1.0 / (bounds[1] - bounds[0]).max()
+        
+        # 복사본 생성하여 원본 변경 방지
+        normalized_mesh = mesh.copy()
+        normalized_mesh.vertices = (vertices - center) * scale
+        
+        return normalized_mesh, center, scale
 
 def create_rotation_animation(mesh, duration=3.0, fps=30):
     """Create a rotation animation around the Y axis"""
@@ -98,15 +125,33 @@ def create_rotation_animation(mesh, duration=3.0, fps=30):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
         angle = t * 2 * math.pi  # Full rotation
         
-        # Create a copy of the mesh to animate
-        animated_mesh = mesh.copy()
-        
-        # Apply rotation around Y axis
-        rotation_matrix = tf.rotation_matrix(angle, [0, 1, 0])
-        animated_mesh.apply_transform(rotation_matrix)
-        
-        # Add to frames
-        frames.append(animated_mesh)
+        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
 
@@ -120,17 +165,30 @@ def create_float_animation(mesh, duration=3.0, fps=30, amplitude=0.2):
     
     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 floating motion (sinusoidal)
         y_offset = amplitude * math.sin(2 * math.pi * t)
-        translation_matrix = tf.translation_matrix([0, y_offset, 0])
-        animated_mesh.apply_transform(translation_matrix)
         
-        # Add to frames
-        frames.append(animated_mesh)
+        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
 
@@ -142,64 +200,98 @@ def create_explode_animation(mesh, duration=3.0, fps=30):
     # Normalize the mesh for consistent animation
     mesh, original_center, original_scale = normalize_mesh(mesh)
     
-    # Split the mesh into components
-    # If the mesh can't be split, we'll just move vertices outward
-    try:
-        components = mesh.split(only_watertight=False)
-        if len(components) <= 1:
-            raise ValueError("Mesh cannot be split into components")
-    except:
-        # If splitting fails, work with the original mesh
-        components = None
-    
-    for frame_idx in range(num_frames):
-        t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
-        
-        if components:
-            # Create a scene to hold all components
-            scene = trimesh.Scene()
+    # 씬인 경우 부분별 처리
+    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()
             
-            # Move each component outward from center
-            for component in components:
-                # Create a copy of the component
-                animated_component = component.copy()
+            # 각 노드별 폭발 애니메이션 적용
+            for node_name, transform, geometry_name in mesh.graph.nodes_geometry:
+                mesh_copy = mesh.geometry[geometry_name].copy()
                 
-                # Calculate direction from center to component centroid
-                direction = animated_component.centroid
+                # 노드의 중심점 계산
+                center_point = mesh_copy.centroid if hasattr(mesh_copy, 'centroid') else np.zeros(3)
+                
+                # 방향 벡터 (원점에서 객체 중심까지)
+                direction = center_point
                 if np.linalg.norm(direction) < 1e-10:
-                    # If component is at center, choose random direction
+                    # 중심점이 원점과 너무 가까우면 랜덤 방향 선택
                     direction = np.random.rand(3) - 0.5
                 
                 direction = direction / np.linalg.norm(direction)
                 
-                # Apply explosion movement
-                translation = direction * t * 0.5  # Scale factor for explosion
+                # 폭발 이동 적용
+                translation = direction * t * 0.5  # 폭발 강도 조절
                 translation_matrix = tf.translation_matrix(translation)
-                animated_component.apply_transform(translation_matrix)
+                mesh_copy.apply_transform(translation_matrix)
                 
-                # Add to scene
-                scene.add_geometry(animated_component)
+                # 씬에 추가
+                frame_scene.add_geometry(mesh_copy, node_name=f"{node_name}_{frame_idx}")
             
-            # Convert scene to mesh (approximation)
-            animated_mesh = trimesh.util.concatenate(scene.dump())
+            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:
-            # Work with vertices directly if components approach failed
-            animated_mesh = mesh.copy()
-            vertices = animated_mesh.vertices.copy()
-            
-            # Calculate directions from center (0,0,0) to each vertex
-            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
-            
-            # Apply explosion factor
-            vertices += directions * t * 0.3
-            animated_mesh.vertices = vertices
-        
-        # Add to frames
-        frames.append(animated_mesh)
+            # 컴포넌트 기반 폭발 애니메이션
+            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
 
@@ -263,23 +355,29 @@ def generate_gif_from_frames(frames, output_path, fps=30, resolution=(640, 480),
     
     for frame in frames:
         # Create a scene with the frame
-        scene = trimesh.Scene(frame)
+        if not isinstance(frame, trimesh.Scene):
+            scene = trimesh.Scene(frame)
+        else:
+            scene = frame
         
-        # Set camera and rendering parameters
+        # 자동 카메라 설정 (전체 장면이 보이도록)
         try:
-            # Try to get a good view of the object
-            scene.camera_transform = scene.camera_transform
+            scene.camera
         except:
-            # If that fails, use a default camera position
-            scene.camera_transform = tf.translation_matrix([0, 0, 2])
+            # 기본 카메라가 없으면 생성
+            scene.set_camera()
         
+        # 모든 객체가 보이도록 카메라 위치 조정
+        scene.camera_transform = scene.camera_transform
+
         # Render the frame
         try:
-            img = scene.save_image(resolution=resolution, background=background_color)
-            gif_frames.append(Image.open(img))
+            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 rendering frame: {str(e)}")
-            # Create a blank image if rendering fails
+            # 렌더링 실패 시 빈 이미지 생성
             gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
     
     # Save as GIF
@@ -300,7 +398,30 @@ def create_animation_mesh(input_mesh_path, animation_type='rotate', duration=3.0
     """Create animation from input mesh based on animation type"""
     # Load the mesh
     try:
-        mesh = trimesh.load(input_mesh_path)
+        # 먼저 Scene으로 로드 시도
+        loaded_obj = trimesh.load(input_mesh_path)
+        
+        # Scene인 경우 단일 메시로 변환 시도
+        if isinstance(loaded_obj, trimesh.Scene):
+            print("Loaded a scene, extracting meshes...")
+            # 씬에서 모든 메시 추출
+            meshes = []
+            for geometry in loaded_obj.geometry.values():
+                if isinstance(geometry, trimesh.Trimesh):
+                    meshes.append(geometry)
+            
+            if not meshes:
+                print("No meshes found in scene")
+                return None, None
+                
+            # 모든 메시를 하나로 결합
+            mesh = trimesh.util.concatenate(meshes)
+        elif isinstance(loaded_obj, trimesh.Trimesh):
+            mesh = loaded_obj
+        else:
+            print(f"Unsupported object type: {type(loaded_obj)}")
+            return None, None
+            
     except Exception as e:
         print(f"Error loading mesh: {str(e)}")
         return None, None