Update app.py

app.py

@@ -1,4 +1,134 @@
-import os
+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)  # 0~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':
+                # 바깥쪽/안쪽으로 움직이는 여러 도형
+                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)
+        
+        # GIF로 저장
+        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 Nonedef create_simple_animation_frames(input_mesh_path, animation_type='rotate', num_frames=30):
+    """간단한 방식으로 애니메이션 프레임 생성 - 다른 방법들이 실패할 경우 대체용"""
+    try:
+        # 메시 로드
+        mesh = trimesh.load(input_mesh_path)
+        
+        # 가장 기본적인 형태로 메시/씬 추출
+        if isinstance(mesh, trimesh.Scene):
+            # 씬에서 첫 번째 메시 추출
+            geometries = list(mesh.geometry.values())
+            if geometries:
+                base_mesh = geometries[0]
+            else:
+                print("No geometries found in scene")
+                return None
+        else:
+            base_mesh = mesh
+        
+        # 애니메이션 프레임 준비
+        frames = []
+        
+        # 단순 회전 애니메이션 생성
+        for i in range(num_frames):
+            angle = i * 2 * math.pi / num_frames
+            
+            # 새 씬 생성
+            scene = trimesh.Scene()
+            
+            # 메시 복사 및 회전
+            rotated_mesh = base_mesh.copy()
+            rotation = tf.rotation_matrix(angle, [0, 1, 0])
+            rotated_mesh.apply_transform(rotation)
+            
+            # 씬에 추가
+            scene.add_geometry(rotated_mesh)
+            
+            # 카메라 설정
+            scene.set_camera()
+            
+            frames.append(scene)
+        
+        return frames
+    except Exception as e:
+        print(f"Error in simple animation: {str(e)}")
+        return Noneimport os
 import time
 import glob
 import json
@@ -75,43 +205,76 @@ print(f"Output directory: {LOG_PATH}")
 
 def normalize_mesh(mesh):
     """Normalize mesh to fit in a unit cube centered at origin"""
-    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
+    try:
+        if isinstance(mesh, trimesh.Scene):
+            # Scene 객체 처리
+            # 씬에서 모든 메시 추출
+            meshes = []
+            for geometry in mesh.geometry.values():
+                if isinstance(geometry, trimesh.Trimesh):
+                    meshes.append(geometry)
+            
+            if not meshes:
+                print("Warning: No meshes found in scene during normalization")
+                return mesh, np.zeros(3), 1.0
+            
+            # 모든 메시의 정점을 결합하여 경계 상자 계산
+            try:
+                all_vertices = np.vstack([m.vertices for m in meshes if hasattr(m, 'vertices') and m.vertices.shape[0] > 0])
+                if len(all_vertices) == 0:
+                    print("Warning: No vertices found in meshes during normalization")
+                    return mesh, np.zeros(3), 1.0
+                    
+                bounds = np.array([all_vertices.min(axis=0), all_vertices.max(axis=0)])
+                center = (bounds[0] + bounds[1]) / 2
+                scale_value = (bounds[1] - bounds[0]).max()
+                if scale_value < 1e-10:
+                    print("Warning: Mesh is too small, using default scale")
+                    scale = 1.0
+                else:
+                    scale = 1.0 / scale_value
+                
+                # 각 메시를 정규화하여 새 씬 생성
+                normalized_scene = trimesh.Scene()
+                for mesh_idx, mesh_obj in enumerate(meshes):
+                    normalized_mesh = mesh_obj.copy()
+                    try:
+                        normalized_mesh.vertices = (normalized_mesh.vertices - center) * scale
+                        normalized_scene.add_geometry(normalized_mesh, node_name=f"normalized_mesh_{mesh_idx}")
+                    except Exception as e:
+                        print(f"Error normalizing mesh {mesh_idx}: {str(e)}")
+                        # 오류가 발생하면 원본 메시 추가
+                        normalized_scene.add_geometry(mesh_obj, node_name=f"original_mesh_{mesh_idx}")
+                
+                return normalized_scene, center, scale
+            except Exception as e:
+                print(f"Error during scene normalization: {str(e)}")
+                return mesh, np.zeros(3), 1.0
+        else:
+            # 일반 Trimesh 객체 처리
+            if not hasattr(mesh, 'vertices') or mesh.vertices.shape[0] == 0:
+                print("Warning: Mesh has no vertices")
+                return mesh, np.zeros(3), 1.0
+                
+            vertices = mesh.vertices
+            bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
+            center = (bounds[0] + bounds[1]) / 2
+            scale_value = (bounds[1] - bounds[0]).max()
+            if scale_value < 1e-10:
+                print("Warning: Mesh is too small, using default scale")
+                scale = 1.0
+            else:
+                scale = 1.0 / scale_value
+            
+            # 복사본 생성하여 원본 변경 방지
+            normalized_mesh = mesh.copy()
+            normalized_mesh.vertices = (vertices - center) * scale
+            
+            return normalized_mesh, center, scale
+    except Exception as e:
+        print(f"Unexpected error in normalize_mesh: {str(e)}")
+        # 오류 발생 시 원본 반환
+        return mesh, np.zeros(3), 1.0
 
 def create_rotation_animation(mesh, duration=3.0, fps=30):
     """Create a rotation animation around the Y axis"""
@@ -119,7 +282,13 @@ def create_rotation_animation(mesh, duration=3.0, fps=30):
     frames = []
     
     # Normalize the mesh for consistent animation
-    mesh, original_center, original_scale = normalize_mesh(mesh)
+    try:
+        mesh, original_center, original_scale = normalize_mesh(mesh)
+        print(f"Normalized mesh center: {original_center}, scale: {original_scale}")
+    except Exception as e:
+        print(f"Error normalizing mesh: {str(e)}")
+        # 정규화에 실패하더라도 계속 진행
+        pass
     
     for frame_idx in range(num_frames):
         t = frame_idx / (num_frames - 1)  # Normalized time [0, 1]
@@ -353,95 +522,206 @@ def generate_gif_from_frames(frames, output_path, fps=30, resolution=(640, 480),
     """Generate a GIF from animation frames"""
     gif_frames = []
     
+    # 모든 프레임의 경계 상자를 계산하여 일관된 카메라 설정 구성
+    all_bounds = []
     for frame in frames:
-        # Create a scene with the frame
-        if not isinstance(frame, trimesh.Scene):
-            scene = trimesh.Scene(frame)
-        else:
-            scene = frame
+        if isinstance(frame, trimesh.Scene):
+            # 씬에서 모든 메시의 정점을 추출하여 경계상자 계산
+            all_points = []
+            for geom in frame.geometry.values():
+                if hasattr(geom, 'vertices') and geom.vertices.shape[0] > 0:
+                    all_points.append(geom.vertices)
+            
+            if all_points:
+                all_vertices = np.vstack(all_points)
+                bounds = np.array([all_vertices.min(axis=0), all_vertices.max(axis=0)])
+                all_bounds.append(bounds)
+        elif hasattr(frame, 'vertices') and frame.vertices.shape[0] > 0:
+            # 일반 메시에서 경계상자 계산
+            bounds = np.array([frame.vertices.min(axis=0), frame.vertices.max(axis=0)])
+            all_bounds.append(bounds)
+    
+    # 모든 프레임을 포함하는 전체 경계상자 계산
+    if all_bounds:
+        min_corner = np.min(np.array([b[0] for b in all_bounds]), axis=0)
+        max_corner = np.max(np.array([b[1] for b in all_bounds]), axis=0)
+        total_bounds = np.array([min_corner, max_corner])
         
-        # 자동 카메라 설정 (전체 장면이 보이도록)
-        try:
-            scene.camera
-        except:
-            # 기본 카메라가 없으면 생성
-            scene.set_camera()
+        # 경계상자 중심과 크기 계산
+        center = (total_bounds[0] + total_bounds[1]) / 2
+        size = np.max(total_bounds[1] - total_bounds[0])
         
-        # 모든 객체가 보이도록 카메라 위치 조정
-        scene.camera_transform = scene.camera_transform
-
-        # Render the frame
+        # 카메라 위치 계산 (적절한 거리에서 객체 바라보기)
+        camera_distance = size * 2.5  # 객체 크기의 2.5배 거리
+    else:
+        # 경계상자를 계산할 수 없으면 기본값 사용
+        center = np.zeros(3)
+        camera_distance = 2.0
+    
+    # 각 프레임 렌더링
+    for i, frame in enumerate(frames):
         try:
-            rendered_img = scene.save_image(resolution=resolution, background=background_color)
-            pil_img = Image.open(rendered_img)
-            gif_frames.append(pil_img)
+            # 씬 객체 생성
+            if not isinstance(frame, trimesh.Scene):
+                scene = trimesh.Scene(frame)
+            else:
+                scene = frame
+            
+            # 더 강력한 카메라 설정 방법
+            try:
+                # 객체가 보이는 위치에 카메라 설정
+                camera_fov = 60.0  # 시야각 (각도)
+                camera_pos = np.array([0, 0, camera_distance])  # 카메라 위치
+                
+                # 카메라 변환 행렬 생성
+                camera_transform = np.eye(4)
+                camera_transform[:3, 3] = camera_pos
+                
+                # 카메라가 원점을 바라보도록 설정
+                scene.camera = trimesh.scene.Camera(
+                    resolution=resolution, 
+                    fov=[camera_fov, camera_fov * (resolution[1] / resolution[0])]
+                )
+                scene.camera_transform = camera_transform
+            except Exception as e:
+                print(f"Error setting camera: {str(e)}")
+                # 기본 카메라 설정
+                scene.set_camera(angles=(0, 0, 0), distance=camera_distance)
+            
+            # 렌더링 시도
+            try:
+                # PyOpenGL 경고 숨기기
+                import warnings
+                warnings.filterwarnings("ignore", category=UserWarning)
+                
+                # 씬 렌더링
+                rendered_img = scene.save_image(resolution=resolution, background=background_color)
+                pil_img = Image.open(rendered_img)
+                
+                # 이미지가 비어있는지 확인
+                if np.array(pil_img).std() < 1.0:  # 표준편차가 작으면 대부분 동일한 색상 (빈 이미지)
+                    print(f"Warning: Frame {i} seems to be empty, trying different angle")
+                    # 다른 각도에서 다시 시도
+                    scene.set_camera(angles=(np.pi/4, np.pi/4, 0), distance=camera_distance*1.2)
+                    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 in main rendering: {str(e)}")
+                # 오프스크린 렌더링 실패 시 간단한 방법으로 시도
+                try:
+                    # 대체 렌더링 메서드
+                    from PIL import Image, ImageDraw
+                    img = Image.new('RGB', resolution, color=(255, 255, 255))
+                    draw = ImageDraw.Draw(img)
+                    
+                    # 프레임 번호를 텍스트로 표시
+                    draw.text((resolution[0]//2, resolution[1]//2), f"Frame {i}", fill=(0, 0, 0))
+                    gif_frames.append(img)
+                except Exception as e2:
+                    print(f"Error in fallback rendering: {str(e2)}")
+                    gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
         except Exception as e:
-            print(f"Error rendering frame: {str(e)}")
-            # 렌더링 실패 시 빈 이미지 생성
+            print(f"Unexpected error in frame processing: {str(e)}")
             gif_frames.append(Image.new('RGB', resolution, (255, 255, 255)))
     
-    # Save as GIF
+    # GIF 저장
     if gif_frames:
-        gif_frames[0].save(
-            output_path,
-            save_all=True,
-            append_images=gif_frames[1:],
-            optimize=False,
-            duration=int(1000 / fps),
-            loop=0
-        )
-        return output_path
+        try:
+            gif_frames[0].save(
+                output_path,
+                save_all=True,
+                append_images=gif_frames[1:],
+                optimize=False,
+                duration=int(1000 / fps),
+                loop=0
+            )
+            print(f"GIF saved to {output_path}")
+            # 확인을 위해 첫 프레임도 따로 저장
+            first_frame_path = output_path.replace('.gif', '_first_frame.png')
+            gif_frames[0].save(first_frame_path)
+            print(f"First frame saved to {first_frame_path}")
+            return output_path
+        except Exception as e:
+            print(f"Error saving GIF: {str(e)}")
+            return None
     else:
+        print("No frames to save")
         return None
 
 def create_animation_mesh(input_mesh_path, animation_type='rotate', duration=3.0, fps=30):
     """Create animation from input mesh based on animation type"""
     # Load the mesh
     try:
+        print(f"Loading mesh from {input_mesh_path}")
         # 먼저 Scene으로 로드 시도
         loaded_obj = trimesh.load(input_mesh_path)
+        print(f"Loaded object type: {type(loaded_obj)}")
         
         # Scene인 경우 단일 메시로 변환 시도
         if isinstance(loaded_obj, trimesh.Scene):
             print("Loaded a scene, extracting meshes...")
             # 씬에서 모든 메시 추출
             meshes = []
-            for geometry in loaded_obj.geometry.values():
+            for geometry_name, geometry in loaded_obj.geometry.items():
                 if isinstance(geometry, trimesh.Trimesh):
+                    print(f"Found mesh: {geometry_name} with {len(geometry.vertices)} vertices")
                     meshes.append(geometry)
             
             if not meshes:
-                print("No meshes found in scene")
-                return None, None
-                
-            # 모든 메시를 하나로 결합
-            mesh = trimesh.util.concatenate(meshes)
+                print("No meshes found in scene, trying simple animation...")
+                frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
+                if not frames:
+                    print("Simple animation failed too")
+                    return None, None
+            else:
+                # 모든 메시를 하나로 결합
+                mesh = loaded_obj
+                print(f"Using original scene with {len(meshes)} meshes")
         elif isinstance(loaded_obj, trimesh.Trimesh):
             mesh = loaded_obj
+            print(f"Loaded a single mesh with {len(mesh.vertices)} vertices")
         else:
             print(f"Unsupported object type: {type(loaded_obj)}")
-            return None, None
-            
+            # 간단한 애니메이션 생성 시도
+            frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
+            if not frames:
+                return None, None
     except Exception as e:
         print(f"Error loading mesh: {str(e)}")
-        return None, None
+        # 간단한 애니메이션 생성 시도
+        frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
+        if not frames:
+            return None, None
     
     # Generate animation frames based on animation type
-    if animation_type == 'rotate':
-        frames = create_rotation_animation(mesh, duration, fps)
-    elif animation_type == 'float':
-        frames = create_float_animation(mesh, duration, fps)
-    elif animation_type == 'explode':
-        frames = create_explode_animation(mesh, duration, fps)
-    elif animation_type == 'assemble':
-        frames = create_assemble_animation(mesh, duration, fps)
-    elif animation_type == 'pulse':
-        frames = create_pulse_animation(mesh, duration, fps)
-    elif animation_type == 'swing':
-        frames = create_swing_animation(mesh, duration, fps)
-    else:
-        print(f"Unknown animation type: {animation_type}")
-        return None, None
+    try:
+        if 'frames' not in locals():  # 이미 frames가 생성되지 않았다면
+            print(f"Generating {animation_type} animation...")
+            if animation_type == 'rotate':
+                frames = create_rotation_animation(mesh, duration, fps)
+            elif animation_type == 'float':
+                frames = create_float_animation(mesh, duration, fps)
+            elif animation_type == 'explode':
+                frames = create_explode_animation(mesh, duration, fps)
+            elif animation_type == 'assemble':
+                frames = create_assemble_animation(mesh, duration, fps)
+            elif animation_type == 'pulse':
+                frames = create_pulse_animation(mesh, duration, fps)
+            elif animation_type == 'swing':
+                frames = create_swing_animation(mesh, duration, fps)
+            else:
+                print(f"Unknown animation type: {animation_type}, using default rotate")
+                frames = create_rotation_animation(mesh, duration, fps)
+    except Exception as e:
+        print(f"Error generating animation: {str(e)}")
+        # 애니메이션 생성 실패 시 간단한 애니메이션 시도
+        frames = create_simple_animation_frames(input_mesh_path, animation_type, int(duration * fps))
+        if not frames:
+            return None, None
+    
+    print(f"Generated {len(frames)} animation frames")
     
     base_filename = os.path.basename(input_mesh_path).rsplit('.', 1)[0]
     
@@ -455,8 +735,12 @@ def create_animation_mesh(input_mesh_path, animation_type='rotate', duration=3.0
             # First frame for static GLB
             first_frame = frames[0]
             # Export as GLB
-            scene = trimesh.Scene(first_frame)
+            if not isinstance(first_frame, trimesh.Scene):
+                scene = trimesh.Scene(first_frame)
+            else:
+                scene = first_frame
             scene.export(animated_glb_path)
+            print(f"Exported GLB to {animated_glb_path}")
         else:
             return None, None
     except Exception as e:
@@ -466,6 +750,7 @@ def create_animation_mesh(input_mesh_path, animation_type='rotate', duration=3.0
     # Create GIF for preview
     try:
         animated_gif_path = os.path.join(LOG_PATH, f'animated_{base_filename}.gif')
+        print(f"Creating GIF at {animated_gif_path}")
         generate_gif_from_frames(frames, animated_gif_path, fps)
     except Exception as e:
         print(f"Error creating GIF: {str(e)}")
@@ -487,8 +772,51 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
             fps=fps
         )
         
-        if not animated_glb_path or not animated_gif_path:
-            return "Error creating animation", None
+        if not animated_glb_path:
+            # 기본 처리가 실패했을 경우 간단한 방식으로 다시 시도
+            print("Primary animation method failed, trying simple animation...")
+            frames = create_simple_animation_frames(
+                input_3d, 
+                animation_type, 
+                int(animation_duration * fps)
+            )
+            
+            if frames:
+                base_filename = os.path.basename(input_3d).rsplit('.', 1)[0]
+                
+                # GLB 저장
+                animated_glb_path = os.path.join(LOG_PATH, f'simple_animated_{base_filename}.glb')
+                if isinstance(frames[0], trimesh.Scene):
+                    scene = frames[0]
+                else:
+                    scene = trimesh.Scene(frames[0])
+                scene.export(animated_glb_path)
+                
+                # GIF 생성
+                animated_gif_path = os.path.join(LOG_PATH, f'simple_animated_{base_filename}.gif')
+                generate_gif_from_frames(frames, animated_gif_path, fps)
+            else:
+                # 모든 메서드가 실패한 경우 텍스트 기반 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, 
+                    os.path.basename(input_3d), 
+                    animation_type, 
+                    animation_duration, 
+                    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:
+                    animated_glb_path = input_3d
+                    print("Could not copy original GLB, using input path")
         
         # Create a simple JSON metadata file
         metadata = {
@@ -503,6 +831,105 @@ def process_3d_model(input_3d, animation_type, animation_duration, fps):
         with open(json_path, 'w') as f:
             json.dump(metadata, f, indent=4)
         
+        # GIF가 없거나 렌더링 실패인 경우를 대비한 백업 GIF 생성
+        if not animated_gif_path:
+            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, 
+                os.path.basename(input_3d), 
+                animation_type, 
+                animation_duration, 
+                fps
+            )
+        
+        return animated_glb_path, animated_gif_path, json_path
+    except Exception as e:
+        error_msg = f"Error processing file: {str(e)}"
+        print(error_msg)
+        
+        # 심각한 오류 발생 시 텍스트 애니메이션이라도 생성
+        try:
+            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, 
+                os.path.basename(input_3d), 
+                animation_type, 
+                animation_duration, 
+                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
+            except:
+                animated_glb_path = input_3d
+                
+            # 메타데이터 생성
+            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"),
+                "error": str(e)
+            }
+            
+            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
+        except:
+            # 모든 방법이 실패한 경우
+            return error_msg, None, None, 50), f"Model: {os.path.basename(input_3d)}", fill=(0, 0, 0))
+                    draw.text((50, 100), f"Animation: {animation_type}", fill=(0, 0, 0))
+                    draw.text((50, 150), f"Angle: {angle}°", fill=(0, 0, 0))
+                    # 간단한 회전 객체 그리기
+                    center_x, center_y = 200, 180
+                    radius = 50
+                    x = center_x + radius * math.cos(math.radians(angle))
+                    y = center_y + radius * math.sin(math.radians(angle))
+                    draw.ellipse((x-20, y-20, x+20, y+20), fill=(255, 0, 0))
+                    simple_frames.append(img)
+                
+                # GIF 저장
+                simple_frames[0].save(
+                    backup_gif_path,
+                    save_all=True,
+                    append_images=simple_frames[1:],
+                    optimize=False,
+                    duration=int(1000 / fps),
+                    loop=0
+                )
+                print(f"Backup GIF created at {backup_gif_path}")
+                
+                # 기존 GIF가 비어있거나 문제가 있으면 백업 GIF 사용
+                try:
+                    # 기존 GIF 확인
+                    original_gif = Image.open(animated_gif_path)
+                    original_frames = []
+                    try:
+                        for i in range(100):  # 최대 100 프레임
+                            original_gif.seek(i)
+                            frame = original_gif.copy()
+                            original_frames.append(frame)
+                    except EOFError:
+                        pass  # 모든 프레임 읽음
+                    
+                    if not original_frames:
+                        print("Original GIF is empty, using backup")
+                        animated_gif_path = backup_gif_path
+                except Exception as e:
+                    print(f"Error checking original GIF: {str(e)}, using backup")
+                    animated_gif_path = backup_gif_path
+            except Exception as e:
+                print(f"Error creating backup GIF: {str(e)}")
+        
         return animated_glb_path, animated_gif_path, json_path
     except Exception as e:
         error_msg = f"Error processing file: {str(e)}"