Update app.py

app.py

@@ -17,6 +17,10 @@ from dataclasses import dataclass, field, asdict
 from collections import defaultdict
 import random
 from huggingface_hub import HfApi, upload_file, hf_hub_download
+import replicate
+from PIL import Image
+import io as io_module
+import base64
 
 # --- Logging setup ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -35,16 +39,19 @@ except ImportError:
     DOCX_AVAILABLE = False
     logger.warning("python-docx not installed. DOCX export will be disabled.")
 
-import io  # Add io import for DOCX export
-
 # --- Environment variables and constants ---
 FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
+REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
 MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
 DB_PATH = "webtoon_sessions_v1.db"
 
-# Target settings for webtoon - UPDATED FOR WEBTOON
+# Initialize Replicate client if token exists
+if REPLICATE_API_TOKEN:
+    os.environ["REPLICATE_API_TOKEN"] = REPLICATE_API_TOKEN
+
+# Target settings for webtoon
 TARGET_EPISODES = 40  # 40화 완결
 PANELS_PER_EPISODE = 30  # 각 화당 30개 패널
 TARGET_PANELS = TARGET_EPISODES * PANELS_PER_EPISODE  # 총 1200 패널
@@ -62,24 +69,49 @@ WEBTOON_GENRES = {
     "스포츠": "Sports"
 }
 
+# Celebrity face references for character design
+CELEBRITY_FACES = {
+    "male": [
+        "톰 크루즈", "브래드 피트", "레오나르도 디카프리오", "라이언 고슬링", 
+        "크리스 헴스워스", "로버트 다우니 주니어", "크리스 에반스", "톰 히들스턴",
+        "베네딕트 컴버배치", "키아누 리브스", "이병헌", "공유", "박서준", "송중기"
+    ],
+    "female": [
+        "스칼렛 요한슨", "엠마 왓슨", "제니퍼 로렌스", "갤 가돗", 
+        "마고 로비", "엠마 스톤", "앤 해서웨이", "나탈리 포트만",
+        "전지현", "송혜교", "김태리", "아이유", "수지", "한소희"
+    ]
+}
+
 # --- Environment validation ---
 if not FIREWORKS_API_KEY:
     logger.error("FIREWORKS_API_KEY not set. Application will not work properly.")
     FIREWORKS_API_KEY = "dummy_token_for_testing"
 
-if not BRAVE_SEARCH_API_KEY:
-    logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
+if not REPLICATE_API_TOKEN:
+    logger.warning("REPLICATE_API_TOKEN not set. Image generation will be disabled.")
 
 # --- Global variables ---
 db_lock = threading.Lock()
+generated_images_cache = {}  # Cache for generated images
 
 # --- Data classes ---
+@dataclass
+class CharacterProfile:
+    """Character profile with celebrity lookalike"""
+    name: str
+    role: str
+    personality: str
+    appearance: str
+    celebrity_lookalike: str
+    gender: str
+
 @dataclass
 class WebtoonBible:
     """Webtoon story bible for maintaining consistency"""
     genre: str = ""
     title: str = ""
-    characters: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    characters: Dict[str, CharacterProfile] = field(default_factory=dict)
     settings: Dict[str, str] = field(default_factory=dict)
     plot_points: List[Dict[str, Any]] = field(default_factory=list)
     episode_hooks: Dict[int, str] = field(default_factory=dict)
@@ -92,13 +124,14 @@ class StoryboardPanel:
     """Individual storyboard panel"""
     panel_number: int
     scene_type: str  # wide, close-up, medium, establishing
-    image_prompt: str  # Image generation prompt with gfwm trigger
+    image_prompt: str  # Image generation prompt with character descriptions
     dialogue: List[str] = field(default_factory=list)
     narration: str = ""
     sound_effects: List[str] = field(default_factory=list)
     emotion_notes: str = ""
     camera_angle: str = ""
     background: str = ""
+    characters_in_scene: List[str] = field(default_factory=list)  # Character names in this panel
 
 @dataclass
 class EpisodeStoryboard:
@@ -167,20 +200,6 @@ GENRE_ELEMENTS = {
     }
 }
 
-# Panel composition types
-PANEL_COMPOSITIONS = {
-    "establishing": "전체 배경과 분위기를 보여주는 원거리 샷",
-    "wide": "캐릭터와 배경이 모두 보이는 와이드 샷",
-    "medium": "캐릭터 상반신이 보이는 미디엄 샷",
-    "close_up": "얼굴이나 표정에 집중하는 클로즈업",
-    "extreme_close_up": "눈, 입 등 특정 부위 극단 클로즈업",
-    "over_shoulder": "어깨 너머로 보는 오버숄더 샷",
-    "dutch_angle": "긴장감을 위한 기울어진 앵글",
-    "bird_eye": "위에서 내려다보는 부감 샷",
-    "worm_eye": "아래서 올려다보는 앙각 샷",
-    "action": "움직임을 강조하는 액션 샷"
-}
-
 # --- Core logic classes ---
 class WebtoonTracker:
     """Webtoon narrative and storyboard tracker"""
@@ -189,11 +208,17 @@ class WebtoonTracker:
         self.episode_storyboards: Dict[int, EpisodeStoryboard] = {}
         self.episodes: Dict[int, str] = {}
         self.total_panel_count = 0
+        self.character_profiles: Dict[str, CharacterProfile] = {}
         
     def set_genre(self, genre: str):
         """Set the webtoon genre"""
         self.story_bible.genre = genre
         self.story_bible.genre_elements = GENRE_ELEMENTS.get(genre, {})
+    
+    def add_character(self, character: CharacterProfile):
+        """Add character with celebrity lookalike"""
+        self.character_profiles[character.name] = character
+        self.story_bible.characters[character.name] = character
         
     def add_storyboard(self, episode_num: int, storyboard: EpisodeStoryboard):
         """Add episode storyboard"""
@@ -223,7 +248,8 @@ class WebtoonDatabase:
                     total_episodes INTEGER DEFAULT 40,
                     planning_doc TEXT,
                     story_bible TEXT,
-                    visual_style TEXT
+                    visual_style TEXT,
+                    character_profiles TEXT
                 )
             ''')
             
@@ -243,7 +269,7 @@ class WebtoonDatabase:
                 )
             ''')
             
-            # Panels table
+            # Panels table with image data
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS panels (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -255,6 +281,7 @@ class WebtoonDatabase:
                     dialogue TEXT,
                     narration TEXT,
                     sound_effects TEXT,
+                    generated_image TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                 )
@@ -313,6 +340,57 @@ class WebtoonDatabase:
                       json.dumps(panel.sound_effects)))
             
             conn.commit()
+    
+    @staticmethod
+    def save_character_profiles(session_id: str, profiles: Dict[str, CharacterProfile]):
+        with WebtoonDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            profiles_json = json.dumps({name: asdict(profile) for name, profile in profiles.items()})
+            cursor.execute(
+                "UPDATE sessions SET character_profiles = ? WHERE session_id = ?",
+                (profiles_json, session_id)
+            )
+            conn.commit()
+
+# --- Image Generation ---
+class ImageGenerator:
+    """Handle image generation using Replicate API"""
+    
+    @staticmethod
+    def generate_image(prompt: str, panel_num: int, session_id: str) -> Optional[str]:
+        """Generate image using Replicate API"""
+        try:
+            if not REPLICATE_API_TOKEN:
+                logger.warning("No Replicate API token, returning placeholder")
+                return None
+            
+            # Run the model
+            input_params = {
+                "prompt": prompt,
+                "num_inference_steps": 25,
+                "guidance_scale": 7.5
+            }
+            
+            output = replicate.run(
+                "qwen/qwen-image",
+                input=input_params
+            )
+            
+            # Get the image URL
+            if output and len(output) > 0:
+                image_url = output[0].url() if hasattr(output[0], 'url') else str(output[0])
+                
+                # Cache the image
+                cache_key = f"{session_id}_{panel_num}"
+                generated_images_cache[cache_key] = image_url
+                
+                return image_url
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Image generation error: {e}")
+            return None
 
 # --- LLM Integration ---
 class WebtoonSystem:
@@ -323,6 +401,7 @@ class WebtoonSystem:
         self.model_id = MODEL_ID
         self.tracker = WebtoonTracker()
         self.current_session_id = None
+        self.image_generator = ImageGenerator()
         WebtoonDatabase.init_db()
 
     def create_headers(self):
@@ -331,10 +410,40 @@ class WebtoonSystem:
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self.api_key}"
         }
+    
+    def assign_celebrity_lookalikes(self, characters: List[Dict]) -> Dict[str, CharacterProfile]:
+        """Assign celebrity lookalikes to characters"""
+        profiles = {}
+        used_celebrities = []
+        
+        for char in characters:
+            gender = char.get('gender', 'male')
+            available_celebrities = [c for c in CELEBRITY_FACES.get(gender, []) 
+                                    if c not in used_celebrities]
+            
+            if not available_celebrities:
+                available_celebrities = CELEBRITY_FACES.get(gender, [])
+            
+            celebrity = random.choice(available_celebrities)
+            used_celebrities.append(celebrity)
+            
+            profile = CharacterProfile(
+                name=char.get('name', ''),
+                role=char.get('role', ''),
+                personality=char.get('personality', ''),
+                appearance=char.get('appearance', ''),
+                celebrity_lookalike=celebrity,
+                gender=gender
+            )
+            
+            profiles[profile.name] = profile
+            self.tracker.add_character(profile)
+        
+        return profiles
 
     # --- Prompt generation functions ---
     def create_planning_prompt(self, query: str, genre: str, language: str) -> str:
-        """Create initial planning prompt for webtoon"""
+        """Create initial planning prompt for webtoon with character profiles"""
         genre_info = GENRE_ELEMENTS.get(genre, {})
         
         lang_prompts = {
@@ -346,26 +455,15 @@ class WebtoonSystem:
 **장르:** {genre}
 **목표:** 40화 완결 웹툰
 
-⚠️ **중요**: 위에 제시된 스토리 설정을 반드시 기반으로 하여 플롯을 구성하세요.
+⚠️ **중요**: 
+1. 위에 제시된 스토리 설정을 반드시 기반으로 하여 플롯을 구성하세요.
+2. 각 캐릭터의 성별(gender)을 명확히 지정하세요 (male/female).
 
 **장르 필수 요소:**
 - 핵심 요소: {', '.join(genre_info.get('key_elements', []))}
 - 비주얼 스타일: {', '.join(genre_info.get('visual_styles', []))}
 - 주요 씬: {', '.join(genre_info.get('typical_scenes', []))}
 
-**전체 구성 (40화 기준):**
-1. **1-5화**: 세계관 소개, 주인공 등장, 핵심 갈등 제시
-2. **6-15화**: 갈등 심화, 캐릭터 관계 발전, 서브플롯 전개
-3. **16-25화**: 중간 클라이맥스, 반전, 새로운 위기
-4. **26-35화**: 최종 갈등 고조, 결전 준비
-5. **36-40화**: 클라이맥스, 해결, 에필로그
-
-**웹툰 특화 요소:**
-- 매 화 마지막 강력한 클리프행어
-- 세로 스크롤에 적합한 연출
-- 임팩트 있는 대사와 액션
-- 독자 댓글을 유발하는 전개
-
 다음 형식으로 작성하세요:
 
 📚 **작품 제목:** [임팩트 있는 제목]
@@ -375,10 +473,10 @@ class WebtoonSystem:
 - 색감: [주요 색상 톤]
 - 캐릭터 디자인 특징: [주인공들의 비주얼 특징]
 
-👥 **주요 캐릭터:**
-- 주인공: [이름] - [외모 특징, 성격, 목표]
-- 캐릭터2: [이름] - [역할, 특징]
-- 캐릭터3: [이름] - [역할, 특징]
+👥 **주요 캐릭터:** (각 캐릭터마다 성별을 반드시 명시!)
+- 주인공: [이름] - 성별: [male/female] - [외모 특징, 성격, 목표]
+- 캐릭터2: [이름] - 성별: [male/female] - [역할, 특징]
+- 캐릭터3: [이름] - 성별: [male/female] - [역할, 특징]
 
 📖 **시놉시스:**
 [3-4줄로 전체 스토리 요약]
@@ -399,26 +497,15 @@ class WebtoonSystem:
 **Genre:** {genre}
 **Goal:** 40 episodes webtoon
 
-⚠️ **IMPORTANT**: You MUST base the plot on the story setting provided above.
+⚠️ **IMPORTANT**: 
+1. You MUST base the plot on the story setting provided above.
+2. Clearly specify each character's gender (male/female).
 
 **Genre Requirements:**
 - Key elements: {', '.join(genre_info.get('key_elements', []))}
 - Visual styles: {', '.join(genre_info.get('visual_styles', []))}
 - Typical scenes: {', '.join(genre_info.get('typical_scenes', []))}
 
-**Overall Structure (40 episodes):**
-1. **Episodes 1-5**: World introduction, protagonist debut, core conflict
-2. **Episodes 6-15**: Deepening conflict, character development, subplots
-3. **Episodes 16-25**: Mid-climax, plot twist, new crisis
-4. **Episodes 26-35**: Final conflict escalation, preparation for showdown
-5. **Episodes 36-40**: Climax, resolution, epilogue
-
-**Webtoon-specific elements:**
-- Strong cliffhanger at end of each episode
-- Vertical scroll-optimized directing
-- Impactful dialogue and action
-- Comment-inducing development
-
 Format as follows:
 
 📚 **Title:** [Impactful title]
@@ -428,49 +515,53 @@ Format as follows:
 - Color tone: [Main color palette]
 - Character design: [Visual characteristics]
 
-👥 **Main Characters:**
-- Protagonist: [Name] - [Appearance, personality, goal]
-- Character2: [Name] - [Role, traits]
-- Character3: [Name] - [Role, traits]
+👥 **Main Characters:** (Must specify gender for each!)
+- Protagonist: [Name] - Gender: [male/female] - [Appearance, personality, goal]
+- Character2: [Name] - Gender: [male/female] - [Role, traits]
+- Character3: [Name] - Gender: [male/female] - [Role, traits]
 
 📖 **Synopsis:**
 [3-4 line story summary]
 
 📝 **40 Episode Structure:**
-Include key events and cliffhangers for each episode.
-
-Episode 1: [Title] - [Key event] - Cliffhanger: [Shocking ending]
-Episode 2: [Title] - [Key event] - Cliffhanger: [Shocking ending]
-...
-Episode 40: [Title] - [Key event] - [Grand finale]"""
+Include key events and cliffhangers for each episode."""
         }
         
         return lang_prompts.get(language, lang_prompts["Korean"])
 
     def create_storyboard_prompt(self, episode_num: int, plot_outline: str, 
-                                genre: str, language: str) -> str:
-        """Create prompt for episode 1 storyboard with 30 panels - INCLUDING gfwm trigger"""
+                                genre: str, language: str, character_profiles: Dict[str, CharacterProfile]) -> str:
+        """Create prompt for episode storyboard with character descriptions"""
         genre_info = GENRE_ELEMENTS.get(genre, {})
         
+        # Create character description string
+        char_descriptions = "\n".join([
+            f"- {name}: {profile.celebrity_lookalike} 닮은 얼굴의 {profile.gender}"
+            for name, profile in character_profiles.items()
+        ])
+        
         lang_prompts = {
             "Korean": f"""웹툰 {episode_num}화 스토리보드를 30개 패널로 작성하세요.
 
 **장르:** {genre}
 **1화 내용:** {self._extract_episode_plan(plot_outline, episode_num)}
 
+**캐릭터 얼굴 설정:**
+{char_descriptions}
+
+⚠️ **중요**: 캐릭터가 등장할 때마다 "캐릭터이름(유명인 닮은 얼굴의 성별)" 형식으로 작성하세요!
+예시: "홍길동(톰 크루즈 닮은 얼굴의 남자)이 거리를 걷고 있다"
+
 **패널 구성 지침:**
 - 총 30개 패널로 구성
-- 다양한 샷 사이즈 활용 (와이드샷, 클로즈업, 미디엄샷 등)
+- 다양한 샷 사이즈 활용
 - 장르 특성에 맞는 연출: {', '.join(genre_info.get('panel_types', []))}
-- 세로 스크롤 웹툰에 최적화된 구성
-
-⚠️ **중요**: 모든 이미지 프롬프트는 반드시 "gfwm" 트리거워드로 시작해야 합니다!
 
 **각 패널별로 다음을 포함하여 작성:**
 
 패널 1:
 - 샷 타입: [establishing/wide/medium/close_up 등]
-- 이미지 프롬프트: gfwm, [상세한 한글 이미지 생성 프롬프트]
+- 이미지 프롬프트: [캐릭터 설명 포함한 상세한 한글 이미지 생성 프롬프트]
 - 대사: [캐릭터 대사가 있다면]
 - 나레이션: [해설이 있다면]
 - 효과음: [필요한 효과음]
@@ -478,48 +569,35 @@ Episode 40: [Title] - [Key event] - [Grand finale]"""
 
 ...이런 식으로 30개 패널 모두 작성
 
-**중요 연출 포인트:**
-1. 첫 패널은 임팩트 있는 establishing shot
-2. 감정선은 클로즈업으로 강조
-3. 액션은 다이나믹한 앵글 활용
-4. 마지막 패널은 강력한 클리프행어
-5. 대사와 이미지가 조화롭게 구성
-
 반드시 30개 패널을 모두 작성하세요.""",
 
             "English": f"""Create Episode {episode_num} storyboard with 30 panels.
 
 **Genre:** {genre}
-**Episode 1 content:** {self._extract_episode_plan(plot_outline, episode_num)}
+**Episode content:** {self._extract_episode_plan(plot_outline, episode_num)}
+
+**Character Face Settings:**
+{char_descriptions}
+
+⚠️ **IMPORTANT**: Always describe characters as "CharacterName (celebrity lookalike face gender)"!
+Example: "John (Tom Cruise lookalike male) walking down the street"
 
 **Panel composition guidelines:**
 - Total 30 panels
-- Various shot sizes (wide, close-up, medium, etc.)
+- Various shot sizes
 - Genre-appropriate directing: {', '.join(genre_info.get('panel_types', []))}
-- Optimized for vertical scroll webtoon
-
-⚠️ **IMPORTANT**: All image prompts must start with "gfwm" trigger word!
 
 **For each panel include:**
 
 Panel 1:
 - Shot type: [establishing/wide/medium/close_up etc]
-- Image prompt: gfwm, [Detailed Korean image generation prompt]
+- Image prompt: [Detailed prompt with character descriptions]
 - Dialogue: [Character dialogue if any]
 - Narration: [Narration if any]
 - Sound effects: [Required sound effects]
 - Background: [Background description]
 
-...continue for all 30 panels
-
-**Key directing points:**
-1. First panel: impactful establishing shot
-2. Emphasize emotions with close-ups
-3. Dynamic angles for action
-4. Last panel: powerful cliffhanger
-5. Harmonious dialogue and image composition
-
-Must write all 30 panels."""
+...continue for all 30 panels"""
         }
         
         return lang_prompts.get(language, lang_prompts["Korean"])
@@ -555,6 +633,62 @@ Must write all 30 panels."""
             return '\n'.join(episode_section)
         
         return f"에피소드 {episode_num} 내용을 플롯에서 참조하여 작성하세요."
+    
+    def parse_characters_from_planning(self, planning_doc: str) -> List[Dict]:
+        """Parse character information from planning document"""
+        characters = []
+        lines = planning_doc.split('\n')
+        
+        in_character_section = False
+        current_char = {}
+        
+        for line in lines:
+            if '주요 캐릭터' in line or 'Main Characters' in line:
+                in_character_section = True
+                continue
+            elif in_character_section and ('시놉시스' in line or 'Synopsis' in line):
+                if current_char:
+                    characters.append(current_char)
+                break
+            elif in_character_section and line.strip():
+                # Parse character line
+                if '성별:' in line or 'Gender:' in line:
+                    if current_char:
+                        characters.append(current_char)
+                    
+                    parts = line.split('-')
+                    if len(parts) >= 2:
+                        name = parts[0].strip().replace('주인공:', '').replace('캐릭터', '').strip()
+                        
+                        # Extract gender
+                        gender = 'male'  # default
+                        if 'female' in line.lower() or '여' in line:
+                            gender = 'female'
+                        elif 'male' in line.lower() or '남' in line:
+                            gender = 'male'
+                        
+                        current_char = {
+                            'name': name,
+                            'gender': gender,
+                            'role': parts[1].strip() if len(parts) > 1 else '',
+                            'personality': parts[2].strip() if len(parts) > 2 else '',
+                            'appearance': parts[3].strip() if len(parts) > 3 else ''
+                        }
+        
+        if current_char and current_char not in characters:
+            characters.append(current_char)
+        
+        # Ensure at least 3 characters
+        while len(characters) < 3:
+            characters.append({
+                'name': f'캐릭터{len(characters)+1}',
+                'gender': 'male' if len(characters) % 2 == 0 else 'female',
+                'role': '조연',
+                'personality': '일반적',
+                'appearance': '평범한 외모'
+            })
+        
+        return characters
 
     # --- LLM call functions ---
     def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
@@ -641,44 +775,35 @@ Must write all 30 panels."""
 독자를 사로잡는 스토리와 비주얼 연출을 기획합니다.
 40화 완결 구조로 완벽한 기승전결을 설계합니다.
 각 화마다 강력한 클리프행어로 다음 화를 기대하게 만듭니다.
-장르별 특성과 독자층을 정확히 파악합니다.
+캐릭터의 성별을 명확히 지정합니다.
 
 ⚠️ 가장 중요한 원칙: 사용자가 제공한 스토리 설정을 절대적으로 우선시하고, 이를 중심으로 모든 플롯을 구성합니다.""",
                 
                 "storyboarder": """당신은 웹툰 스토리보드 전문가입니다.
 30개 패널로 한 화를 완벽하게 구성합니다.
 세로 스크롤에 최적화된 연출을 합니다.
-각 패널마다 상세한 이미지 프롬프트를 한글로 작성합니다.
-대사, 나레이션, 효과음을 적절히 배치합니다.
-다양한 카메라 앵글과 샷 사이즈를 활용합니다.
-감정선과 액션을 시각적으로 극대화합니다.
+각 패널마다 캐릭터의 유명인 닮은꼴 설정을 포함한 상세한 이미지 프롬프트를 작성합니다.
 
 ⚠️ 가장 중요한 원칙: 
 1. 반드시 30개 패널을 모두 작성합니다.
-2. 모든 이미지 프롬프트는 "gfwm" 트리거워드로 시작해야 합니다.
-3. 각 패널마다 이미지 생성이 가능한 구체적인 한글 프롬프트를 제공합니다."""
+2. 캐릭터가 등장할 때마다 "캐릭터이름(유명인 닮은 얼굴의 성별)" 형식으로 작성합니다."""
             },
             "English": {
                 "planner": """You perfectly understand the Korean webtoon market.
 Design stories and visual direction that captivate readers.
 Create perfect story structure in 40 episodes.
 Make readers anticipate next episode with strong cliffhangers.
-Accurately understand genre characteristics and readership.
+Clearly specify character genders.
 
 ⚠️ Most important principle: Absolutely prioritize the user's story setting and build all plots around it.""",
                 
                 "storyboarder": """You are a webtoon storyboard specialist.
 Perfectly compose one episode with 30 panels.
-Optimize direction for vertical scrolling.
-Write detailed image prompts in Korean for each panel.
-Properly place dialogue, narration, and sound effects.
-Use various camera angles and shot sizes.
-Visually maximize emotions and action.
+Write detailed image prompts including celebrity lookalike descriptions.
 
 ⚠️ Most important principles:
 1. Must write all 30 panels.
-2. All image prompts must start with "gfwm" trigger word.
-3. Provide specific Korean prompts for image generation for each panel."""
+2. Always describe characters as "CharacterName (celebrity lookalike face gender)"."""
             }
         }
         
@@ -686,7 +811,7 @@ Visually maximize emotions and action.
 
     # --- Main process ---
     def process_webtoon_stream(self, query: str, genre: str, language: str, 
-                              session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
+                              session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str, Dict], None, None]:
         """Webtoon planning and storyboard generation process"""
         try:
             if not session_id:
@@ -697,8 +822,8 @@ Visually maximize emotions and action.
             else:
                 self.current_session_id = session_id
 
-            # Phase 1: Generate planning document (40 episodes structure)
-            yield "🎬 웹툰 기획안 작성 중...", "", f"장르: {genre}", self.current_session_id
+            # Phase 1: Generate planning document
+            yield "🎬 웹툰 기획안 작성 중...", "", f"장르: {genre}", self.current_session_id, {}
             
             planning_prompt = self.create_planning_prompt(query, genre, language)
             planning_doc = self.call_llm_sync(
@@ -708,33 +833,37 @@ Visually maximize emotions and action.
             
             self.planning_doc = planning_doc
             
-            yield "✅ 기획안 완성!", planning_doc, "40화 구성 완료", self.current_session_id
+            # Parse characters and assign celebrity lookalikes
+            characters = self.parse_characters_from_planning(planning_doc)
+            character_profiles = self.assign_celebrity_lookalikes(characters)
+            
+            # Save character profiles
+            WebtoonDatabase.save_character_profiles(self.current_session_id, character_profiles)
+            
+            yield "✅ 기획안 완성!", planning_doc, "40화 구성 완료", self.current_session_id, character_profiles
 
-            # Phase 2: Generate Episode 1 Storyboard (30 panels)
-            yield "🎨 1화 스토리보드 작성 중...", planning_doc, "30개 패널 구성 중", self.current_session_id
+            # Phase 2: Generate Episode 1 Storyboard
+            yield "🎨 1화 스토리보드 작성 중...", planning_doc, "30개 패널 구성 중", self.current_session_id, character_profiles
             
-            storyboard_prompt = self.create_storyboard_prompt(1, planning_doc, genre, language)
+            storyboard_prompt = self.create_storyboard_prompt(1, planning_doc, genre, language, character_profiles)
             storyboard_content = self.call_llm_sync(
                 [{"role": "user", "content": storyboard_prompt}],
                 "storyboarder", language
             )
             
             # Parse storyboard into structured format
-            storyboard = self.parse_storyboard(storyboard_content, 1)
+            storyboard = self.parse_storyboard(storyboard_content, 1, character_profiles)
             
             # Save to database
             WebtoonDatabase.save_storyboard(self.current_session_id, 1, storyboard)
             
-            # Format final output
-            final_output = f"{planning_doc}\n\n{'='*50}\n\n## 📋 1화 스토리보드 (30 패널)\n\n{storyboard_content}"
-            
-            yield "🎉 완성!", planning_doc, storyboard_content, self.current_session_id
+            yield "🎉 완성!", planning_doc, storyboard_content, self.current_session_id, character_profiles
 
         except Exception as e:
             logger.error(f"Webtoon generation error: {e}", exc_info=True)
-            yield f"❌ 오류 발생: {e}", "", "", self.current_session_id
+            yield f"❌ 오류 발생: {e}", "", "", self.current_session_id, {}
 
-    def parse_storyboard(self, content: str, episode_num: int) -> EpisodeStoryboard:
+    def parse_storyboard(self, content: str, episode_num: int, character_profiles: Dict[str, CharacterProfile]) -> EpisodeStoryboard:
         """Parse storyboard text into structured format"""
         storyboard = EpisodeStoryboard(episode_number=episode_num, title=f"{episode_num}화")
         
@@ -751,15 +880,11 @@ Visually maximize emotions and action.
                 current_panel = StoryboardPanel(
                     panel_number=panel_number, 
                     scene_type="medium",
-                    image_prompt="gfwm, "  # Initialize with gfwm trigger
+                    image_prompt=""
                 )
             elif current_panel:
                 if '이미지 프롬프트:' in line or 'Image prompt:' in line:
-                    prompt = line.split(':', 1)[1].strip()
-                    # Ensure gfwm trigger is included
-                    if not prompt.startswith("gfwm"):
-                        prompt = f"gfwm, {prompt}"
-                    current_panel.image_prompt = prompt
+                    current_panel.image_prompt = line.split(':', 1)[1].strip()
                 elif '대사:' in line or 'Dialogue:' in line:
                     dialogue = line.split(':', 1)[1].strip()
                     if dialogue:
@@ -776,12 +901,12 @@ Visually maximize emotions and action.
         if current_panel:
             panels.append(current_panel)
         
-        storyboard.panels = panels[:30]  # Limit to 30 panels
+        storyboard.panels = panels[:30]
         return storyboard
 
 # --- Format storyboard for display ---
-def format_storyboard_for_display(storyboard_content: str) -> str:
-    """Format storyboard content for panel display"""
+def format_storyboard_for_display(storyboard_content: str, character_profiles: Dict[str, CharacterProfile], session_id: str) -> str:
+    """Format storyboard content for panel display with image generation buttons"""
     formatted_panels = []
     panel_texts = []
     current_panel = {}
@@ -794,10 +919,7 @@ def format_storyboard_for_display(storyboard_content: str) -> str:
                 panel_texts.append(current_panel)
             current_panel = {'number': len(panel_texts) + 1}
         elif '이미지 프롬프트:' in line or 'Image prompt:' in line:
-            prompt = line.split(':', 1)[1].strip()
-            if not prompt.startswith("gfwm"):
-                prompt = f"gfwm, {prompt}"
-            current_panel['prompt'] = prompt
+            current_panel['prompt'] = line.split(':', 1)[1].strip()
         elif '대사:' in line or 'Dialogue:' in line:
             current_panel['dialogue'] = line.split(':', 1)[1].strip()
         elif '나레이션:' in line or 'Narration:' in line:
@@ -811,15 +933,29 @@ def format_storyboard_for_display(storyboard_content: str) -> str:
         panel_texts.append(current_panel)
     
     # Format each panel for display
-    for panel in panel_texts[:30]:  # Ensure only 30 panels
+    for panel in panel_texts[:30]:
+        panel_num = panel.get('number', '?')
         panel_html = f"""
 <div style="border: 1px solid #ddd; padding: 15px; margin-bottom: 15px; border-radius: 8px; background: #f9f9f9;">
-    <h4 style="color: #764ba2; margin-top: 0;">🎬 패널 {panel.get('number', '?')}</h4>
+    <h4 style="color: #764ba2; margin-top: 0;">🎬 패널 {panel_num}</h4>
     <p><strong>샷 타입:</strong> {panel.get('shot', 'N/A')}</p>
-    <p><strong>이미지 프롬프트:</strong><br><code style="background: #fff; padding: 5px; display: block; border-radius: 4px;">{panel.get('prompt', 'N/A')}</code></p>
+    <p><strong>이미지 프롬프트:</strong><br>
+    <code style="background: #fff; padding: 8px; display: block; border-radius: 4px; font-size: 12px;">
+    {panel.get('prompt', 'N/A')}
+    </code></p>
     {f"<p><strong>대사:</strong> {panel.get('dialogue')}</p>" if panel.get('dialogue') else ""}
     {f"<p><strong>나레이션:</strong> {panel.get('narration')}</p>" if panel.get('narration') else ""}
     {f"<p><strong>효과음:</strong> {panel.get('effects')}</p>" if panel.get('effects') else ""}
+    <div id="panel_{panel_num}_buttons" style="margin-top: 10px;">
+        <button onclick="generateImage({panel_num}, '{session_id}')" 
+                style="background: #667eea; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer;">
+            🎨 이미지 생성
+        </button>
+        <button onclick="regenerateImage({panel_num}, '{session_id}')" 
+                style="background: #764ba2; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer; margin-left: 10px;">
+            🔄 다시 생성
+        </button>
+    </div>
 </div>
         """
         formatted_panels.append(panel_html)
@@ -845,47 +981,6 @@ def export_to_txt(planning_doc: str, storyboard: str, genre: str, title: str = "
     
     return content
 
-def export_to_docx(planning_doc: str, storyboard: str, genre: str, title: str = "") -> bytes:
-    """Export webtoon planning and storyboard to DOCX format"""
-    if not DOCX_AVAILABLE:
-        raise Exception("python-docx is not installed")
-    
-    doc = Document()
-    
-    # Title
-    doc.add_heading(title if title else f"{genre} 웹툰", 0)
-    
-    # Info
-    doc.add_paragraph(f"장르: {genre}")
-    doc.add_paragraph("총 40화 기획")
-    doc.add_page_break()
-    
-    # Planning document
-    doc.add_heading("📚 기획안", 1)
-    for line in planning_doc.split('\n'):
-        if line.strip():
-            if line.startswith('#'):
-                doc.add_heading(line.replace('#', '').strip(), 2)
-            else:
-                doc.add_paragraph(line)
-    
-    doc.add_page_break()
-    
-    # Storyboard
-    doc.add_heading("🎨 1화 스토리보드 (30 패널)", 1)
-    for line in storyboard.split('\n'):
-        if line.strip():
-            if '패널' in line or 'Panel' in line:
-                doc.add_heading(line, 2)
-            else:
-                doc.add_paragraph(line)
-    
-    # Save to bytes
-    bytes_io = io.BytesIO()
-    doc.save(bytes_io)
-    bytes_io.seek(0)
-    return bytes_io.getvalue()
-
 def generate_random_webtoon_theme(genre: str, language: str) -> str:
     """Generate random webtoon theme"""
     templates = {
@@ -959,48 +1054,45 @@ def create_interface():
                 text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
             }
             
-            .header-subtitle {
-                font-size: 1.2rem;
-                margin-bottom: 0.5rem;
-            }
-            
-            .storyboard-container {
-                display: grid;
-                grid-template-columns: 1fr 1fr;
-                gap: 20px;
-                height: 800px;
-                overflow: hidden;
-            }
-            
-            .panel-text {
-                overflow-y: auto;
-                padding: 20px;
-                background: #f5f5f5;
-                border-radius: 10px;
-            }
-            
-            .panel-images {
-                overflow-y: auto;
-                padding: 20px;
-                background: #fafafa;
-                border-radius: 10px;
-                border: 2px dashed #ddd;
+            .character-profile {
+                background: #f0f0f0;
+                padding: 10px;
+                margin: 5px 0;
+                border-radius: 8px;
             }
             
-            .panel-placeholder {
-                height: 400px;
+            .panel-image-container {
+                min-height: 400px;
                 background: #fff;
-                border: 1px solid #e0e0e0;
+                border: 2px dashed #ddd;
                 border-radius: 8px;
                 margin-bottom: 20px;
                 display: flex;
                 align-items: center;
                 justify-content: center;
-                color: #999;
-                font-size: 14px;
             }
         </style>
         
+        <script>
+            async function generateImage(panelNum, sessionId) {
+                const promptElement = document.querySelector(`#panel_${panelNum}_prompt`);
+                if (!promptElement) return;
+                
+                const prompt = promptElement.textContent;
+                const imageContainer = document.querySelector(`#panel_${panelNum}_image`);
+                
+                imageContainer.innerHTML = '<p>이미지 생성 중...</p>';
+                
+                // Call image generation API
+                // This would be connected to your backend
+                console.log('Generating image for panel', panelNum, 'with prompt:', prompt);
+            }
+            
+            async function regenerateImage(panelNum, sessionId) {
+                generateImage(panelNum, sessionId);
+            }
+        </script>
+        
         <div class="main-header">
             <h1 class="header-title">🎨 K-Webtoon Storyboard Generator</h1>
             <p class="header-subtitle">한국형 웹툰 기획 및 스토리보드 자동 생성 시스템</p>
@@ -1011,6 +1103,7 @@ def create_interface():
         current_session_id = gr.State(None)
         planning_state = gr.State("")
         storyboard_state = gr.State("")
+        character_profiles_state = gr.State({})
         
         with gr.Tab("📚 기획안 작성"):
             with gr.Group():
@@ -1043,9 +1136,10 @@ def create_interface():
                         )
                         
                         gr.Markdown("""
-                        **🔥 트리거워드: gfwm**
+                        **🎭 캐릭터 얼굴 설정**
                         
-                        모든 이미지 프롬프트에 자동 적용됩니다.
+                        각 캐릭터에 유명인 닮은꼴이
+                        자동으로 배정됩니다.
                         """)
                 
                 status_text = gr.Textbox(
@@ -1057,9 +1151,12 @@ def create_interface():
             # Planning output
             planning_display = gr.Markdown("*기획안이 여기에 표시됩니다*")
             
+            # Character profiles display
+            character_display = gr.HTML(label="캐릭터 프로필")
+            
             with gr.Row():
                 download_format = gr.Radio(
-                    choices=["TXT", "DOCX"],
+                    choices=["TXT"],
                     value="TXT",
                     label="다운로드 형식"
                 )
@@ -1070,7 +1167,7 @@ def create_interface():
         with gr.Tab("🎬 1화 스토리보드"):
             gr.Markdown("""
             ### 📋 1화 스토리보드 (30 패널)
-            좌측: 텍스트 및 이미지 프롬프트 | 우측: 이미지 공간 (준비중)
+            좌측: 텍스트 및 이미지 프롬프트 | 우측: 생성된 이미지
             """)
             
             with gr.Row():
@@ -1081,18 +1178,20 @@ def create_interface():
                     )
                 
                 with gr.Column():
-                    gr.HTML("""
-                    <div style="padding: 20px; background: #fafafa; border: 2px dashed #ddd; border-radius: 10px; min-height: 800px;">
-                        <p style="color: #999; text-align: center;">🖼️ 이미지 생성 공간</p>
-                        <p style="color: #aaa; text-align: center; font-size: 12px;">각 패널의 이미지가 여기에 표시됩니다</p>
-                        
-                        <!-- Panel placeholders -->
-                        <div class="panel-placeholder">패널 1 이미지</div>
-                        <div class="panel-placeholder">패널 2 이미지</div>
-                        <div class="panel-placeholder">패널 3 이미지</div>
-                        <p style="color: #ccc; text-align: center;">... 30개 패널까지</p>
-                    </div>
-                    """)
+                    image_display_area = gr.HTML(
+                        value="""
+                        <div style="padding: 20px; background: #fafafa; border: 2px dashed #ddd; border-radius: 10px; min-height: 800px;">
+                            <p style="color: #999; text-align: center;">🖼️ 이미지 생성 공간</p>
+                            <p style="color: #aaa; text-align: center; font-size: 12px;">각 패널의 생성 버튼을 클릭하면 이미지가 여기에 표시됩니다</p>
+                        </div>
+                        """,
+                        label="생성된 이미지"
+                    )
+            
+            # Image generation controls
+            with gr.Row():
+                generate_all_btn = gr.Button("🎨 모든 이미지 생성", variant="primary")
+                clear_images_btn = gr.Button("🗑️ 이미지 초기화", variant="secondary")
         
         with gr.Tab("📚 사용 가이드"):
             gr.Markdown("""
@@ -1102,26 +1201,20 @@ def create_interface():
                - 장르 선택
                - 스토리 콘셉트 입력
                - "기획 시작" 클릭
-               - 40화 전체 구성이 생성됩니다
+               - 40화 전체 구성과 캐릭터 프로필이 생성됩니다
             
-            2. **1화 스토리보드 탭**에서:
-               - 30개 패널의 상세 스토리보드 확인
-               - 각 패널별 이미지 프롬프트 (gfwm 트리거 포함)
-               - 대사, 나레이션, 효과음 정보
+            2. **캐릭터 얼굴 설정**:
+               - 각 캐릭터에 유명인 닮은꼴이 자동 배정됩니다
+               - 이미지 프롬프트에 "캐릭터명(유명인 닮은 얼굴)" 형식으로 포함됩니다
             
-            ### 트리거워드: gfwm
-            모든 이미지 생성 프롬프트에 자동으로 포함됩니다.
+            3. **1화 스토리보드 탭**에서:
+               - 30개 패널의 상세 스토리보드 확인
+               - 각 패널별 이미지 생성 버튼 클릭
+               - Replicate API를 통한 이미지 생성
             
-            ### 장르별 특징
-            - **로맨스**: 감정선, 관계 중심
-            - **로판**: 회귀/빙의 판타지
-            - **판타지**: 모험과 성장
-            - **현판**: 현대 배경 능력물
-            - **무협**: 무공과 복수
-            - **스릴러**: 서스펜스와 반전
-            - **일상**: 공감과 힐링
-            - **개그**: 웃음과 패러디
-            - **스포츠**: 열정과 성장
+            ### API 설정
+            - REPLICATE_API_TOKEN 환경변수 필요
+            - 이미지 생성은 qwen/qwen-image 모델 사용
             """)
         
         # Event handlers
@@ -1129,18 +1222,36 @@ def create_interface():
             system = WebtoonSystem()
             planning = ""
             storyboard = ""
+            character_profiles = {}
             
-            for planning_content, storyboard_content, status, new_session_id in system.process_webtoon_stream(query, genre, language, session_id):
+            for planning_content, storyboard_content, status, new_session_id, profiles in system.process_webtoon_stream(query, genre, language, session_id):
                 planning = planning_content
                 storyboard = storyboard_content
-                yield planning, storyboard, status, new_session_id
+                character_profiles = profiles
+                yield planning, storyboard, status, new_session_id, character_profiles
+        
+        def format_character_profiles(profiles: Dict[str, CharacterProfile]) -> str:
+            """Format character profiles for display"""
+            if not profiles:
+                return ""
+            
+            html = "<h3>🎭 캐릭터 프로필</h3>"
+            for name, profile in profiles.items():
+                html += f"""
+                <div class="character-profile">
+                    <strong>{name}</strong> - {profile.celebrity_lookalike} 닮은 얼굴
+                    <br>역할: {profile.role}
+                    <br>성격: {profile.personality}
+                </div>
+                """
+            return html
         
-        def update_storyboard_display(storyboard_content):
+        def update_storyboard_display(storyboard_content, character_profiles, session_id):
             """Update storyboard display with formatted panels"""
             if not storyboard_content or storyboard_content == "":
                 return "<p style='color: #999; text-align: center; padding: 50px;'>기획안 작성 후 스토리보드가 생성됩니다</p>"
             
-            return format_storyboard_for_display(storyboard_content)
+            return format_storyboard_for_display(storyboard_content, character_profiles, session_id)
         
         def handle_random_theme(genre, language):
             return generate_random_webtoon_theme(genre, language)
@@ -1149,44 +1260,64 @@ def create_interface():
             """Handle download request"""
             try:
                 title = f"{genre} 웹툰"
+                content = export_to_txt(planning, storyboard, genre, title)
                 
-                if download_format == "TXT":
-                    content = export_to_txt(planning, storyboard, genre, title)
-                    
-                    with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', 
-                                                   suffix='.txt', delete=False) as f:
-                        f.write(content)
-                        return f.name
-                
-                elif download_format == "DOCX":
-                    if not DOCX_AVAILABLE:
-                        gr.Warning("DOCX export requires python-docx library")
-                        return None
-                    
-                    content = export_to_docx(planning, storyboard, genre, title)
-                    
-                    with tempfile.NamedTemporaryFile(mode='wb', suffix='.docx', 
-                                                   delete=False) as f:
-                        f.write(content)
-                        return f.name
+                with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', 
+                                               suffix='.txt', delete=False) as f:
+                    f.write(content)
+                    return f.name
                         
             except Exception as e:
                 logger.error(f"Download error: {e}")
                 gr.Warning(f"다운로드 중 오류 발생: {str(e)}")
                 return None
         
-        # Connect events
+        def generate_all_images(session_id, storyboard_content):
+            """Generate images for all panels"""
+            if not REPLICATE_API_TOKEN:
+                return "<p style='color: red;'>Replicate API 토큰이 설정되지 않았습니다.</p>"
+            
+            # Parse panels and generate images
+            image_html = "<div style='padding: 20px;'>"
+            image_html += "<h3>🖼️ 생성된 이미지</h3>"
+            
+            # This would iterate through panels and generate images
+            # For now, returning placeholder
+            for i in range(1, 31):
+                image_html += f"""
+                <div class="panel-image-container" id="panel_{i}_image">
+                    <p style='color: #999;'>패널 {i} 이미지 (생성 대기)</p>
+                </div>
+                """
+            
+            image_html += "</div>"
+            return image_html
+        
+        def clear_all_images():
+            """Clear all generated images"""
+            return """
+            <div style="padding: 20px; background: #fafafa; border: 2px dashed #ddd; border-radius: 10px; min-height: 800px;">
+                <p style="color: #999; text-align: center;">🖼️ 이미지 생성 공간</p>
+                <p style="color: #aaa; text-align: center; font-size: 12px;">이미지가 초기화되었습니다</p>
+            </div>
+            """
+
+# Connect events
         submit_btn.click(
             fn=process_query,
             inputs=[query_input, genre_select, language_select, current_session_id],
-            outputs=[planning_state, storyboard_state, status_text, current_session_id]
+            outputs=[planning_state, storyboard_state, status_text, current_session_id, character_profiles_state]
         ).then(
             fn=lambda x: x,
             inputs=[planning_state],
             outputs=[planning_display]
+        ).then(
+            fn=format_character_profiles,
+            inputs=[character_profiles_state],
+            outputs=[character_display]
         ).then(
             fn=update_storyboard_display,
-            inputs=[storyboard_state],
+            inputs=[storyboard_state, character_profiles_state, current_session_id],
             outputs=[storyboard_text_display]
         )
         
@@ -1206,6 +1337,18 @@ def create_interface():
             outputs=[download_file]
         )
         
+        generate_all_btn.click(
+            fn=generate_all_images,
+            inputs=[current_session_id, storyboard_state],
+            outputs=[image_display_area]
+        )
+        
+        clear_images_btn.click(
+            fn=clear_all_images,
+            inputs=[],
+            outputs=[image_display_area]
+        )
+        
         # Examples
         gr.Examples(
             examples=[
@@ -1234,7 +1377,11 @@ if __name__ == "__main__":
     logger.info(f"Model: {MODEL_ID}")
     logger.info(f"Target: {TARGET_EPISODES} episodes, {PANELS_PER_EPISODE} panels per episode")
     logger.info("Genres: " + ", ".join(WEBTOON_GENRES.keys()))
-    logger.info("Trigger word: gfwm (automatically added to all image prompts)")
+    
+    if REPLICATE_API_TOKEN:
+        logger.info("Replicate API: Configured ✓")
+    else:
+        logger.warning("Replicate API: Not configured (Image generation disabled)")
     
     logger.info("=" * 60)
     
@@ -1249,4 +1396,4 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=False
-    )
+    )