Update app-BACKUP.py

app-BACKUP.py

@@ -10,6 +10,7 @@ import tempfile
 import random
 from typing import Dict, List, Tuple, Optional
 import shutil
+import concurrent.futures
 
 import gradio as gr
 from loguru import logger
@@ -48,6 +49,28 @@ SERPHOUSE_API_KEY = os.getenv("SERPHOUSE_API_KEY", "")
 if not SERPHOUSE_API_KEY:
     logger.warning("SERPHOUSE_API_KEY not set. Web search functionality will be limited.")
 
+##############################################################################
+# AI Image Generation API Configuration - 3D Style
+##############################################################################
+AI_IMAGE_API_URL = "http://211.233.58.201:7971/"
+AI_IMAGE_ENABLED = False
+ai_image_client = None
+
+def initialize_ai_image_api():
+    """AI 이미지 생성 API 초기화 (3D 스타일)"""
+    global AI_IMAGE_ENABLED, ai_image_client
+    
+    try:
+        logger.info("Connecting to AI image generation API (3D style)...")
+        ai_image_client = Client(AI_IMAGE_API_URL)
+        AI_IMAGE_ENABLED = True
+        logger.info("AI image generation API (3D style) connected successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to connect to AI image API: {e}")
+        AI_IMAGE_ENABLED = False
+        return False
+
 ##############################################################################
 # AI Image Generation API Configuration - FLUX API
 ##############################################################################
@@ -863,89 +886,169 @@ def pdf_to_markdown(pdf_path: str) -> str:
     return f"**[PDF File: {os.path.basename(pdf_path)}]**\n\n{full_text}"
 
 ##############################################################################
-# AI Image Generation Functions using FLUX API
+# AI Image Generation Functions using Multiple APIs
 ##############################################################################
-def generate_cover_image_prompt(topic: str, slides_data: list) -> str:
-    """PPT 주제와 내용을 기반으로 표지 이미지 프롬프트 생성"""
+def generate_diverse_prompt(title: str, content: str, slide_index: int) -> Tuple[str, str]:
+    """슬라이드별로 다양한 프롬프트 생성 - 3D와 포토리얼리스틱 버전"""
     
     # 주요 키워드 추출
-    keywords = extract_keywords(topic, top_k=3).split()
+    keywords = extract_keywords(f"{title} {content}", top_k=5).split()
     
-    # 주제 분석을 통한 스타일 결정
-    style = "modern professional"
-    topic_lower = topic.lower()
+    # 슬라이드 인덱스에 따라 다양한 스타일 적용
+    styles_3d = [
+        "isometric 3D illustration",
+        "low poly 3D art",
+        "3D cartoon style",
+        "3D glass morphism",
+        "3D neon glow effect",
+        "3D paper cut art",
+        "3D clay render",
+        "3D geometric abstract"
+    ]
     
-    if any(word in topic_lower for word in ['기술', 'tech', 'ai', '인공지능', 'digital', '디지털']):
-        style = "futuristic technology"
-    elif any(word in topic_lower for word in ['비즈니스', 'business', '경영', 'management']):
-        style = "corporate business"
-    elif any(word in topic_lower for word in ['교육', 'education', '학습', 'learning']):
-        style = "educational inspiring"
-    elif any(word in topic_lower for word in ['환경', 'environment', '자연', 'nature']):
-        style = "nature eco-friendly"
-    elif any(word in topic_lower for word in ['의료', 'medical', '건강', 'health']):
-        style = "medical healthcare"
-    elif any(word in topic_lower for word in ['금융', 'finance', '투자', 'investment']):
-        style = "financial professional"
+    styles_photo = [
+        "professional photography",
+        "cinematic shot",
+        "minimalist photography",
+        "aerial view photograph",
+        "macro photography",
+        "dramatic lighting photo",
+        "architectural photography",
+        "lifestyle photography"
+    ]
     
-    # FLUX를 위한 영어 프롬프트 구성
-    prompt = f"Professional presentation cover design, {style} theme, abstract geometric shapes representing {' '.join(keywords)}, modern minimalist style, gradient background, clean composition, high quality, corporate design"
+    # 내용 기반 시각 메타포 선택
+    visual_metaphors = []
+    content_lower = (title + " " + content).lower()
     
-    return prompt
-
-def generate_conclusion_image_prompt(title: str, content: str) -> str:
-    """결론 슬라이드용 이미지 프롬프트 생성"""
+    if any(word in content_lower for word in ['성장', 'growth', '증가', 'increase']):
+        visual_metaphors = ["ascending stairs", "growing tree", "rocket launch", "mountain peak", "rising graph"]
+    elif any(word in content_lower for word in ['혁신', 'innovation', '창의', 'creative']):
+        visual_metaphors = ["lightbulb moment", "puzzle pieces connecting", "spark of genius", "breaking boundaries", "colorful explosion"]
+    elif any(word in content_lower for word in ['협업', 'collaboration', '팀', 'team']):
+        visual_metaphors = ["hands joining together", "connected network", "team huddle", "bridge building", "interlocking gears"]
+    elif any(word in content_lower for word in ['데이터', 'data', '분석', 'analysis']):
+        visual_metaphors = ["data visualization", "digital dashboard", "flowing data streams", "analytical charts", "information network"]
+    elif any(word in content_lower for word in ['미래', 'future', '전망', 'vision']):
+        visual_metaphors = ["horizon view", "crystal ball", "futuristic cityscape", "pathway to tomorrow", "digital transformation"]
+    elif any(word in content_lower for word in ['프로세스', 'process', '단계', 'step']):
+        visual_metaphors = ["flowing river", "assembly line", "domino effect", "clockwork mechanism", "journey path"]
+    elif any(word in content_lower for word in ['목표', 'goal', '성공', 'success']):
+        visual_metaphors = ["target with arrow", "trophy on pedestal", "finish line", "mountain summit", "golden key"]
+    else:
+        visual_metaphors = ["abstract shapes", "dynamic composition", "symbolic representation", "conceptual art", "modern design"]
+    
+    # 스타일과 메타포 선택
+    style_3d = styles_3d[slide_index % len(styles_3d)]
+    style_photo = styles_photo[slide_index % len(styles_photo)]
+    metaphor = random.choice(visual_metaphors)
+    
+    # 색상 팔레트 다양화
+    color_palettes = [
+        "vibrant blue and orange",
+        "elegant purple and gold",
+        "fresh green and white",
+        "bold red and black",
+        "soft pastel tones",
+        "monochromatic blue",
+        "warm sunset colors",
+        "cool ocean palette"
+    ]
+    colors = color_palettes[slide_index % len(color_palettes)]
     
-    # 주요 키워드 추출
-    keywords = extract_keywords(f"{title} {content}", top_k=5).split()
+    # 3D 스타일 프롬프트 (한글)
+    prompt_3d = f"wbgmsst, {style_3d}, {metaphor} representing {' '.join(keywords[:3])}, {colors}, professional presentation slide, high quality, white background"
+    
+    # 포토리얼리스틱 프롬프트 (영어)
+    prompt_photo = f"{style_photo} of {metaphor} symbolizing {' '.join(keywords[:3])}, {colors} color scheme, professional business context, clean composition, high resolution"
+    
+    return prompt_3d, prompt_photo
+
+def generate_cover_image_prompts(topic: str, slides_data: list) -> Tuple[str, str]:
+    """표지용 3D와 포토리얼리스틱 프롬프트 생성"""
     
-    # 결론/하이라이트 관련 키워드 감지
-    conclusion_keywords = ['결론', 'conclusion', '요약', 'summary', '핵심', 'key', 
-                          '중요', 'important', '미래', 'future', '전망', 'outlook']
+    keywords = extract_keywords(topic, top_k=3).split()
     
-    # 프롬프트 스타일 결정
-    if any(word in title.lower() + content.lower() for word in conclusion_keywords):
-        style = "inspirational conclusion with bright future vision"
+    # 주제별 특화된 시각 요소
+    topic_lower = topic.lower()
+    if any(word in topic_lower for word in ['기술', 'tech', 'ai', '인공지능']):
+        visual_3d = "futuristic 3D holographic interface"
+        visual_photo = "modern technology workspace with holographic displays"
+    elif any(word in topic_lower for word in ['비즈니스', 'business', '경영']):
+        visual_3d = "3D corporate building with glass architecture"
+        visual_photo = "professional business meeting in modern office"
+    elif any(word in topic_lower for word in ['교육', 'education', '학습']):
+        visual_3d = "3D books transforming into knowledge symbols"
+        visual_photo = "inspiring educational environment with digital elements"
+    elif any(word in topic_lower for word in ['환경', 'environment', '자연']):
+        visual_3d = "3D earth with renewable energy icons"
+        visual_photo = "pristine nature landscape with sustainable elements"
     else:
-        style = "professional summary visualization"
+        visual_3d = "abstract 3D geometric composition"
+        visual_photo = "professional abstract photography"
     
-    # FLUX 프롬프트 구성
-    prompt = f"Professional presentation conclusion slide, {style}, highlighting {' '.join(keywords[:3])}, modern abstract visualization, uplifting mood, corporate design, high quality"
+    prompt_3d = f"wbgmsst, {visual_3d}, {' '.join(keywords)} theme, premium 3D render, elegant composition, gradient background"
+    prompt_photo = f"{visual_photo} featuring {' '.join(keywords)}, cinematic lighting, professional presentation cover, high-end photography"
     
-    return prompt
+    return prompt_3d, prompt_photo
 
-def generate_flux_prompt(title: str, content: str) -> str:
-    """슬라이드 내용을 기반으로 FLUX 이미지 프롬프트 생성"""
+def generate_conclusion_image_prompts(title: str, content: str) -> Tuple[str, str]:
+    """결론 슬라이드용 특별한 프롬프트 생성"""
     
-    # 주요 키워드 추출
     keywords = extract_keywords(f"{title} {content}", top_k=4).split()
     
-    # 내용 분석을 통한 스타일 결정
-    content_lower = (title + " " + content).lower()
-    
-    style = "professional business"
-    if any(word in content_lower for word in ['data', '데이터', 'analysis', '분석', 'chart', '차트']):
-        style = "data visualization analytics"
-    elif any(word in content_lower for word in ['process', '프로세스', 'workflow', '워크플로우']):
-        style = "workflow process diagram"
-    elif any(word in content_lower for word in ['team', '팀', 'collaboration', '협업']):
-        style = "teamwork collaboration"
-    elif any(word in content_lower for word in ['growth', '성장', 'increase', '증가']):
-        style = "growth success metrics"
+    # 결론 스타일 비주얼
+    prompt_3d = f"wbgmsst, 3D trophy or achievement symbol, {' '.join(keywords[:2])} success visualization, golden lighting, celebration mood, premium quality"
+    prompt_photo = f"inspirational sunrise or horizon view symbolizing {' '.join(keywords[:2])}, bright future ahead, professional photography, uplifting atmosphere"
     
-    # FLUX 프롬프트 구성
-    prompt = f"Professional presentation slide illustration, {style} theme, featuring {' '.join(keywords[:3])}, modern business graphics, clean corporate design, white background, high quality"
+    return prompt_3d, prompt_photo
+
+def generate_ai_image_via_3d_api(prompt: str) -> Optional[str]:
+    """3D 스타일 API를 통해 이미지 생성"""
+    if not AI_IMAGE_ENABLED or not ai_image_client:
+        return None
     
-    return prompt
+    try:
+        logger.info(f"Generating 3D style image with prompt: {prompt[:100]}...")
+        
+        result = ai_image_client.predict(
+            height=1024.0,
+            width=1024.0,
+            steps=8.0,
+            scales=3.5,
+            prompt=prompt,
+            seed=float(random.randint(0, 1000000)),
+            api_name="/process_and_save_image"
+        )
+        
+        # 결과 처리
+        image_path = None
+        if isinstance(result, dict):
+            image_path = result.get("path")
+        elif isinstance(result, str):
+            image_path = result
+        
+        if image_path and os.path.exists(image_path):
+            # PNG로 변환
+            with Image.open(image_path) as img:
+                png_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                img.save(png_tmp.name, format="PNG")
+                logger.info(f"3D image generated and saved to {png_tmp.name}")
+                return png_tmp.name
+        
+        return None
+        
+    except Exception as e:
+        logger.error(f"Failed to generate 3D image: {e}")
+        return None
 
 def generate_flux_image_via_api(prompt: str) -> Optional[str]:
-    """FLUX API를 통해 이미지 생성"""
+    """FLUX API를 통해 포토리얼리스틱 이미지 생성"""
     if not FLUX_API_ENABLED or not flux_api_client:
-        logger.warning("FLUX API is not available")
         return None
     
     try:
-        logger.info(f"Generating FLUX image with prompt: {prompt[:100]}...")
+        logger.info(f"Generating FLUX photorealistic image with prompt: {prompt[:100]}...")
         
         result = flux_api_client.predict(
             prompt=prompt,
@@ -964,7 +1067,6 @@ def generate_flux_image_via_api(prompt: str) -> Optional[str]:
         if isinstance(result, tuple) and len(result) > 0:
             image_path = result[0]
             if image_path and os.path.exists(image_path):
-                # PNG로 변환
                 with Image.open(image_path) as img:
                     png_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
                     img.save(png_tmp.name, format="PNG")
@@ -977,22 +1079,28 @@ def generate_flux_image_via_api(prompt: str) -> Optional[str]:
         logger.error(f"Failed to generate FLUX image: {e}")
         return None
 
-def generate_ai_cover_image_via_flux(topic: str, slides_data: list) -> Optional[str]:
-    """FLUX API를 통해 AI 표지 이미지 생성"""
-    if not FLUX_API_ENABLED:
-        return None
-
-    prompt = generate_cover_image_prompt(topic, slides_data)
-    return generate_flux_image_via_api(prompt)
+def generate_images_parallel(prompt_3d: str, prompt_photo: str) -> Tuple[Optional[str], Optional[str]]:
+    """두 API를 병렬로 호출하여 이미지 생성"""
+    import concurrent.futures
+    
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        # 두 API를 동시에 호출
+        future_3d = executor.submit(generate_ai_image_via_3d_api, prompt_3d)
+        future_photo = executor.submit(generate_flux_image_via_api, prompt_photo)
+        
+        # 결과 대기
+        image_3d = future_3d.result()
+        image_photo = future_photo.result()
+        
+    return image_3d, image_photo
 
 ##############################################################################
 # PPT Generation Functions - FIXED VERSION
 ##############################################################################
 def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> list:
-    """Parse LLM response to extract slide content - COMPLETELY FIXED VERSION"""
+    """Parse LLM response to extract slide content - FIXED VERSION"""
     slides = []
     
-    # Debug: 전체 응답 확인
     logger.info(f"Parsing LLM response, total length: {len(response)}")
     logger.debug(f"First 500 chars: {response[:500]}")
     
@@ -1005,24 +1113,45 @@ def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> l
     except:
         pass
     
-    # Split by slide markers and process each section
-    # 슬라이드를 구분하는 더 강력한 정규식
-    slide_pattern = r'(?:^|\n)(?:슬라이드|Slide)\s*\d+|(?:^|\n)\d+[\.)](?:\s|$)'
-    
-    # 슬라이드 섹션으로 분할
-    sections = re.split(slide_pattern, response, flags=re.MULTILINE | re.IGNORECASE)
-    
-    # 첫 번째 빈 섹션 제거
-    if sections and not sections[0].strip():
-        sections = sections[1:]
-    
-    logger.info(f"Found {len(sections)} potential slide sections")
-    
-    for idx, section in enumerate(sections):
-        if not section.strip():
+    # 더 정확한 슬라이드 구분 패턴
+    # "슬라이드 1", "슬라이드 2" 또는 "Slide 1", "Slide 2" 형식을 찾음
+    slide_markers = []
+    
+    # 슬라이드 마커의 위치를 먼저 찾음
+    for match in re.finditer(r'^(?:슬라이드|Slide)\s*(\d+)\s*$', response, re.MULTILINE):
+        slide_markers.append({
+            'index': int(match.group(1)),
+            'start': match.start(),
+            'end': match.end()
+        })
+    
+    logger.info(f"Found {len(slide_markers)} slide markers")
+    
+    # 슬라이드 마커가 없으면 다른 패턴 시도
+    if not slide_markers:
+        # 숫자만으로 시작하는 패턴도 찾기 (예: "1.", "2." 등)
+        for match in re.finditer(r'^(\d+)[.)]\s*$', response, re.MULTILINE):
+            slide_markers.append({
+                'index': int(match.group(1)),
+                'start': match.start(),
+                'end': match.end()
+            })
+    
+    # 각 슬라이드 마커 사이의 내용을 추출
+    for i, marker in enumerate(slide_markers):
+        # 현재 슬라이드의 시작과 끝 위치
+        start = marker['end']
+        if i < len(slide_markers) - 1:
+            end = slide_markers[i + 1]['start']
+        else:
+            end = len(response)
+        
+        section = response[start:end].strip()
+        
+        if not section:
             continue
             
-        logger.debug(f"Processing section {idx}: {section[:100]}...")
+        logger.debug(f"Processing slide {marker['index']}: {section[:100]}...")
         
         slide = {
             'title': '',
@@ -1033,9 +1162,9 @@ def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> l
         }
         
         # 섹션 내에서 제목, 내용, 노트 추출
-        lines = section.strip().split('\n')
+        lines = section.split('\n')
         current_part = None
-        title_lines = []
+        title_found = False
         content_lines = []
         notes_lines = []
         
@@ -1045,11 +1174,11 @@ def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> l
                 continue
             
             # 제목 섹션 감지
-            if line.startswith('제목:') or line.startswith('Title:'):
+            if (line.startswith('제목:') or line.startswith('Title:')) and not title_found:
                 current_part = 'title'
                 title_text = line.split(':', 1)[1].strip() if ':' in line else ''
-                if title_text:
-                    title_lines.append(title_text)
+                slide['title'] = title_text
+                title_found = True
             # 내용 섹션 감지
             elif line.startswith('내용:') or line.startswith('Content:'):
                 current_part = 'content'
@@ -1064,57 +1193,91 @@ def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> l
                     notes_lines.append(notes_text)
             # 현재 섹션에 따라 내용 추가
             else:
-                if current_part == 'title' and not title_lines:
-                    title_lines.append(line)
+                if current_part == 'title' and not slide['title']:
+                    slide['title'] = line
                 elif current_part == 'content':
                     content_lines.append(line)
                 elif current_part == 'notes':
                     notes_lines.append(line)
-                elif not current_part and not title_lines:
+                elif not title_found and not slide['title']:
                     # 첫 번째 줄을 제목으로
-                    title_lines.append(line)
-                    current_part = 'content'  # 이후 줄들은 content로
-                elif not current_part:
+                    slide['title'] = line
+                    title_found = True
+                    current_part = 'content'
+                elif current_part is None and title_found:
+                    current_part = 'content'
                     content_lines.append(line)
         
         # 슬라이드 데이터 설정
-        slide['title'] = ' '.join(title_lines).strip()
         slide['content'] = '\n'.join(content_lines).strip()
         slide['notes'] = ' '.join(notes_lines).strip()
         
-        # 제목 정리
-        slide['title'] = re.sub(r'^(슬라이드|Slide)\s*\d+\s*[:：\-]?\s*', '', slide['title'], flags=re.IGNORECASE)
-        slide['title'] = re.sub(r'^(제목|Title)\s*[:：]\s*', '', slide['title'], flags=re.IGNORECASE)
-        
         # 내용이 있는 경우에만 추가
         if slide['title'] or slide['content']:
             logger.info(f"Slide {len(slides)+1}: Title='{slide['title'][:30]}...', Content length={len(slide['content'])}")
             slides.append(slide)
     
-    # 만약 위 방법으로 파싱이 안 되었다면, 더 간단한 방법 시도
-    if not slides:
-        logger.warning("Primary parsing failed, trying fallback method...")
+    # 만약 위 방법으로 파싱이 안 되었다면, 더 유연한 방법 시도
+    if not slides or len(slides) < 3:
+        logger.warning(f"Primary parsing resulted in only {len(slides)} slides, trying alternative method...")
+        slides = []
+        
+        # "제목:" 패턴으로 슬라이드 구분 시도
+        sections = re.split(r'\n(?=제목:|Title:)', response)
         
-        # 더블 뉴라인으로 구분
-        sections = response.split('\n\n')
         for section in sections:
-            lines = section.strip().split('\n')
-            if len(lines) >= 2:  # 최소 제목과 내용이 있어야 함
-                slide = {
-                    'title': lines[0].strip(),
-                    'content': '\n'.join(lines[1:]).strip(),
-                    'notes': '',
-                    'layout': 'title_content',
-                    'chart_data': None
-                }
+            if not section.strip():
+                continue
                 
-                # 제목 정리
-                slide['title'] = re.sub(r'^(슬라이드|Slide)\s*\d+\s*[:：\-]?\s*', '', slide['title'], flags=re.IGNORECASE)
+            slide = {
+                'title': '',
+                'content': '',
+                'notes': '',
+                'layout': 'title_content',
+                'chart_data': None
+            }
+            
+            lines = section.strip().split('\n')
+            current_part = None
+            content_lines = []
+            notes_lines = []
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
                 
-                if slide['title'] and slide['content']:
-                    slides.append(slide)
+                if line.startswith('제목:') or line.startswith('Title:'):
+                    slide['title'] = line.split(':', 1)[1].strip() if ':' in line else ''
+                    current_part = 'content'
+                elif line.startswith('내용:') or line.startswith('Content:'):
+                    current_part = 'content'
+                elif line.startswith('노트:') or line.startswith('Notes:'):
+                    current_part = 'notes'
+                    notes_text = line.split(':', 1)[1].strip() if ':' in line else ''
+                    if notes_text:
+                        notes_lines.append(notes_text)
+                elif current_part == 'content':
+                    content_lines.append(line)
+                elif current_part == 'notes':
+                    notes_lines.append(line)
+            
+            slide['content'] = '\n'.join(content_lines).strip()
+            slide['notes'] = ' '.join(notes_lines).strip()
+            
+            # 슬라이드 번호 제거
+            slide['title'] = re.sub(r'^(슬라이드|Slide)\s*\d+\s*[:：\-]?\s*', '', slide['title'], flags=re.IGNORECASE)
+            
+            if slide['title'] or slide['content']:
+                slides.append(slide)
     
     logger.info(f"Total slides parsed: {len(slides)}")
+    
+    # 파싱 결과 검증
+    if len(slides) < 3:
+        logger.error("Parsing resulted in too few slides. Raw response preview:")
+        logger.error(response[:1000])
+    
     return slides
 
 def force_font_size(text_frame, font_size_pt: int, theme: Dict):
@@ -1380,14 +1543,14 @@ def create_advanced_ppt_from_content(
     # 배경 그라디언트
     add_gradient_background(slide, theme['colors']['primary'], theme['colors']['secondary'])
 
-    # 제목과 부제목을 먼저 중앙 상단에 배치
+    # 제목과 부제목을 중앙 상단에 배치
     title_shape = slide.shapes.title
     subtitle_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else None
 
     if title_shape:
         title_shape.left = Inches(0.5)
         title_shape.width = prs.slide_width - Inches(1)
-        title_shape.top = Inches(0.8)  # 상단에 배치
+        title_shape.top = Inches(1.0)  # 상단에 배치
         title_shape.height = Inches(1.2)
 
         tf = title_shape.text_frame
@@ -1403,7 +1566,7 @@ def create_advanced_ppt_from_content(
     if subtitle_shape:
         subtitle_shape.left = Inches(0.5)
         subtitle_shape.width = prs.slide_width - Inches(1)
-        subtitle_shape.top = Inches(2.0)  # 제목 아래에 배치
+        subtitle_shape.top = Inches(2.2)  # 제목 아래에 배치
         subtitle_shape.height = Inches(0.9)
 
         tf2 = subtitle_shape.text_frame
@@ -1415,18 +1578,27 @@ def create_advanced_ppt_from_content(
         p2.font.color.rgb = RGBColor(255, 255, 255)
         p2.alignment = PP_ALIGN.CENTER
 
-    # AI 이미지를 우측에 배치
-    if include_ai_image and FLUX_API_ENABLED:
-        logger.info("Generating AI cover image via FLUX API...")
-        ai_image_path = generate_ai_cover_image_via_flux(topic, slides_data)
+    # AI 이미지를 우측 하단에 배치 (두 API 병렬 사용)
+    if include_ai_image and (AI_IMAGE_ENABLED or FLUX_API_ENABLED):
+        logger.info("Generating AI cover images via parallel APIs...")
+        
+        # 두 가지 프롬프트 생성
+        prompt_3d, prompt_photo = generate_cover_image_prompts(topic, slides_data)
+        
+        # 병렬로 이미지 생성
+        image_3d, image_photo = generate_images_parallel(prompt_3d, prompt_photo)
+        
+        # 성공한 이미지 중 하나 선택 (3D 우선)
+        ai_image_path = image_3d or image_photo
+        
         if ai_image_path and os.path.exists(ai_image_path):
             try:
                 img = Image.open(ai_image_path)
                 img_width, img_height = img.size
                 
-                # 이미지를 우측에 배치
-                max_width = Inches(4)
-                max_height = Inches(3.5)
+                # 이미지를 우측 하단에 배치
+                max_width = Inches(3.5)
+                max_height = Inches(2.5)
                 
                 ratio = img_height / img_width
                 img_w = max_width
@@ -1436,9 +1608,9 @@ def create_advanced_ppt_from_content(
                     img_h = max_height
                     img_w = max_height / ratio
                 
-                # 우측 배치
+                # 우측 하단 배치
                 left = prs.slide_width - img_w - Inches(0.5)
-                top = (prs.slide_height - img_h) / 2
+                top = prs.slide_height - img_h - Inches(0.8)
                 
                 pic = slide.shapes.add_picture(ai_image_path, left, top, width=img_w, height=img_h)
                 pic.shadow.inherit = False
@@ -1447,9 +1619,9 @@ def create_advanced_ppt_from_content(
                 pic.shadow.distance = Pt(8)
                 pic.shadow.angle = 45
                 
-                # 이미지 아래에 작은 캡션 추가
+                # 이미지 위에 작은 캡션 추가
                 caption_box = slide.shapes.add_textbox(
-                    left, top + img_h + Inches(0.1), 
+                    left, top - Inches(0.3), 
                     img_w, Inches(0.3)
                 )
                 caption_tf = caption_box.text_frame
@@ -1459,10 +1631,14 @@ def create_advanced_ppt_from_content(
                 caption_p.font.color.rgb = RGBColor(255, 255, 255)
                 caption_p.alignment = PP_ALIGN.CENTER
                 
-                try:
-                    os.unlink(ai_image_path)
-                except Exception as e:
-                    logger.warning(f"Temp image delete failed: {e}")
+                # 임시 파일 정리
+                for temp_path in [image_3d, image_photo]:
+                    if temp_path and os.path.exists(temp_path):
+                        try:
+                            os.unlink(temp_path)
+                        except:
+                            pass
+                            
             except Exception as e:
                 logger.error(f"Failed to add cover image: {e}")
 
@@ -1525,18 +1701,18 @@ def create_advanced_ppt_from_content(
         should_add_visual = False
         visual_type = None
         
-        # 결론 슬라이드는 항상 FLUX 이미지 추가
-        if is_conclusion_slide and include_flux_images and FLUX_API_ENABLED:
+        # 결론 슬라이드는 항상 이미지 추가
+        if is_conclusion_slide and include_flux_images:
             should_add_visual = True
-            visual_type = ('flux_conclusion', None)
+            visual_type = ('conclusion_images', None)
         elif include_diagrams:
             diagram_type = detect_diagram_type(slide_title, slide_content)
             if diagram_type:
                 should_add_visual = True
                 visual_type = ('diagram', diagram_type)
-        elif not should_add_visual and include_flux_images and i % 3 == 0:  # 매 3번째 슬라이드에 FLUX 이미지
+        elif not should_add_visual and include_flux_images and i % 2 == 0:  # 매 2번째 슬라이드에 이미지
             should_add_visual = True
-            visual_type = ('flux', None)
+            visual_type = ('diverse_images', None)
         
         # 시각적 요소가 있는 경우 좌-우 레이아웃 적용
         if should_add_visual and layout_type not in ['section_header']:
@@ -1584,17 +1760,19 @@ def create_advanced_ppt_from_content(
                         except Exception as e:
                             logger.error(f"Failed to add diagram: {e}")
             
-            elif visual_type[0] == 'flux_conclusion':
-                # 결론 슬라이드용 FLUX 이미지 생성
-                logger.info(f"Generating conclusion FLUX image for slide {i+1}")
-                conclusion_prompt = generate_conclusion_image_prompt(slide_title, slide_content)
-                flux_image_path = generate_flux_image_via_api(conclusion_prompt)
+            elif visual_type[0] == 'conclusion_images':
+                # 결론 슬라이드용 이미지 생성 (두 API 병렬)
+                logger.info(f"Generating conclusion images for slide {i+1}")
+                prompt_3d, prompt_photo = generate_conclusion_image_prompts(slide_title, slide_content)
+                image_3d, image_photo = generate_images_parallel(prompt_3d, prompt_photo)
+                
+                # 성공한 이미지 중 하나 선택
+                selected_image = image_photo or image_3d  # 결론은 포토리얼리스틱 우선
                 
-                if flux_image_path and os.path.exists(flux_image_path):
+                if selected_image and os.path.exists(selected_image):
                     try:
-                        # FLUX 이미지 추가
                         pic = slide.shapes.add_picture(
-                            flux_image_path,
+                            selected_image,
                             Inches(5.2), Inches(1.5),
                             width=Inches(4.3), height=Inches(3.0)
                         )
@@ -1611,31 +1789,45 @@ def create_advanced_ppt_from_content(
                         caption_p.font.color.rgb = theme['colors']['secondary']
                         caption_p.alignment = PP_ALIGN.CENTER
                         
-                        # 임시 파일 삭제
-                        os.unlink(flux_image_path)
+                        # 임시 파일 정리
+                        for temp_path in [image_3d, image_photo]:
+                            if temp_path and os.path.exists(temp_path):
+                                try:
+                                    os.unlink(temp_path)
+                                except:
+                                    pass
                     except Exception as e:
-                        logger.error(f"Failed to add conclusion FLUX image: {e}")
+                        logger.error(f"Failed to add conclusion image: {e}")
             
-            elif visual_type[0] == 'flux':
-                # FLUX 이미지 생성
-                logger.info(f"Generating FLUX image for slide {i+1}")
-                flux_prompt = generate_flux_prompt(slide_title, slide_content)
-                flux_image_path = generate_flux_image_via_api(flux_prompt)
+            elif visual_type[0] == 'diverse_images':
+                # 다양한 슬라이드 이미지 생성 (두 API 병렬)
+                logger.info(f"Generating diverse images for slide {i+1}")
+                prompt_3d, prompt_photo = generate_diverse_prompt(slide_title, slide_content, i)
+                image_3d, image_photo = generate_images_parallel(prompt_3d, prompt_photo)
+                
+                # 슬라이드 인덱스에 따라 번갈아 선택
+                selected_image = image_3d if i % 2 == 0 else image_photo
+                if not selected_image:  # 실패시 다른 것 선택
+                    selected_image = image_photo if i % 2 == 0 else image_3d
                 
-                if flux_image_path and os.path.exists(flux_image_path):
+                if selected_image and os.path.exists(selected_image):
                     try:
-                        # FLUX 이미지 추가
                         pic = slide.shapes.add_picture(
-                            flux_image_path,
+                            selected_image,
                             Inches(5.2), Inches(1.5),
                             width=Inches(4.3), height=Inches(3.0)
                         )
                         visual_added = True
                         
-                        # 임시 파일 삭제
-                        os.unlink(flux_image_path)
+                        # 임시 파일 정리
+                        for temp_path in [image_3d, image_photo]:
+                            if temp_path and os.path.exists(temp_path):
+                                try:
+                                    os.unlink(temp_path)
+                                except:
+                                    pass
                     except Exception as e:
-                        logger.error(f"Failed to add FLUX image: {e}")
+                        logger.error(f"Failed to add slide image: {e}")
             
             # 시각적 요소가 추가되지 않은 경우 플레이스홀더 추가
             if not visual_added:
@@ -2052,14 +2244,25 @@ def generate_ppt(
         return None, "❌ 슬라이드 수는 3장 이상 20장 이하로 설정해주세요.", ""
     
     try:
-        # FLUX API 초기화 (표지 이미지용)
-        if include_ai_image and not FLUX_API_ENABLED:
-            yield None, "🔄 FLUX 이미지 생성 API에 연결하는 중...", ""
+        # 3D 스타일 API 초기화 (표지 이미지용)
+        if include_ai_image and not AI_IMAGE_ENABLED:
+            yield None, "🔄 3D 스타일 이미지 생성 API에 연결하는 중...", ""
+            if initialize_ai_image_api():
+                yield None, "✅ 3D 스타일 API 연결 성공!", ""
+            else:
+                include_ai_image = False
+                yield None, "⚠️ 3D 스타일 API 연결 실패. AI 이미지 없이 진행합니다.", ""
+        
+        # FLUX API 초기화 (포토리얼리스틱 이미지용)
+        if (include_ai_image or include_flux_images) and not FLUX_API_ENABLED:
+            yield None, "🔄 FLUX 포토리얼리스틱 API에 연결하는 중...", ""
             if initialize_flux_api():
                 yield None, "✅ FLUX API 연결 성공!", ""
             else:
-                include_ai_image = False
-                yield None, "⚠️ FLUX API 연결 실패. AI 이미지 없이 진행합니다.", ""
+                if include_ai_image and not AI_IMAGE_ENABLED:
+                    include_ai_image = False
+                include_flux_images = False
+                yield None, "⚠️ FLUX API 연결 실패. 포토리얼리스틱 이미지 없이 진행합니다.", ""
         
         # 다이어그램 API 초기화
         if include_diagrams and not DIAGRAM_API_ENABLED:
@@ -2070,15 +2273,6 @@ def generate_ppt(
                 include_diagrams = False
                 yield None, "⚠️ 다이어그램 API 연결 실패. 다이어그램 없이 진행합니다.", ""
         
-        # FLUX API 초기화 (슬라이드 이미지용)
-        if include_flux_images and not FLUX_API_ENABLED:
-            yield None, "🔄 FLUX 이미지 생성 API에 연결하는 중...", ""
-            if initialize_flux_api():
-                yield None, "✅ FLUX API 연결 성공!", ""
-            else:
-                include_flux_images = False
-                yield None, "⚠️ FLUX API 연결 실패. 슬라이드 이미지 없이 진행합니다.", ""
-        
         # Process reference files if provided
         additional_context = ""
         chart_data = None
@@ -2540,16 +2734,17 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
         6. **생성 버튼 클릭**: AI가 자동으로 PPT 생성
         
         ### 🎨 새로운 기능
-        - **FLUX AI 표지 이미지**: FLUX API를 통한 고품질 표지 이미지 (우측 배치)
-        - **AI 다이어그램**: 내용 분석 후 적절한 다이어그램 자동 생성
-        - **FLUX 슬라이드 이미지**: 주요 슬라이드에 AI 생성 이미지 추가
-        - **결론 슬라이드 강조**: 결론/요약 슬라이드에 특별한 FLUX 이미지 추가
+        - **병렬 AI 이미지 생성**: 3D 스타일과 포토리얼리스틱 API를 동시에 사용하여 생성 시간 단축
+        - **다양한 이미지 스타일**: 각 슬라이드마다 다른 스타일과 메타포로 이미지 생성
+        - **AI 표지 이미지**: 우측 하단 배치로 텍스트와 겹치지 않음
+        - **결론 슬라이드 강조**: 결론/요약 슬라이드에 특별한 이미지 추가
         - **좌-우 레이아웃**: 텍스트는 좌측, 시각적 요소는 우측 배치
         
         ### 💡 고급 팁
-        - 표지의 제목/부제는 중앙 상단, AI 이미지는 우측에 배치됩니다
+        - 표지 이미지는 우측 하단에 배치되어 제목/부제와 겹치지 않습니다
+        - 3D 스타일과 포토리얼리스틱 이미지가 병렬로 생성되어 시간이 절약됩니다
+        - 각 슬라이드는 내용에 맞는 고유한 시각 메타포와 스타일로 이미지가 생성됩니다
         - 결론/요약 슬라이드는 자동으로 감지되어 특별한 이미지가 추가됩니다
-        - FLUX 이미지는 슬라이드 내용을 분석하여 관련 이미지를 생성합니다
         """
     )
     
@@ -2588,10 +2783,21 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
 
 # Initialize APIs on startup
 if __name__ == "__main__":
-    # Try to initialize APIs
-    if FLUX_API_URL:
-        initialize_flux_api()
-    if DIAGRAM_API_URL:
-        initialize_diagram_api()
+    # Try to initialize APIs in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        futures = []
+        if AI_IMAGE_API_URL:
+            futures.append(executor.submit(initialize_ai_image_api))
+        if FLUX_API_URL:
+            futures.append(executor.submit(initialize_flux_api))
+        if DIAGRAM_API_URL:
+            futures.append(executor.submit(initialize_diagram_api))
+        
+        # Wait for all to complete
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                future.result()
+            except Exception as e:
+                logger.error(f"API initialization failed: {e}")
     
     demo.launch()