Update app.py

app.py

@@ -383,30 +383,94 @@ class WebtoonDatabase:
            conn.commit()
 
 # --- Image Generation ---
+# --- Image Generation Fixed Version ---
 class ImageGenerator:
     """Handle image generation using Replicate API with webtoon-focused prompts"""
    
     def __init__(self):
         self.generation_lock = Lock()
         self.active_generations = {}
+        # 웹툰 표준 크기 설정 (690x1227px)
+        self.target_width = 690
+        self.target_height = 1227
    
+    def resize_image_from_url(self, image_url: str) -> str:
+        """Download image from URL, resize to 690x1227px, and return new URL"""
+        try:
+            import requests
+            from PIL import Image
+            import io as io_module
+            import base64
+            
+            # 이미지 다운로드
+            response = requests.get(image_url, timeout=30)
+            if response.status_code != 200:
+                logger.error(f"Failed to download image: {response.status_code}")
+                return image_url
+            
+            # PIL Image로 변환
+            img = Image.open(io_module.BytesIO(response.content))
+            
+            # 690x1227로 리사이즈 (비율 유지하며 크롭)
+            # 원본 비율 계산
+            original_ratio = img.width / img.height
+            target_ratio = self.target_width / self.target_height
+            
+            if original_ratio > target_ratio:
+                # 원본이 더 넓음 - 높이 맞추고 좌우 크롭
+                new_height = self.target_height
+                new_width = int(new_height * original_ratio)
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                # 중앙 크롭
+                left = (new_width - self.target_width) // 2
+                img = img.crop((left, 0, left + self.target_width, self.target_height))
+            else:
+                # 원본이 더 좁음 - 너비 맞추고 상하 크롭
+                new_width = self.target_width
+                new_height = int(new_width / original_ratio)
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                # 상단 기준 크롭 (웹툰은 상단이 중요)
+                img = img.crop((0, 0, self.target_width, self.target_height))
+            
+            # 임시 파일로 저장
+            with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+                img.save(tmp_file.name, 'JPEG', quality=95)
+                
+                # Base64로 인코딩하여 데이터 URL 생성
+                with open(tmp_file.name, 'rb') as f:
+                    img_data = f.read()
+                    base64_data = base64.b64encode(img_data).decode('utf-8')
+                    data_url = f"data:image/jpeg;base64,{base64_data}"
+                
+                # 임시 파일 삭제
+                try:
+                    os.unlink(tmp_file.name)
+                except:
+                    pass
+                    
+                return data_url
+                
+        except Exception as e:
+            logger.error(f"Error resizing image: {e}")
+            return image_url
+    
     def enhance_prompt_for_webtoon(self, prompt: str, panel_number: int, scene_type: str = "medium", genre: str = "로맨스") -> str:
         """Enhanced prompt for webtoon-style panels focusing on action and scenes"""
        
         # 웹툰 스타일 기본 설정
-        base_style = "webtoon style, manhwa illustration, clean line art, vibrant colors"
+        base_style = "webtoon style, manhwa illustration, clean line art, vibrant colors, vertical format"
        
         # 장르별 스타일 조정
         genre_styles = {
-            "로맨스": "soft colors, romantic atmosphere, emotional lighting",
-            "판타지": "dynamic action, magical effects, epic atmosphere",
-            "스릴러": "dark tones, dramatic shadows, suspenseful mood",
-            "일상": "warm colors, everyday scenes, comfortable atmosphere",
-            "개그": "exaggerated expressions, comedic style, bright colors",
-            "스포츠": "dynamic motion, athletic poses, energetic atmosphere",
-            "무협": "martial arts action, eastern style, dramatic poses",
-            "로판": "fantasy romance, elegant costumes, magical atmosphere",
-            "현판": "modern fantasy, urban setting, supernatural effects"
+            "로맨스": "soft colors, romantic atmosphere, emotional lighting, shoujo manga style",
+            "판타지": "dynamic action, magical effects, epic atmosphere, detailed backgrounds",
+            "스릴러": "dark tones, dramatic shadows, suspenseful mood, noir style",
+            "일상": "warm colors, everyday scenes, comfortable atmosphere, slice of life",
+            "개그": "exaggerated expressions, comedic style, bright colors, cartoon style",
+            "스포츠": "dynamic motion, athletic poses, energetic atmosphere, action lines",
+            "무협": "martial arts action, eastern style, dramatic poses, wuxia aesthetic",
+            "로판": "fantasy romance, elegant costumes, magical atmosphere, ornate details",
+            "현판": "modern fantasy, urban setting, supernatural effects, contemporary style"
         }
        
         # 씬 타입별 카메라 앵글과 구도
@@ -437,8 +501,8 @@ class ImageGenerator:
         else:
             action_emphasis = "clear composition, focused scene"
        
-        # 웹툰 패널 특성
-        panel_style = "single panel illustration, vertical scroll webtoon format, story panel"
+        # 웹툰 패널 특성 (9:16 비율 강조)
+        panel_style = "single panel illustration, 9:16 aspect ratio, vertical scroll webtoon format, story panel"
        
         # 배경과 환경 강조
         if "establishing" in scene_type or "wide" in scene_type:
@@ -466,7 +530,7 @@ class ImageGenerator:
     def generate_image(self, prompt: str, panel_id: str, session_id: str, 
                       scene_type: str = "medium", genre: str = "로맨스", 
                       progress_callback=None) -> Dict[str, Any]:
-        """Generate image using Qwen-Image API with webtoon optimization"""
+        """Generate image using Replicate API with webtoon optimization and size control"""
         try:
             if not REPLICATE_API_TOKEN:
                 logger.warning("No Replicate API token")
@@ -478,72 +542,135 @@ class ImageGenerator:
             # 웹툰 스타일 프롬프트 강화
             enhanced_prompt = self.enhance_prompt_for_webtoon(prompt, panel_number, scene_type, genre)
             
-            # Qwen-Image 파라미터 (웹툰 최적화)
-            input_params = {
-                "prompt": enhanced_prompt,
-                "negative_prompt": "low quality, blurry, distorted, bad anatomy, text errors",
-                "num_inference_steps": 50,  # 빠른 생성을 위해 낮춤
-                "guidance": 3.5,  # 실사감과 스타일 균형
-                "aspect_ratio": "9:16",  # 세로형 웹툰
-                "image_size": "optimize_for_quality",
-                "go_fast": True,  # 속도 최적화
-                "enhance_prompt": True,  # 프롬프트 자동 개선
-                "output_format": "jpg",
-                "output_quality": 100
-            }
+            # 사용 가능한 모델 목록 (우선순위 순)
+            models_to_try = [
+                {
+                    "model": "black-forest-labs/flux-dev",
+                    "params": {
+                        "prompt": enhanced_prompt,
+                        "aspect_ratio": "9:16",
+                        "num_outputs": 1,
+                        "guidance": 3.5,
+                        "num_inference_steps": 28,
+                        "output_format": "jpg",
+                        "output_quality": 95
+                    }
+                },
+                {
+                    "model": "stability-ai/sdxl",
+                    "params": {
+                        "prompt": enhanced_prompt,
+                        "negative_prompt": "low quality, blurry, distorted, bad anatomy, text errors, watermark",
+                        "width": 768,
+                        "height": 1344,
+                        "num_inference_steps": 30,
+                        "guidance_scale": 7.5,
+                        "scheduler": "K_EULER",
+                        "num_outputs": 1
+                    }
+                },
+                {
+                    "model": "playgroundai/playground-v2.5-1024px-aesthetic",
+                    "params": {
+                        "prompt": enhanced_prompt,
+                        "width": 768,
+                        "height": 1344,
+                        "scheduler": "K_EULER_ANCESTRAL",
+                        "guidance_scale": 3,
+                        "num_inference_steps": 25,
+                        "negative_prompt": "ugly, deformed, noisy, blurry, low contrast"
+                    }
+                }
+            ]
             
-            # 장르별 LoRA 적용 (있을 경우)
-            webtoon_loras = {
-                "로맨스": "fofr/flux-anime-romance",  # 예시
-                "판타지": "fofr/flux-fantasy-art",    # 예시
-            }
-        
-            if genre in webtoon_loras:
-                input_params["lora_weights"] = webtoon_loras[genre]
-
-            output = replicate.run(
-                "qwen/qwen-image",
-                input=input_params
-            )
+            # 각 모델 시도
+            for model_config in models_to_try:
+                try:
+                    logger.info(f"Trying model: {model_config['model']}")
+                    
+                    output = replicate.run(
+                        model_config["model"],
+                        input=model_config["params"]
+                    )
+                    
+                    if output:
+                        # Replicate returns different formats depending on the model
+                        if isinstance(output, list) and len(output) > 0:
+                            image_item = output[0]
+                            if hasattr(image_item, 'url'):
+                                image_url = image_item.url() if callable(image_item.url) else str(image_item.url)
+                            else:
+                                image_url = str(image_item)
+                        elif isinstance(output, str):
+                            image_url = output
+                        elif hasattr(output, 'url'):
+                            image_url = output.url() if callable(output.url) else str(output.url)
+                        else:
+                            image_url = str(output)
+                        
+                        # 이미지 크기 조정 (690x1227)
+                        logger.info(f"Resizing image to {self.target_width}x{self.target_height}")
+                        resized_url = self.resize_image_from_url(image_url)
+                        
+                        # 캐시 저장
+                        cache_key = f"{session_id}_{panel_id}"
+                        generated_images_cache[cache_key] = resized_url
+                        
+                        logger.info(f"Successfully generated and resized image for panel {panel_id}")
+                        return {
+                            "panel_id": panel_id,
+                            "status": "success",
+                            "image_url": resized_url,
+                            "original_url": image_url,
+                            "prompt": enhanced_prompt,
+                            "model_used": model_config["model"]
+                        }
+                    
+                except Exception as model_error:
+                    logger.warning(f"Model {model_config['model']} failed: {model_error}")
+                    continue
             
-            if output:
-                # Replicate returns different formats depending on the model
-                # Handle both list and direct URL responses
-                if isinstance(output, list) and len(output) > 0:
-                    # If it's a list, get the first item
-                    image_item = output[0]
-                    # Check if it has a url method or if it's already a string
-                    if hasattr(image_item, 'url') and callable(image_item.url):
-                        image_url = image_item.url()
-                    else:
-                        image_url = str(image_item)
-                elif isinstance(output, str):
-                    # Direct string URL
-                    image_url = output
-                else:
-                    # Try to convert to string as fallback
-                    image_url = str(output)
-                
-                # 캐시 저장
-                cache_key = f"{session_id}_{panel_id}"
-                generated_images_cache[cache_key] = image_url
-                
-                logger.info(f"Successfully generated image for panel {panel_id}")
-                return {
-                    "panel_id": panel_id,
-                    "status": "success",
-                    "image_url": image_url,
-                    "prompt": enhanced_prompt
-                }
-            else:
-                logger.error(f"No output from Replicate for panel {panel_id}")
-                return {"panel_id": panel_id, "status": "error", "message": "No output from model"}
-
+            # 모든 모델 실패
+            logger.error(f"All models failed for panel {panel_id}")
+            return {"panel_id": panel_id, "status": "error", "message": "All models failed"}
                 
         except Exception as e:
             logger.error(f"Image generation error: {e}")
             return {"panel_id": panel_id, "status": "error", "message": str(e)}
 
+    def generate_batch_images(self, panels: List[Dict], session_id: str, 
+                            character_profiles: Dict, genre: str = "로맨스",
+                            progress_callback=None) -> List[Dict]:
+        """배치로 여러 패널 이미지 생성"""
+        results = []
+        total = len(panels)
+        
+        for i, panel in enumerate(panels):
+            if progress_callback:
+                progress_callback((i / total), f"패널 {panel['number']}/{total} 생성 중...")
+            
+            panel_id = f"ep1_panel{panel['number']}"
+            prompt = panel.get('prompt_en', panel.get('prompt', ''))
+            scene_type = panel.get('scene_type', 'medium')
+            
+            result = self.generate_image(
+                prompt=prompt,
+                panel_id=panel_id,
+                session_id=session_id,
+                scene_type=scene_type,
+                genre=genre
+            )
+            
+            results.append(result)
+            
+            # API 제한 방지를 위한 대기
+            time.sleep(1)
+        
+        if progress_callback:
+            progress_callback(1.0, "이미지 생성 완료!")
+        
+        return results
+
 # --- LLM Integration ---
 class WebtoonSystem:
    """Webtoon planning and storyboard generation system"""