Update app.py

app.py

@@ -28,19 +28,6 @@ from threading import Lock
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# --- Document export imports ---
-try:
-   from docx import Document
-   from docx.shared import Inches, Pt, RGBColor, Mm
-   from docx.enum.text import WD_ALIGN_PARAGRAPH
-   from docx.enum.style import WD_STYLE_TYPE
-   from docx.oxml.ns import qn
-   from docx.oxml import OxmlElement
-   DOCX_AVAILABLE = True
-except ImportError:
-   DOCX_AVAILABLE = False
-   logger.warning("python-docx not installed. DOCX export will be disabled.")
-
 # --- Environment variables and constants ---
 FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
 REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN", "")
@@ -54,9 +41,9 @@ 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 패널
+TARGET_EPISODES = 40
+PANELS_PER_EPISODE = 30
+TARGET_PANELS = TARGET_EPISODES * PANELS_PER_EPISODE
 
 # Webtoon genres
 WEBTOON_GENRES = {
@@ -71,7 +58,7 @@ WEBTOON_GENRES = {
    "스포츠": "Sports"
 }
 
-# Celebrity face references for character design - 영어 이름 매핑 추가
+# Celebrity face references for character design
 CELEBRITY_FACES = {
    "male": [
        {"kr": "톰 크루즈", "en": "Tom Cruise"},
@@ -107,7 +94,7 @@ CELEBRITY_FACES = {
    ]
 }
 
-# --- Environment validation ---
+# 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"
@@ -115,13 +102,13 @@ if not FIREWORKS_API_KEY:
 if not REPLICATE_API_TOKEN:
    logger.warning("REPLICATE_API_TOKEN not set. Image generation will be disabled.")
 
-# --- Global variables ---
+# Global variables
 db_lock = threading.Lock()
-generated_images_cache = {}  # Cache for generated images
-panel_images_state = {}  # Global state for panel images
-character_consistency_map = {}  # 캐릭터 일관성 맵
+generated_images_cache = {}
+panel_images_state = {}
+character_consistency_map = {}
 
-# --- Genre-specific prompts and elements ---
+# Genre-specific prompts and elements
 GENRE_ELEMENTS = {
    "로맨스": {
        "key_elements": ["감정선", "오해와 화해", "달콤한 순간", "질투", "고백"],
@@ -187,10 +174,10 @@ class CharacterProfile:
    role: str
    personality: str
    appearance: str
-   celebrity_lookalike_kr: str  # 한글 이름
-   celebrity_lookalike_en: str  # 영어 이름
+   celebrity_lookalike_kr: str
+   celebrity_lookalike_en: str
    gender: str
-   detailed_appearance: str = ""  # 상세 외모 설명
+   detailed_appearance: str = ""
 
 @dataclass
 class WebtoonBible:
@@ -209,10 +196,10 @@ class WebtoonBible:
 class StoryboardPanel:
    """Individual storyboard panel with unique ID"""
    panel_number: int
-   scene_type: str  # wide, close-up, medium, establishing
-   image_prompt: str  # Image generation prompt with character descriptions
-   image_prompt_en: str = ""  # 영어 번역된 프롬프트
-   panel_id: str = ""  # Unique panel identifier
+   scene_type: str
+   image_prompt: str
+   image_prompt_en: str = ""
+   panel_id: str = ""
    dialogue: List[str] = field(default_factory=list)
    narration: str = ""
    sound_effects: List[str] = field(default_factory=list)
@@ -220,7 +207,7 @@ class StoryboardPanel:
    camera_angle: str = ""
    background: str = ""
    characters_in_scene: List[str] = field(default_factory=list)
-   generated_image_url: str = ""  # URL of generated image
+   generated_image_url: str = ""
 
 @dataclass
 class EpisodeStoryboard:
@@ -264,7 +251,6 @@ class WebtoonDatabase:
            conn.execute("PRAGMA journal_mode=WAL")
            cursor = conn.cursor()
            
-           # Sessions table with genre and character consistency
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS sessions (
                    session_id TEXT PRIMARY KEY,
@@ -285,7 +271,6 @@ class WebtoonDatabase:
                )
            ''')
            
-           # Storyboards table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS storyboards (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -301,7 +286,6 @@ class WebtoonDatabase:
                )
            ''')
            
-           # Panels table with image data and English prompts
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS panels (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -350,7 +334,6 @@ class WebtoonDatabase:
        with WebtoonDatabase.get_db() as conn:
            cursor = conn.cursor()
            
-           # Save storyboard
            cursor.execute('''
                INSERT INTO storyboards (session_id, episode_number, title, 
                                        storyboard_data, panel_count, status)
@@ -361,7 +344,6 @@ class WebtoonDatabase:
                  json.dumps(asdict(storyboard)), len(storyboard.panels),
                  storyboard.title, json.dumps(asdict(storyboard)), len(storyboard.panels)))
            
-           # Save individual panels with English prompts
            for panel in storyboard.panels:
                cursor.execute('''
                    INSERT INTO panels (session_id, episode_number, panel_number,
@@ -406,59 +388,82 @@ class ImageGenerator:
        self.generation_lock = Lock()
        self.active_generations = {}
    
-   def enhance_prompt_for_webtoon(self, prompt: str, panel_number: int) -> str:
-       """Enhance prompt for single-scene webtoon panel generation"""
-       # 기본 스타일 접두사
-       base_style = "Japanese animation style, webtoon panel, single scene, clear composition"
+   def enhance_prompt_for_webtoon(self, prompt: str, panel_number: int, scene_type: str = "medium") -> str:
+       """Enhanced prompt for story-driven webtoon panel generation"""
+       
+       # 스토리 중심의 프롬프트 구성
+       base_style = "professional webtoon art, Korean manhwa style, high quality digital art"
+       
+       # 씬 타입별 강조점
+       scene_emphasis = {
+           "establishing": "wide environmental shot, detailed background, atmospheric scene",
+           "wide": "full scene view, multiple elements, environmental storytelling",
+           "medium": "balanced composition, character and environment, narrative focus",
+           "close_up": "emotional expression, detailed facial features, intimate moment",
+           "extreme_close_up": "dramatic detail, intense emotion, impactful moment"
+       }
        
-       # 단일 장면 강조 키워드 추가
-       single_scene_emphasis = "ONE scene only, focused composition, no split scenes, no multiple moments"
+       # 웹툰 특화 스타일
+       webtoon_style = "clean line art, vibrant colors, dynamic composition, professional illustration"
        
-       # 웹툰 특화 키워드
-       webtoon_keywords = "vertical scroll webtoon style, manhwa art, clean lines, vibrant colors"
+       # 스토리 중심 강조
+       story_focus = "narrative scene, story moment, sequential art panel"
        
-       # 카메라 앵글 강조
-       camera_focus = "single camera angle, consistent perspective"
+       # 씬 타입 적용
+       scene_desc = scene_emphasis.get(scene_type, scene_emphasis["medium"])
        
        # 최종 프롬프트 구성
-       enhanced_prompt = f"{base_style}, {single_scene_emphasis}, {prompt}, {webtoon_keywords}, {camera_focus}"
+       enhanced_prompt = f"{base_style}, {scene_desc}, {prompt}, {webtoon_style}, {story_focus}"
        
-       # 너무 긴 프롬프트 제한 (SDXL 권장 길이)
+       # 길이 제한
        if len(enhanced_prompt) > 500:
-           # 핵심 부분만 유지
-           enhanced_prompt = f"{base_style}, {prompt[:350]}, {single_scene_emphasis}"
+           enhanced_prompt = f"{base_style}, {prompt[:350]}, {story_focus}"
        
        return enhanced_prompt
    
-   def generate_image(self, prompt: str, panel_id: str, session_id: str, progress_callback=None) -> Dict[str, Any]:
-       """Generate image using Replicate API with enhanced webtoon prompts"""
+   def generate_image(self, prompt: str, panel_id: str, session_id: str, 
+                     scene_type: str = "medium", progress_callback=None) -> Dict[str, Any]:
+       """Generate image using Replicate API with enhanced quality settings"""
        try:
            if not REPLICATE_API_TOKEN:
                logger.warning("No Replicate API token, returning placeholder")
                return {"panel_id": panel_id, "status": "error", "message": "No API token"}
            
-           logger.info(f"Generating image for panel {panel_id}")
+           logger.info(f"Generating image for panel {panel_id} - Scene type: {scene_type}")
            
            # 패널 번호 추출
            panel_number = int(panel_id.split('_panel')[1]) if '_panel' in panel_id else 1
            
-           # 프롬프트 개선 (이미 영어로 번역된 프롬프트 사용)
-           enhanced_prompt = self.enhance_prompt_for_webtoon(prompt, panel_number)
+           # 프롬프트 개선 (스토리 중심)
+           enhanced_prompt = self.enhance_prompt_for_webtoon(prompt, panel_number, scene_type)
            
            logger.info(f"Enhanced prompt: {enhanced_prompt[:150]}...")
            
            if progress_callback:
                progress_callback(f"패널 {panel_number} 이미지 생성 중...")
            
-           # Run the model with enhanced parameters
+           # Enhanced negative prompt for better quality
+           negative_prompt = (
+               "text, watermark, signature, logo, writing, letters, words, "
+               "low quality, blurry, pixelated, distorted, deformed, "
+               "bad anatomy, bad proportions, extra limbs, missing limbs, "
+               "duplicate, multiple panels, split screen, collage, "
+               "comic strip layout, speech bubbles, dialogue boxes"
+           )
+           
+           # Run SDXL with optimized parameters
            input_params = {
                "prompt": enhanced_prompt,
-               "negative_prompt": "multiple scenes, split screen, collage, montage, comic strip layout, multiple panels, confused composition, overlapping scenes, blurry, bad anatomy, ugly, deformed, text, watermark",
-               "num_inference_steps": 30,  # 품질 향상을 위해 증가
-               "guidance_scale": 8.5,  # 프롬프트 충실도 증가
-               "width": 768,  # 웹툰 세로형 비율
+               "negative_prompt": negative_prompt,
+               "num_inference_steps": 35,  # 품질 향상
+               "guidance_scale": 9.0,  # 프롬프트 충실도 향상
+               "width": 768,  # 웹툰 세로형
                "height": 1024,
-               "scheduler": "K_EULER_ANCESTRAL"  # 더 나은 결과를 위한 스케줄러
+               "scheduler": "DPMSolverMultistep",  # 더 나은 품질
+               "refine": "expert_ensemble_refiner",  # SDXL refiner 사용
+               "high_noise_frac": 0.8,
+               "prompt_strength": 0.9,
+               "num_outputs": 1
            }
            
            output = replicate.run(
@@ -466,11 +471,9 @@ class ImageGenerator:
                input=input_params
            )
            
-           # Get the image URL
            if output and len(output) > 0:
                image_url = output[0] if isinstance(output[0], str) else str(output[0])
                
-               # Cache the image
                cache_key = f"{session_id}_{panel_id}"
                generated_images_cache[cache_key] = image_url
                
@@ -498,7 +501,7 @@ class WebtoonSystem:
        self.tracker = WebtoonTracker()
        self.current_session_id = None
        self.image_generator = ImageGenerator()
-       self.character_consistency_map = {}  # 캐릭터 일관성 맵
+       self.character_consistency_map = {}
        WebtoonDatabase.init_db()
 
    def create_headers(self):
@@ -524,7 +527,6 @@ class WebtoonSystem:
            celebrity = random.choice(available_celebrities)
            used_celebrities.append(celebrity)
            
-           # 상세 외모 설명 생성
            detailed_appearance = f"{celebrity['en']} lookalike face, {char.get('appearance', '')}"
            
            profile = CharacterProfile(
@@ -541,7 +543,6 @@ class WebtoonSystem:
            profiles[profile.name] = profile
            self.tracker.add_character(profile)
            
-           # 캐릭터 일관성 맵에 저장
            self.character_consistency_map[profile.name] = {
                'kr': f"{profile.name}({celebrity['kr']} 닮은 얼굴의 {gender})",
                'en': f"{profile.name} ({celebrity['en']} lookalike {gender})",
@@ -553,16 +554,14 @@ class WebtoonSystem:
    def translate_prompt_to_english(self, korean_prompt: str, character_profiles: Dict[str, CharacterProfile]) -> str:
        """한글 프롬프트를 영어로 번역"""
        try:
-           # 캐릭터 이름을 영어 설명으로 대체
            english_prompt = korean_prompt
            for name, profile in character_profiles.items():
                korean_pattern = f"{name}\\([^)]+\\)"
                english_replacement = f"{name} ({profile.celebrity_lookalike_en} lookalike {profile.gender})"
                english_prompt = re.sub(korean_pattern, english_replacement, english_prompt)
            
-           # LLM을 통한 번역
            translation_prompt = f"""Translate this Korean webtoon panel description to English.
-Keep character descriptions and maintain the visual details.
+Focus on visual elements and actions, not just characters.
 Korean: {english_prompt}
 English translation:"""
            
@@ -572,10 +571,8 @@ English translation:"""
            return translated.strip()
        except Exception as e:
            logger.error(f"Translation error: {e}")
-           # 폴백: 기본 번역 시도
-           return korean_prompt  # 번역 실패시 원본 반환
+           return korean_prompt
 
-   # --- Prompt generation functions ---
    def create_planning_prompt(self, query: str, genre: str, language: str) -> str:
        """Create initial planning prompt for webtoon with character profiles"""
        genre_info = GENRE_ELEMENTS.get(genre, {})
@@ -685,10 +682,9 @@ Episode 40: [Title] - [Key event] - [Grand finale]
 
    def create_storyboard_prompt(self, episode_num: int, plot_outline: str, 
                                genre: str, language: str, character_profiles: Dict[str, CharacterProfile]) -> str:
-       """Create prompt for episode storyboard with single-scene focus and character consistency"""
+       """Create prompt for episode storyboard with story-driven focus"""
        genre_info = GENRE_ELEMENTS.get(genre, {})
        
-       # Create character description string with consistency
        char_descriptions = "\n".join([
            f"- {name}: 항상 '{profile.celebrity_lookalike_kr} 닮은 얼굴'로 묘사. {profile.appearance}"
            for name, profile in character_profiles.items()
@@ -700,80 +696,72 @@ Episode 40: [Title] - [Key event] - [Grand finale]
 **장르:** {genre}
 **{episode_num}화 내용:** {self._extract_episode_plan(plot_outline, episode_num)}
 
-**캐릭터 일관성 규칙 (매우 중요!):**
+**캐릭터 일관성 규칙:**
 {char_descriptions}
 
-⚠️ **절대 규칙**: 
+⚠️ **절대 규칙 - 스토리 중심 전개**: 
 1. 반드시 30개 패널을 모두 작성하세요!
-2. 각 패널은 **단 하나의 장면**만 담아야 합니다!
-3. 캐릭터가 나올 때마다 반드시 "캐릭터이름(유명인 닮은 얼굴의 성별)" 형식으로 작성!
-4. 캐릭터 외모는 처음부터 끝까지 완전히 일관되게 유지!
-5. 이미지 프롬프트는 구체적이고 시각적으로 명확하게!
+2. 각 패널은 **스토리 전개의 한 순간**을 담아야 합니다!
+3. 단순 인물 샷이 아닌 **사건과 행동 중심**으로 구성!
+4. 배경, 상황, 액션을 구체적으로 묘사!
+5. 캐릭터가 나올 때마다 "캐릭터이름(유명인 닮은 얼굴)" 형식 유지!
 
-**패널 구성 지침:**
-- 총 30개 패널로 구성
-- 각 패널은 독립적인 단일 장면
-- 장르 특성: {', '.join(genre_info.get('panel_types', []))}
+**패널 구성 가이드:**
+- establishing shot (전체 상황/배경): 4-5개
+- wide shot (전신/환경): 8-10개  
+- medium shot (상반신/대화): 10-12개
+- close-up (얼굴/감정): 5-6개
+- extreme close-up (디테일): 2-3개
 
-**각 패널별로 다음을 포함하여 작성:**
+**각 패널 작성 형식:**
 
 패널 1:
 - 샷 타입: [establishing/wide/medium/close_up/extreme_close_up 중 하나]
-- 이미지 프롬프트: [단일 장면, 캐릭터는 반드시 "이름(유명인 닮은 얼굴의 성별)" 형식]
+- 이미지 프롬프트: [구체적인 장면 묘사 - 배경, 행동, 분위기 포함]
 - 대사: [캐릭터 대사]
 - 나레이션: [해설]
 - 효과음: [효과음]
 - 배경: [구체적 배경]
 
-패널 2:
-(동일한 형식, 캐릭터 일관성 유지)
-
 ...30개 패널 모두 작성
 
-패널 30:
-(동일한 형식, 캐릭터 일관성 유지)
-
-⚠️ 모든 패널에서 캐릭터 묘사를 일관되게 유지하세요!""",
+⚠️ 스토리 진행이 자연스럽게 이어지도록 구성하세요!""",
 
            "English": f"""Create Episode {episode_num} storyboard with 30 panels.
 
 **Genre:** {genre}
 **Episode content:** {self._extract_episode_plan(plot_outline, episode_num)}
 
-**Character Consistency Rules (VERY IMPORTANT!):**
+**Character Consistency Rules:**
 {char_descriptions}
 
-⚠️ **ABSOLUTE RULES**: 
+⚠️ **ABSOLUTE RULES - Story-Driven Focus**: 
 1. Must write all 30 panels!
-2. Each panel must contain **ONLY ONE SCENE**!
-3. Always describe characters as "Name (celebrity lookalike face gender)"!
-4. Keep character appearance completely consistent!
-5. Image prompts must be specific and visually clear!
+2. Each panel must capture **a moment in story progression**!
+3. Focus on **events and actions**, not just character shots!
+4. Describe backgrounds, situations, actions specifically!
+5. Always maintain "Name (celebrity lookalike)" format!
 
-**Panel composition:**
-- Total 30 panels
-- Each panel is independent single scene
-- Genre traits: {', '.join(genre_info.get('panel_types', []))}
+**Panel Composition Guide:**
+- establishing shot (overall scene/setting): 4-5 panels
+- wide shot (full body/environment): 8-10 panels
+- medium shot (upper body/dialogue): 10-12 panels
+- close-up (face/emotion): 5-6 panels
+- extreme close-up (detail): 2-3 panels
 
-**For each panel include:**
+**Panel format:**
 
 Panel 1:
 - Shot type: [one of: establishing/wide/medium/close_up/extreme_close_up]
-- Image prompt: [Single scene, characters as "Name (celebrity lookalike face gender)"]
+- Image prompt: [Specific scene description - include background, action, atmosphere]
 - Dialogue: [Character dialogue]
 - Narration: [Narration]
 - Sound effects: [Effects]
 - Background: [Specific background]
 
-Panel 2:
-(Same format, maintain character consistency)
-
 ...write all 30 panels
 
-Panel 30:
-(Same format, maintain character consistency)
-
-⚠️ Keep character descriptions consistent across all panels!"""
+⚠️ Ensure natural story flow across panels!"""
        }
        
        return lang_prompts.get(language, lang_prompts["Korean"])
@@ -827,7 +815,6 @@ Panel 30:
                    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)
@@ -836,14 +823,12 @@ Panel 30:
                    if len(parts) >= 2:
                        name = parts[0].strip().replace('주인공:', '').replace('캐릭터', '').strip()
                        
-                       # Extract gender
-                       gender = 'male'  # default
+                       gender = 'male'
                        if 'female' in line.lower() or '여' in line:
                            gender = 'female'
                        elif 'male' in line.lower() or '남' in line:
                            gender = 'male'
                        
-                       # Extract appearance
                        appearance = ''
                        for part in parts:
                            if '외모:' in part or 'Appearance:' in part:
@@ -860,7 +845,6 @@ Panel 30:
        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}',
@@ -872,7 +856,6 @@ Panel 30:
        
        return characters
 
-   # --- LLM call functions ---
    def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
        full_content = ""
        for chunk in self.call_llm_streaming(messages, role, language):
@@ -952,7 +935,7 @@ Panel 30:
            yield f"❌ Error occurred: {str(e)}"
 
    def get_system_prompts(self, language: str) -> Dict[str, str]:
-       """System prompts for webtoon roles with single-scene emphasis"""
+       """System prompts for webtoon roles with story-driven emphasis"""
        base_prompts = {
            "Korean": {
                "planner": """당신은 한국 웹툰 시장을 완벽히 이해하는 웹툰 기획자입니다.
@@ -969,18 +952,20 @@ Panel 30:
                "storyboarder": """당신은 웹툰 스토리보드 전문가입니다.
 30개 패널로 한 화를 완벽하게 구성합니다.
 세로 스크롤에 최적화된 연출을 합니다.
-각 패널마다 캐릭터의 유명인 닮은꼴 설정을 일관되게 포함합니다.
 
-⚠️ 가장 중요한 원칙: 
+⚠️ 가장 중요한 원칙 - 스토리 중심 전개: 
 1. 반드시 30개 패널을 모두 작성합니다.
-2. 각 패널은 **단 하나의 장면**만 담습니다.
-3. 캐릭터가 나올 때마다 반드시 "캐릭터이름(유명인 닮은 얼굴의 성별)" 형식을 유지합니다.
-4. 모든 패널에서 캐릭터 외모를 완벽히 일관되게 유지합니다.""",
+2. 각 패널은 **스토리 진행의 한 순간**을 담습니다.
+3. 단순 인물 샷이 아닌 **사건, 행동, 상황 중심**으로 구성합니다.
+4. 배경과 환경을 구체적으로 묘사합니다.
+5. 다양한 샷 타입을 활용하여 역동적으로 구성합니다.
+6. 캐릭터가 나올 때마다 "캐릭터이름(유명인 닮은 얼굴)" 형식을 유지합니다.""",
                
                "translator": """You are a professional translator specializing in webtoon and visual content.
 Translate Korean webtoon panel descriptions to English while maintaining:
-- Character names and descriptions
+- Focus on actions and scenes, not just characters
 - Visual details and camera angles
+- Environmental descriptions
 - Emotional nuances
 - Keep celebrity lookalike descriptions consistent"""
            },
@@ -998,18 +983,20 @@ Clearly specify character genders and appearances.
                
                "storyboarder": """You are a webtoon storyboard specialist.
 Perfectly compose one episode with 30 panels.
-Include consistent celebrity lookalike descriptions for characters.
 
-⚠️ Most important principles:
+⚠️ Most important principles - Story-Driven Focus:
 1. Must write all 30 panels.
-2. Each panel contains **ONLY ONE SCENE**.
-3. Always maintain "CharacterName (celebrity lookalike face gender)" format.
-4. Keep character appearances perfectly consistent across all panels.""",
+2. Each panel captures **a moment in story progression**.
+3. Focus on **events, actions, situations**, not just character shots.
+4. Describe backgrounds and environments specifically.
+5. Use varied shot types for dynamic composition.
+6. Always maintain "CharacterName (celebrity lookalike)" format.""",
                
                "translator": """You are a professional translator specializing in webtoon and visual content.
 Translate Korean webtoon panel descriptions to English while maintaining:
-- Character names and descriptions
+- Focus on actions and scenes, not just characters
 - Visual details and camera angles
+- Environmental descriptions
 - Emotional nuances
 - Keep celebrity lookalike descriptions consistent"""
            }
@@ -1017,7 +1004,6 @@ Translate Korean webtoon panel descriptions to English while maintaining:
        
        return base_prompts.get(language, base_prompts["Korean"])
 
-   # --- Main process ---
    def process_webtoon_stream(self, query: str, genre: str, language: str, 
                              session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str, Dict], None, None]:
        """Webtoon planning and storyboard generation process"""
@@ -1030,7 +1016,6 @@ Translate Korean webtoon panel descriptions to English while maintaining:
            else:
                self.current_session_id = session_id
 
-           # Phase 1 시작 알림
            yield "", "", f"🎬 웹툰 기획안 작성 중... (40화 전체 구성 포함) - 장르: {genre}", self.current_session_id, {}
            
            planning_prompt = self.create_planning_prompt(query, genre, language)
@@ -1041,18 +1026,14 @@ Translate Korean webtoon panel descriptions to English while maintaining:
            
            self.planning_doc = planning_doc
            
-           # Parse characters and assign celebrity lookalikes
            characters = self.parse_characters_from_planning(planning_doc)
            character_profiles = self.assign_celebrity_lookalikes(characters)
            
-           # Save character profiles and consistency map
            WebtoonDatabase.save_character_profiles(self.current_session_id, character_profiles)
            WebtoonDatabase.save_character_consistency(self.current_session_id, self.character_consistency_map)
            
-           # 기획안 완성 시점
            yield planning_doc, "", "✅ 기획안 완성! (40화 구성 완료)", self.current_session_id, character_profiles
 
-           # Phase 2: 1화 스토리보드 생성
            yield planning_doc, "", "🎨 1화 스토리보드 작성 중... (30개 패널)", self.current_session_id, character_profiles
            
            storyboard_prompt = self.create_storyboard_prompt(1, planning_doc, genre, language, character_profiles)
@@ -1061,13 +1042,10 @@ Translate Korean webtoon panel descriptions to English while maintaining:
                "storyboarder", language
            )
            
-           # Parse storyboard into structured format
            storyboard = self.parse_storyboard(storyboard_content, 1, character_profiles)
            
-           # Save to database
            WebtoonDatabase.save_storyboard(self.current_session_id, 1, storyboard)
            
-           # 최종 완료
            yield planning_doc, storyboard_content, "🎉 완성! (기획안 + 1화 스토리보드)", self.current_session_id, character_profiles
 
        except Exception as e:
@@ -1075,7 +1053,7 @@ Translate Korean webtoon panel descriptions to English while maintaining:
            yield "", "", f"❌ 오류 발생: {e}", self.current_session_id, {}
 
    def parse_storyboard(self, content: str, episode_num: int, character_profiles: Dict[str, CharacterProfile]) -> EpisodeStoryboard:
-       """Parse storyboard text into structured format with English translation"""
+       """Parse storyboard text into structured format with scene types"""
        storyboard = EpisodeStoryboard(episode_number=episode_num, title=f"{episode_num}화")
        
        panels = []
@@ -1086,7 +1064,6 @@ Translate Korean webtoon panel descriptions to English while maintaining:
        for line in lines:
            if '패널' in line or 'Panel' in line:
                if current_panel:
-                   # Translate Korean prompt to English before saving
                    if current_panel.image_prompt and not current_panel.image_prompt_en:
                        current_panel.image_prompt_en = self.translate_prompt_to_english(
                            current_panel.image_prompt, character_profiles
@@ -1102,12 +1079,22 @@ Translate Korean webtoon panel descriptions to English while maintaining:
                    panel_id=panel_id
                )
            elif current_panel:
-               if '이미지 프롬프트:' in line or 'Image prompt:' in line:
+               if '샷 타입:' in line or 'Shot type:' in line:
+                   shot = line.split(':', 1)[1].strip().lower()
+                   if 'establishing' in shot:
+                       current_panel.scene_type = "establishing"
+                   elif 'wide' in shot:
+                       current_panel.scene_type = "wide"
+                   elif 'close' in shot and 'extreme' in shot:
+                       current_panel.scene_type = "extreme_close_up"
+                   elif 'close' in shot:
+                       current_panel.scene_type = "close_up"
+                   else:
+                       current_panel.scene_type = "medium"
+               elif '이미지 프롬프트:' in line or 'Image prompt:' in line:
                    prompt = line.split(':', 1)[1].strip()
-                   # 캐릭터 일관성 확인 및 적용
                    for char_name, consistency in self.character_consistency_map.items():
                        if char_name in prompt and consistency['kr'] not in prompt:
-                           # 캐릭터 이름만 있고 설명이 없으면 추가
                            prompt = prompt.replace(char_name, consistency['kr'])
                    current_panel.image_prompt = prompt
                elif '대사:' in line or 'Dialogue:' in line:
@@ -1120,11 +1107,8 @@ Translate Korean webtoon panel descriptions to English while maintaining:
                    effects = line.split(':', 1)[1].strip()
                    if effects:
                        current_panel.sound_effects.append(effects)
-               elif '샷 타입:' in line or 'Shot type:' in line:
-                   current_panel.scene_type = line.split(':', 1)[1].strip()
        
        if current_panel:
-           # Translate last panel
            if current_panel.image_prompt and not current_panel.image_prompt_en:
                current_panel.image_prompt_en = self.translate_prompt_to_english(
                    current_panel.image_prompt, character_profiles
@@ -1134,7 +1118,7 @@ Translate Korean webtoon panel descriptions to English while maintaining:
        storyboard.panels = panels[:30]
        return storyboard
 
-# --- Export functions ---
+# Export functions
 def export_planning_to_txt(planning_doc: str, genre: str, title: str = "") -> str:
    """Export only planning document (40 episodes structure) to TXT"""
    content = f"{'=' * 50}\n"
@@ -1213,148 +1197,150 @@ def generate_random_webtoon_theme(genre: str, language: str) -> str:
    genre_themes = templates.get(genre, templates["로맨스"])
    return random.choice(genre_themes)
 
-# --- Helper functions for panel parsing (continued) ---
+# Parse storyboard panels for display
 def parse_storyboard_panels(storyboard_content, character_profiles=None):
-   """Parse storyboard content into structured panel data with English translation"""
-   if not storyboard_content:
-       print("No storyboard content provided")
-       return []
-   
-   panels = []
-   lines = storyboard_content.split('\n')
-   current_panel = None
-   panel_num = 0
-   
-   print(f"Parsing {len(lines)} lines of storyboard content")
-   
-   for i, line in enumerate(lines):
-       # 패널 감지
-       if any(keyword in line for keyword in ['패널', 'Panel']) and any(char.isdigit() for char in line):
-           if current_panel and current_panel.get('prompt'):
-               panels.append(current_panel)
-               print(f"Saved panel {current_panel['number']} with prompt: {current_panel['prompt'][:50]}...")
-           
-           # 패널 번호 추출
-           numbers = re.findall(r'\d+', line)
-           panel_num = int(numbers[0]) if numbers else panel_num + 1
-           
-           current_panel = {
-               'number': panel_num,
-               'shot': '',
-               'prompt': '',
-               'prompt_en': '',  # 영어 번역 프롬프트
-               'dialogue': '',
-               'narration': '',
-               'effects': '',
-               'image_url': None
-           }
-           print(f"Started parsing panel {panel_num}")
-       elif current_panel:
-           low = line.lower()
-           
-           if '샷 타입' in line or 'shot type' in low:
-               if any(sep in line for sep in [':', '：', '-', '–', '—']):
-                   current_panel['shot'] = re.split(r'[:：\-–—]', line, maxsplit=1)[1].strip()
-           
-           # 이미지 프롬프트 감지
-           elif (('이미지' in line and ('프롬' in line or '설명' in line)) or 
-                 ('image prompt' in low) or 
-                 re.search(r'\bprompt\s*[:：\-–—]', low)):
-               if any(sep in line for sep in [':', '：', '-', '–', '—']):
-                   prompt_text = re.split(r'[:：\-–—]', line, maxsplit=1)[1].strip()
-                   if prompt_text:
-                       current_panel['prompt'] = prompt_text
-                       print(f"Found prompt for panel {panel_num}: {prompt_text[:50]}...")
-               elif i + 1 < len(lines):
-                   next_line = lines[i + 1].strip()
-                   if next_line and not any(k in next_line.lower() for k in ['샷', 'shot', '대사', 'dialogue', '나레이션', 'narration', '효과음', 'sound', '패널', 'panel', '배경', 'background']):
-                       current_panel['prompt'] = next_line
-                       print(f"Found prompt on next line for panel {panel_num}: {next_line[:50]}...")
-           
-           elif '대사' in line or 'dialogue' in low:
-               if any(sep in line for sep in [':', '：', '-', '–', '—']):
-                   current_panel['dialogue'] = re.split(r'[:：\-–—]', line, maxsplit=1)[1].strip()
-           
-           elif '나레이션' in line or 'narration' in low:
-               if any(sep in line for sep in [':', '：', '-', '–', '—']):
-                   current_panel['narration'] = re.split(r'[:：\-–—]', line, maxsplit=1)[1].strip()
-           
-           elif '효과음' in line or 'sound effect' in low:
-               if any(sep in line for sep in [':', '：', '-', '–', '—']):
-                   current_panel['effects'] = re.split(r'[:：\-–—]', line, maxsplit=1)[1].strip()
-   
-   # 마지막 패널 추가
-   if current_panel and current_panel.get('prompt'):
-       panels.append(current_panel)
-       print(f"Saved last panel {current_panel['number']}")
-   
-   # 프롬프트가 없는 패널 제거 및 번호 정리
-   valid_panels = []
-   for i, panel in enumerate(panels):
-       if panel.get('prompt'):
-           if panel['number'] == 0:
-               panel['number'] = i + 1
-           valid_panels.append(panel)
-   
-   print(f"Total parsed panels with prompts: {len(valid_panels)}")
-   return valid_panels[:30]
-
-# --- Gradio interface ---
-# --- Gradio interface ---
-def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="K-Webtoon Storyboard Generator") as interface:
-        gr.HTML("""
-        <style>
-            .main-header {
-                text-align: center;
-                margin-bottom: 2rem;
-                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                padding: 2rem;
-                border-radius: 15px;
-                color: white;
-            }
-            
-            .header-title {
-                font-size: 3rem;
-                margin-bottom: 1rem;
-                text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
-            }
-            
-            .character-profile {
-                background: #f0f0f0;
-                padding: 10px;
-                margin: 5px 0;
-                border-radius: 8px;
-            }
-            
-            .panel-container {
-                border: 2px solid #ddd;
-                border-radius: 10px;
-                padding: 20px;
-                margin-bottom: 20px;
-                background: white;
-                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            }
+    """Parse storyboard content into structured panel data"""
+    if not storyboard_content:
+        return []
+    
+    panels = []
+    lines = storyboard_content.split('\n')
+    current_panel = None
+    panel_num = 0
+    
+    for i, line in enumerate(lines):
+        if any(keyword in line for keyword in ['패널', 'Panel']) and any(char.isdigit() for char in line):
+            if current_panel and current_panel.get('prompt'):
+                panels.append(current_panel)
             
-            .panel-header {
-                font-size: 18px;
-                font-weight: bold;
-                color: #764ba2;
-                margin-bottom: 15px;
-                border-bottom: 2px solid #764ba2;
-                padding-bottom: 10px;
-            }
+            numbers = re.findall(r'\d+', line)
+            panel_num = int(numbers[0]) if numbers else panel_num + 1
             
-            .episode-structure {
-                background: #f5f5f5;
-                padding: 15px;
-                border-radius: 8px;
-                margin: 10px 0;
-                max-height: 500px;
-                overflow-y: auto;
+            current_panel = {
+                'number': panel_num,
+                'shot': '',
+                'prompt': '',
+                'prompt_en': '',
+                'dialogue': '',
+                'narration': '',
+                'effects': '',
+                'image_url': None,
+                'scene_type': 'medium'
             }
-        </style>
-        
+        elif current_panel:
+            if '샷 타입:' in line or 'Shot type:' in line.lower():
+                shot = line.split(':', 1)[1].strip() if ':' in line else ''
+                current_panel['shot'] = shot
+                # Determine scene type
+                if 'establishing' in shot.lower():
+                    current_panel['scene_type'] = 'establishing'
+                elif 'wide' in shot.lower():
+                    current_panel['scene_type'] = 'wide'
+                elif 'extreme' in shot.lower() and 'close' in shot.lower():
+                    current_panel['scene_type'] = 'extreme_close_up'
+                elif 'close' in shot.lower():
+                    current_panel['scene_type'] = 'close_up'
+                else:
+                    current_panel['scene_type'] = 'medium'
+            elif '이미지 프롬프트:' in line or 'Image prompt:' in line.lower():
+                current_panel['prompt'] = line.split(':', 1)[1].strip() if ':' in line else ''
+            elif '대사:' in line or 'Dialogue:' in line.lower():
+                current_panel['dialogue'] = line.split(':', 1)[1].strip() if ':' in line else ''
+            elif '나레이션:' in line or 'Narration:' in line.lower():
+                current_panel['narration'] = line.split(':', 1)[1].strip() if ':' in line else ''
+            elif '효과음:' in line or 'Sound effect:' in line.lower():
+                current_panel['effects'] = line.split(':', 1)[1].strip() if ':' in line else ''
+    
+    if current_panel and current_panel.get('prompt'):
+        panels.append(current_panel)
+    
+    return panels[:30]
+
+# Gradio interface with side-by-side panel layout
+def create_interface():
+    with gr.Blocks(theme=gr.themes.Soft(), title="K-Webtoon Storyboard Generator", css="""
+        .main-header {
+            text-align: center;
+            margin-bottom: 2rem;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            padding: 2rem;
+            border-radius: 15px;
+            color: white;
+        }
+        .header-title {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
+        }
+        .panel-container {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin: 20px 0;
+        }
+        .panel-text-box {
+            border: 2px solid #e0e0e0;
+            border-radius: 10px;
+            padding: 15px;
+            background: #f9f9f9;
+            height: 400px;
+            overflow-y: auto;
+        }
+        .panel-image-box {
+            border: 2px solid #e0e0e0;
+            border-radius: 10px;
+            padding: 15px;
+            background: white;
+            height: 400px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .panel-header {
+            font-size: 18px;
+            font-weight: bold;
+            color: #764ba2;
+            margin-bottom: 10px;
+            border-bottom: 2px solid #764ba2;
+            padding-bottom: 5px;
+        }
+        .panel-content {
+            font-size: 14px;
+            line-height: 1.8;
+        }
+        .panel-image {
+            max-width: 100%;
+            max-height: 100%;
+            object-fit: contain;
+            border-radius: 8px;
+        }
+        .shot-type {
+            display: inline-block;
+            background: #764ba2;
+            color: white;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            margin-bottom: 5px;
+        }
+        .panel-dialogue {
+            background: #fff;
+            padding: 8px;
+            border-left: 3px solid #667eea;
+            margin: 5px 0;
+        }
+        .panel-narration {
+            font-style: italic;
+            color: #666;
+            margin: 5px 0;
+        }
+        .panel-effects {
+            color: #ff6b6b;
+            font-weight: bold;
+            margin: 5px 0;
+        }
+    """) as interface:
+        gr.HTML("""
         <div class="main-header">
             <h1 class="header-title">🎨 K-Webtoon Storyboard Generator</h1>
             <p class="header-subtitle">한국형 웹툰 기획 및 스토리보드 자동 생성 시스템</p>
@@ -1438,12 +1424,13 @@ def create_interface():
         with gr.Tab("🎬 1화 스토리보드 (30패널)"):
             gr.Markdown("""
             ### 📋 1화 스토리보드 - 30개 패널
-            각 패널의 텍스트를 편집할 수 있습니다. 편집 후 '적용' 버튼을 클릭하세요.
+            각 패널은 스토리 전개에 따라 구성되며, 좌측에 텍스트, 우측에 이미지가 표시됩니다.
             """)
             
             # Control buttons
             with gr.Row():
                 apply_edits_btn = gr.Button("✅ 편집 내용 적용", variant="secondary")
+                generate_selected_btn = gr.Button("🎨 선택한 패널 이미지 생성", variant="secondary")
                 generate_all_images_btn = gr.Button("🎨 모든 패널 이미지 생성", variant="primary", size="lg")
                 download_storyboard_btn = gr.Button("📥 스토리보드 다운로드", variant="secondary")
                 clear_images_btn = gr.Button("🗑️ 이미지 초기화", variant="secondary")
@@ -1454,22 +1441,23 @@ def create_interface():
             # Editable storyboard display
             storyboard_editor = gr.Textbox(
                 label="스토리보드 편집기",
-                lines=30,
-                max_lines=50,
+                lines=15,
+                max_lines=30,
                 interactive=True,
-                placeholder="스토리보드가 생성되면 여기에 표시됩니다. 자유롭게 편집하세요."
+                placeholder="스토리보드가 생성되면 여기에 표시됩니다. 자유롭게 편집하세요.",
+                visible=False
             )
             
-            # Panel images gallery
-            gr.Markdown("### 🖼️ 생성된 이미지")
-            images_gallery = gr.Gallery(
-                label="패널 이미지",
-                show_label=False,
-                elem_id="gallery",
-                columns=5,
-                rows=6,
-                height="auto"
+            # Panel selector
+            panel_selector = gr.CheckboxGroup(
+                label="이미지 생성할 패널 선택",
+                choices=[f"패널 {i}" for i in range(1, 31)],
+                value=[],
+                visible=False
             )
+            
+            # Panels display area with side-by-side layout
+            panels_display = gr.HTML(label="패널 표시", value="<p>스토리보드를 생성하면 여기에 패널이 표시됩니다.</p>")
 
         # Helper functions
         def process_query(query, genre, language, session_id):
@@ -1491,7 +1479,7 @@ def create_interface():
             html = "<h3>🎭 캐릭터 프로필</h3>"
             for name, profile in profiles.items():
                 html += f"""
-                <div class="character-profile">
+                <div style="background: #f0f0f0; padding: 10px; margin: 5px 0; border-radius: 8px;">
                     <strong>{name}</strong> - {profile.celebrity_lookalike_kr} 닮은 얼굴 ({profile.celebrity_lookalike_en})
                     <br>역할: {profile.role}
                     <br>성격: {profile.personality}
@@ -1500,63 +1488,107 @@ def create_interface():
                 """
             return html
         
+        def display_panels_side_by_side(panel_data):
+            """Display panels in side-by-side format"""
+            if not panel_data:
+                return "<p>패널 데이터가 없습니다. 스토리보드를 먼저 생성하세요.</p>"
+            
+            html = ""
+            for panel in panel_data:
+                html += f"""
+                <div class="panel-container">
+                    <div class="panel-text-box">
+                        <div class="panel-header">패널 {panel['number']}</div>
+                        <div class="panel-content">
+                            <span class="shot-type">{panel.get('shot', 'medium')}</span>
+                            <div><strong>장면:</strong> {panel.get('prompt', '')}</div>
+                            {f'<div class="panel-dialogue"><strong>대사:</strong> {panel["dialogue"]}</div>' if panel.get('dialogue') else ''}
+                            {f'<div class="panel-narration"><strong>나레이션:</strong> {panel["narration"]}</div>' if panel.get('narration') else ''}
+                            {f'<div class="panel-effects"><strong>효과음:</strong> {panel["effects"]}</div>' if panel.get('effects') else ''}
+                        </div>
+                    </div>
+                    <div class="panel-image-box">
+                        {f'<img src="{panel["image_url"]}" class="panel-image" alt="Panel {panel["number"]}" />' if panel.get('image_url') else '<p style="color: #999;">이미지가 아직 생성되지 않았습니다</p>'}
+                    </div>
+                </div>
+                """
+            return html
+        
         def apply_edited_storyboard(edited_text, session_id, character_profiles):
             """Parse and apply edited storyboard text"""
             if not edited_text:
-                return [], "스토리보드가 비어있습니다."
+                return [], "<p>스토리보드가 비어있습니다.</p>", gr.update(visible=False), gr.update(visible=False)
             
-            # Parse the edited text back into panel data
-            panel_data = []
-            lines = edited_text.split('\n')
-            current_panel = None
+            panel_data = parse_storyboard_panels(edited_text, character_profiles)
             
-            for line in lines:
-                if '패널' in line and any(char.isdigit() for char in line):
-                    if current_panel and current_panel.get('prompt'):
-                        panel_data.append(current_panel)
-                    
-                    numbers = re.findall(r'\d+', line)
-                    panel_num = int(numbers[0]) if numbers else len(panel_data) + 1
-                    
-                    current_panel = {
-                        'number': panel_num,
-                        'shot': '',
-                        'prompt': '',
-                        'prompt_en': '',
-                        'dialogue': '',
-                        'narration': '',
-                        'effects': '',
-                        'image_url': None
-                    }
-                elif current_panel:
-                    if '샷 타입:' in line or 'Shot type:' in line.lower():
-                        current_panel['shot'] = line.split(':', 1)[1].strip() if ':' in line else ''
-                    elif '이미지 프롬프트:' in line or 'Image prompt:' in line.lower():
-                        current_panel['prompt'] = line.split(':', 1)[1].strip() if ':' in line else ''
-                    elif '대사:' in line or 'Dialogue:' in line.lower():
-                        current_panel['dialogue'] = line.split(':', 1)[1].strip() if ':' in line else ''
-                    elif '나레이션:' in line or 'Narration:' in line.lower():
-                        current_panel['narration'] = line.split(':', 1)[1].strip() if ':' in line else ''
-                    elif '효과음:' in line or 'Sound effect:' in line.lower():
-                        current_panel['effects'] = line.split(':', 1)[1].strip() if ':' in line else ''
+            if panel_data:
+                html = display_panels_side_by_side(panel_data)
+                panel_choices = [f"패널 {p['number']}" for p in panel_data]
+                return panel_data, html, gr.update(visible=True, choices=panel_choices, value=[]), gr.update(visible=True, value=edited_text)
             
-            if current_panel and current_panel.get('prompt'):
-                panel_data.append(current_panel)
+            return [], "<p>패널을 파싱할 수 없습니다.</p>", gr.update(visible=False), gr.update(visible=True)
+        
+        def generate_selected_panel_images(panel_data, selected_panels, session_id, character_profiles, webtoon_system, progress=gr.Progress()):
+            """Generate images for selected panels only"""
+            if not REPLICATE_API_TOKEN:
+                return display_panels_side_by_side(panel_data), gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
+            
+            if not panel_data:
+                return display_panels_side_by_side(panel_data), gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
             
-            return panel_data[:30], f"✅ {len(panel_data)}개 패널이 적용되었습니다."
+            if not selected_panels:
+                return display_panels_side_by_side(panel_data), gr.update(visible=True, value="⚠️ 생성할 패널을 선택하세요.")
+            
+            if not webtoon_system:
+                webtoon_system = WebtoonSystem()
+            
+            selected_numbers = [int(p.split()[1]) for p in selected_panels]
+            total = len(selected_numbers)
+            successful = 0
+            
+            for i, panel in enumerate(panel_data):
+                if panel['number'] in selected_numbers:
+                    idx = selected_numbers.index(panel['number'])
+                    progress((idx / total), desc=f"패널 {panel['number']} 생성 중...")
+                    
+                    if panel.get('prompt'):
+                        try:
+                            # Translate if needed
+                            if not panel.get('prompt_en'):
+                                panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
+                                    panel['prompt'], character_profiles
+                                )
+                            
+                            # Generate with scene type
+                            result = webtoon_system.image_generator.generate_image(
+                                panel['prompt_en'],
+                                f"ep1_panel{panel['number']}",
+                                session_id,
+                                scene_type=panel.get('scene_type', 'medium')
+                            )
+                            
+                            if result['status'] == 'success':
+                                panel['image_url'] = result['image_url']
+                                successful += 1
+                        except Exception as e:
+                            logger.error(f"Error generating panel {panel['number']}: {e}")
+                        
+                        time.sleep(0.5)
+            
+            progress(1.0, desc=f"완료! {successful}/{total} 패널 생성 성공")
+            return display_panels_side_by_side(panel_data), gr.update(visible=False)
         
-        def generate_all_panel_images_from_editor(panel_data, session_id, character_profiles, webtoon_system, progress=gr.Progress()):
-            """Generate images for all panels from edited data"""
+        def generate_all_panel_images(panel_data, session_id, character_profiles, webtoon_system, progress=gr.Progress()):
+            """Generate images for all panels"""
             if not REPLICATE_API_TOKEN:
-                return [], gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
+                return display_panels_side_by_side(panel_data), gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
             
             if not panel_data:
-                return [], gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
+                return display_panels_side_by_side(panel_data), gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
             
             if not webtoon_system:
                 webtoon_system = WebtoonSystem()
             
-            generated_images = []
             total_panels = len(panel_data)
             successful = 0
             failed = 0
@@ -1566,28 +1598,22 @@ def create_interface():
                 
                 if panel.get('prompt'):
                     try:
-                        # Translate to English if needed
+                        # Translate if needed
                         if not panel.get('prompt_en'):
                             panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
                                 panel['prompt'], character_profiles
                             )
                         
-                        # Generate image
+                        # Generate with scene type
                         result = webtoon_system.image_generator.generate_image(
                             panel['prompt_en'],
                             f"ep1_panel{panel['number']}",
-                            session_id
+                            session_id,
+                            scene_type=panel.get('scene_type', 'medium')
                         )
                         
                         if result['status'] == 'success':
-                            # Download and convert image
-                            import requests
-                            from PIL import Image
-                            from io import BytesIO
-                            
-                            response = requests.get(result['image_url'])
-                            img = Image.open(BytesIO(response.content))
-                            generated_images.append((img, f"Panel {panel['number']}"))
+                            panel['image_url'] = result['image_url']
                             successful += 1
                         else:
                             failed += 1
@@ -1598,10 +1624,12 @@ def create_interface():
                     time.sleep(0.5)  # Rate limiting
             
             progress(1.0, desc=f"완료! 성공: {successful}, 실패: {failed}")
-            return generated_images, gr.update(visible=False)
+            return display_panels_side_by_side(panel_data), gr.update(visible=False)
         
-        def clear_all_images():
-            return []
+        def clear_all_images(panel_data):
+            for panel in panel_data:
+                panel['image_url'] = None
+            return display_panels_side_by_side(panel_data)
         
         def handle_random_theme(genre, language):
             return generate_random_webtoon_theme(genre, language)
@@ -1648,32 +1676,47 @@ def create_interface():
             fn=lambda x: x,
             inputs=[storyboard_state],
             outputs=[storyboard_editor]
+        ).then(
+            fn=apply_edited_storyboard,
+            inputs=[storyboard_state, current_session_id, character_profiles_state],
+            outputs=[panel_data_state, panels_display, panel_selector, storyboard_editor]
         )
         
         # Apply edits button
         apply_edits_btn.click(
             fn=apply_edited_storyboard,
             inputs=[storyboard_editor, current_session_id, character_profiles_state],
-            outputs=[panel_data_state, generation_progress]
+            outputs=[panel_data_state, panels_display, panel_selector, storyboard_editor]
         ).then(
             fn=lambda: gr.update(visible=True, value="편집 내용이 적용되었습니다."),
             outputs=[generation_progress]
         )
         
+        # Generate selected images
+        generate_selected_btn.click(
+            fn=lambda: gr.update(visible=True, value="선택한 패널 이미지 생성 시작..."),
+            outputs=[generation_progress]
+        ).then(
+            fn=generate_selected_panel_images,
+            inputs=[panel_data_state, panel_selector, current_session_id, character_profiles_state, webtoon_system],
+            outputs=[panels_display, generation_progress]
+        )
+        
         # Generate all images
         generate_all_images_btn.click(
-            fn=lambda: gr.update(visible=True, value="이미지 생성 시작..."),
+            fn=lambda: gr.update(visible=True, value="모든 패널 이미지 생성 시작..."),
             outputs=[generation_progress]
         ).then(
-            fn=generate_all_panel_images_from_editor,
+            fn=generate_all_panel_images,
             inputs=[panel_data_state, current_session_id, character_profiles_state, webtoon_system],
-            outputs=[images_gallery, generation_progress]
+            outputs=[panels_display, generation_progress]
         )
         
         # Clear images
         clear_images_btn.click(
             fn=clear_all_images,
-            outputs=[images_gallery]
+            inputs=[panel_data_state],
+            outputs=[panels_display]
         )
         
         # Random theme