Update app-BACKUP.py

app-BACKUP.py

@@ -47,6 +47,11 @@ except ImportError as e:
     DIAGRAM_GENERATORS_AVAILABLE = False
     logger.warning(f"다이어그램 생성기 모듈을 찾을 수 없습니다: {e}")
 
+# 한글 폰트 경로 설정
+KOREAN_FONT_PATH = os.path.join(os.path.dirname(__file__), "NanumGothic-Regular.ttf")
+if not os.path.exists(KOREAN_FONT_PATH):
+    logger.warning(f"한글 폰트 파일을 찾을 수 없습니다: {KOREAN_FONT_PATH}")
+
 ##############################################################################
 # API Configuration
 ##############################################################################
@@ -106,11 +111,6 @@ def initialize_flux_api():
         FLUX_API_ENABLED = False
         return False
 
-##############################################################################
-# Diagram Generation API Configuration - REMOVED (using local generators)
-##############################################################################
-# 기존 Diagram API 관련 코드 제거하고 로컬 생성기 사용
-
 ##############################################################################
 # Design Themes and Color Schemes
 ##############################################################################
@@ -350,41 +350,70 @@ def get_emoji_for_content(text: str) -> str:
         return '▶️'
 
 ##############################################################################
-# Diagram Type Detection - UPDATED for 6 types
+# Diagram Type Detection with Priority Score
 ##############################################################################
-def detect_diagram_type(title: str, content: str) -> Optional[str]:
-    """슬라이드 내용을 분석하여 적절한 다이어그램 타입 결정"""
+def detect_diagram_type_with_score(title: str, content: str) -> Tuple[Optional[str], float]:
+    """슬라이드 내용을 분석하여 적절한 다이어그램 타입과 필요도 점수 결정"""
     combined_text = f"{title} {content}".lower()
     
-    # Process Flow keywords
-    if any(word in combined_text for word in ['프로세스', 'process', '절차', 'procedure', '단계', 'step', 'flow', '흐름', '워크플로우', 'workflow', '순서', 'sequence']):
-        return "Process Flow"
-    
-    # WBS keywords
-    elif any(word in combined_text for word in ['wbs', '작업분해', '프로젝트', 'project', '업무분해', 'breakdown', '구조도', '작업구조', 'work structure']):
-        return "WBS Diagram"
-    
-    # Concept Map keywords
-    elif any(word in combined_text for word in ['개념', 'concept', '관계', 'relationship', '연관', 'connection', '마인드맵', 'mindmap', '구조', 'structure', '체계', 'system']):
-        return "Concept Map"
-    
-    # Radial Diagram keywords
-    elif any(word in combined_text for word in ['중심', 'central', '방사형', 'radial', '핵심', 'core', '주요', 'main', '중앙', 'center']):
-        return "Radial Diagram"
-    
-    # Synoptic Chart keywords
-    elif any(word in combined_text for word in ['개요', 'overview', '전체', 'overall', '요약', 'summary', '시놉틱', 'synoptic', '총괄', 'comprehensive']):
-        return "Synoptic Chart"
+    # 각 다이어그램 타입별 키워드와 가중치
+    diagram_scores = {
+        "Process Flow": 0,
+        "WBS Diagram": 0,
+        "Concept Map": 0,
+        "Radial Diagram": 0,
+        "Synoptic Chart": 0
+    }
     
-    # Default: 키워드가 없으면 내용의 특성에 따라 결정
-    # 리스트나 항목이 많으면 Concept Map
+    # Process Flow keywords with weights
+    if any(word in combined_text for word in ['프로세스', 'process', '절차', 'procedure']):
+        diagram_scores["Process Flow"] += 3
+    if any(word in combined_text for word in ['단계', 'step', 'flow', '흐름']):
+        diagram_scores["Process Flow"] += 2
+    if any(word in combined_text for word in ['워크플로우', 'workflow', '순서', 'sequence']):
+        diagram_scores["Process Flow"] += 2
+    
+    # WBS keywords with weights
+    if any(word in combined_text for word in ['wbs', '작업분해', '프로젝트', 'project']):
+        diagram_scores["WBS Diagram"] += 3
+    if any(word in combined_text for word in ['업무분해', 'breakdown', '구조도', '작업구조']):
+        diagram_scores["WBS Diagram"] += 2
+    
+    # Concept Map keywords with weights
+    if any(word in combined_text for word in ['개념', 'concept', '관계', 'relationship']):
+        diagram_scores["Concept Map"] += 3
+    if any(word in combined_text for word in ['연관', 'connection', '마인드맵', 'mindmap']):
+        diagram_scores["Concept Map"] += 2
+    if any(word in combined_text for word in ['구조', 'structure', '체계', 'system']):
+        diagram_scores["Concept Map"] += 1
+    
+    # Radial Diagram keywords with weights
+    if any(word in combined_text for word in ['중심', 'central', '방사형', 'radial']):
+        diagram_scores["Radial Diagram"] += 3
+    if any(word in combined_text for word in ['핵심', 'core', '주요', 'main']):
+        diagram_scores["Radial Diagram"] += 2
+    
+    # Synoptic Chart keywords with weights
+    if any(word in combined_text for word in ['개요', 'overview', '전체', 'overall']):
+        diagram_scores["Synoptic Chart"] += 3
+    if any(word in combined_text for word in ['요약', 'summary', '시놉틱', 'synoptic']):
+        diagram_scores["Synoptic Chart"] += 2
+    
+    # 추가 점수 부여: 리스트나 구조화된 내용이 많은 경우
     if content.count('\n-') > 3 or content.count('\n•') > 3:
-        return "Concept Map"
-    # 숫자가 있으면 Process Flow
-    elif any(char in content for char in ['1.', '2.', '3.', '①', '②', '③']):
-        return "Process Flow"
+        diagram_scores["Concept Map"] += 1
+    if any(char in content for char in ['1.', '2.', '3.', '①', '②', '③']):
+        diagram_scores["Process Flow"] += 1
     
-    return None
+    # 가장 높은 점수의 다이어그램 타입 선택
+    max_score = max(diagram_scores.values())
+    if max_score > 0:
+        best_type = max(diagram_scores.items(), key=lambda x: x[1])[0]
+        # 필요도 점수 계산 (0-1 범위)
+        necessity_score = min(max_score / 5.0, 1.0)  # 최대 5점을 1.0으로 정규화
+        return best_type, necessity_score
+    
+    return None, 0.0
 
 ##############################################################################
 # Generate Diagram JSON using LLM
@@ -394,7 +423,7 @@ def generate_diagram_json(title: str, content: str, diagram_type: str) -> Option
     if not FRIENDLI_TOKEN:
         return None
     
-    # 다이어그램 타입별 JSON 구조 가이드 - paste-2.txt의 구조와 동일하게
+    # 다이어그램 타입별 JSON 구조 가이드
     json_guides = {
         "Concept Map": """Generate a JSON for a concept map with the EXACT following structure:
 {
@@ -526,15 +555,18 @@ Important rules:
     return None
 
 ##############################################################################
-# Generate Diagram using Local Generators - NEW
+# Generate Diagram using Local Generators with Korean Font
 ##############################################################################
 def generate_diagram_locally(json_data: str, diagram_type: str, output_format: str = "png") -> Optional[str]:
-    """로컬 생성기를 사용하여 다이어그램 생성"""
+    """로컬 생성기를 사용하여 다이어그램 생성 (한글 폰트 적용)"""
     if not DIAGRAM_GENERATORS_AVAILABLE:
         logger.error("다이어그램 생성기 모듈을 사용할 수 없습니다")
         return None
     
     try:
+        # 한글 폰트 경로를 환경변수로 설정
+        os.environ['KOREAN_FONT_PATH'] = KOREAN_FONT_PATH
+        
         # 적절한 생성기를 사용하여 다이어그램 생성
         if diagram_type == "Concept Map":
             result = generate_concept_map(json_data, output_format)
@@ -1067,7 +1099,7 @@ def generate_images_parallel(prompt_3d: str, prompt_photo: str) -> Tuple[Optiona
     return image_3d, image_photo
 
 ##############################################################################
-# PPT Generation Functions - FIXED VERSION
+# PPT Generation Functions - FIXED WITH LIMITED DIAGRAMS AND IMAGES
 ##############################################################################
 def parse_llm_ppt_response(response: str, layout_style: str = "consistent") -> list:
     """Parse LLM response to extract slide content - FIXED VERSION"""
@@ -1495,7 +1527,7 @@ def create_advanced_ppt_from_content(
     include_diagrams: bool = False,
     include_flux_images: bool = False
 ) -> str:
-    """Create advanced PPT file with consistent visual design and AI-generated visuals"""
+    """Create advanced PPT file with limited visuals (max 6 images + 2 diagrams)"""
     if not PPTX_AVAILABLE:
         raise ImportError("python-pptx library is required")
 
@@ -1506,8 +1538,32 @@ def create_advanced_ppt_from_content(
     prs.slide_width = Inches(10)
     prs.slide_height = Inches(5.625)
 
+    # 이미지와 다이어그램 카운터 및 추적
+    image_count_3d = 0
+    image_count_flux = 0
+    diagram_count = 0
+    max_images_per_api = 3
+    max_diagrams = 2
+    
+    # 다이어그램이 필요한 슬라이드를 미리 분석
+    diagram_candidates = []
+    if include_diagrams:
+        for i, slide_data in enumerate(slides_data):
+            title = slide_data.get('title', '')
+            content = slide_data.get('content', '')
+            diagram_type, score = detect_diagram_type_with_score(title, content)
+            if diagram_type and score > 0:
+                diagram_candidates.append((i, diagram_type, score))
+        
+        # 필요도 점수가 높은 순으로 정렬하고 상위 2개만 선택
+        diagram_candidates.sort(key=lambda x: x[2], reverse=True)
+        diagram_candidates = diagram_candidates[:max_diagrams]
+        diagram_slide_indices = [x[0] for x in diagram_candidates]
+    else:
+        diagram_slide_indices = []
+
     # ─────────────────────────────────────────────────────────
-    # 1) 제목 슬라이드(표지) 생성 - 수정된 레이아웃
+    # 1) 제목 슬라이드(표지) 생성
     # ─────────────────────────────────────────────────────────
     title_slide_layout = prs.slide_layouts[0]
     slide = prs.slides.add_slide(title_slide_layout)
@@ -1522,7 +1578,7 @@ def create_advanced_ppt_from_content(
     if title_shape:
         title_shape.left = Inches(0.5)
         title_shape.width = prs.slide_width - Inches(1)
-        title_shape.top = Inches(1.0)  # 상단에 배치
+        title_shape.top = Inches(1.0)
         title_shape.height = Inches(1.2)
 
         tf = title_shape.text_frame
@@ -1538,7 +1594,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.2)  # 제목 아래에 배치
+        subtitle_shape.top = Inches(2.2)
         subtitle_shape.height = Inches(0.9)
 
         tf2 = subtitle_shape.text_frame
@@ -1550,25 +1606,27 @@ def create_advanced_ppt_from_content(
         p2.font.color.rgb = RGBColor(255, 255, 255)
         p2.alignment = PP_ALIGN.CENTER
 
-    # 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
+        # 3D 우선 선택
+        ai_image_path = None
+        if image_3d and image_count_3d < max_images_per_api:
+            ai_image_path = image_3d
+            image_count_3d += 1
+        elif image_photo and image_count_flux < max_images_per_api:
+            ai_image_path = image_photo
+            image_count_flux += 1
         
         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(3.5)
                 max_height = Inches(2.5)
                 
@@ -1580,7 +1638,6 @@ 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 - Inches(0.8)
                 
@@ -1591,7 +1648,6 @@ def create_advanced_ppt_from_content(
                 pic.shadow.distance = Pt(8)
                 pic.shadow.angle = 45
                 
-                # 이미지 위에 작은 캡션 추가
                 caption_box = slide.shapes.add_textbox(
                     left, top - Inches(0.3), 
                     img_w, Inches(0.3)
@@ -1614,14 +1670,14 @@ def create_advanced_ppt_from_content(
             except Exception as e:
                 logger.error(f"Failed to add cover image: {e}")
 
-    # 장식 요소
     add_decorative_shapes(slide, theme)
 
-    # Add content slides with consistent design
+    # ─────────────────────────────────────────────────────────
+    # 2) 컨텐츠 슬라이드 생성
+    # ─────────────────────────────────────────────────────────
     for i, slide_data in enumerate(slides_data):
         layout_type = slide_data.get('layout', 'title_content')
         
-        # Log slide creation
         logger.info(f"Creating slide {i+1}: {slide_data.get('title', 'No title')}")
         logger.debug(f"Content length: {len(slide_data.get('content', ''))}")
         
@@ -1643,24 +1699,23 @@ def create_advanced_ppt_from_content(
         # Set title
         if slide.shapes.title:
             slide.shapes.title.text = slide_data.get('title', '제목 없음')
-            # IMMEDIATELY set title font size after setting text
             try:
                 title_text_frame = slide.shapes.title.text_frame
                 if title_text_frame and title_text_frame.paragraphs:
                     for paragraph in title_text_frame.paragraphs:
                         if layout_type == 'section_header':
-                            paragraph.font.size = Pt(28)  # Increased from 20
+                            paragraph.font.size = Pt(28)
                             paragraph.font.color.rgb = RGBColor(255, 255, 255)
                             paragraph.alignment = PP_ALIGN.CENTER
                         else:
-                            paragraph.font.size = Pt(24)  # Increased from 18
+                            paragraph.font.size = Pt(24)
                             paragraph.font.color.rgb = theme['colors']['primary']
                         paragraph.font.bold = True
                         paragraph.font.name = theme['fonts']['title']
             except Exception as e:
                 logger.warning(f"Title font sizing failed: {e}")
         
-        # Detect if this slide should have a diagram or image
+        # 슬라이드 정보
         slide_title = slide_data.get('title', '')
         slide_content = slide_data.get('content', '')
         
@@ -1669,20 +1724,22 @@ def create_advanced_ppt_from_content(
                                  ['결론', 'conclusion', '요약', 'summary', '핵심', 'key', 
                                   '마무리', 'closing', '정리', 'takeaway', '시사점', 'implication'])
         
-        # 다이어그램 또는 이미지 생성 여부 결정
+        # 시각적 요소 추가 여부 결정
         should_add_visual = False
         visual_type = None
         
-        # 결론 슬라이드는 항상 이미지 추가
-        if is_conclusion_slide and include_flux_images:
+        # 1. 다이어그램 우선 확인
+        if i in diagram_slide_indices and diagram_count < max_diagrams:
+            should_add_visual = True
+            diagram_info = next(x for x in diagram_candidates if x[0] == i)
+            visual_type = ('diagram', diagram_info[1])
+            diagram_count += 1
+        # 2. 결론 슬라이드는 이미지 추가 (이미지 제한 내에서)
+        elif is_conclusion_slide and include_flux_images and (image_count_3d + image_count_flux) < (max_images_per_api * 2):
             should_add_visual = True
             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 % 2 == 0:  # 매 2번째 슬라이드에 이미지
+        # 3. 일반 슬라이드 이미지 (이미지 제한 내에서, 3~4장마다 하나씩)
+        elif include_flux_images and (image_count_3d + image_count_flux) < (max_images_per_api * 2) and i % 3 == 0:
             should_add_visual = True
             visual_type = ('diverse_images', None)
         
@@ -1712,14 +1769,13 @@ def create_advanced_ppt_from_content(
             
             if visual_type[0] == 'diagram' and DIAGRAM_GENERATORS_AVAILABLE:
                 # 다이어그램 생성
-                logger.info(f"Generating {visual_type[1]} for slide {i+1}")
+                logger.info(f"Generating {visual_type[1]} for slide {i+1} (Diagram {diagram_count}/{max_diagrams})")
                 diagram_json = generate_diagram_json(slide_title, slide_content, visual_type[1])
                 
                 if diagram_json:
                     diagram_path = generate_diagram_locally(diagram_json, visual_type[1], "png")
                     if diagram_path and os.path.exists(diagram_path):
                         try:
-                            # 다이어그램 이미지 추가
                             pic = slide.shapes.add_picture(
                                 diagram_path,
                                 Inches(5.2), Inches(1.5),
@@ -1727,7 +1783,6 @@ def create_advanced_ppt_from_content(
                             )
                             visual_added = True
                             
-                            # 다이어그램 캡션 추가
                             caption_box = slide.shapes.add_textbox(
                                 Inches(5.2), Inches(4.6), Inches(4.3), Inches(0.3)
                             )
@@ -1738,7 +1793,6 @@ def create_advanced_ppt_from_content(
                             caption_p.font.color.rgb = theme['colors']['secondary']
                             caption_p.alignment = PP_ALIGN.CENTER
                             
-                            # 임시 파일 삭제
                             try:
                                 os.unlink(diagram_path)
                             except:
@@ -1747,13 +1801,26 @@ def create_advanced_ppt_from_content(
                             logger.error(f"Failed to add diagram: {e}")
             
             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  # 결론은 포토리얼리스틱 우선
+                image_3d = None
+                image_photo = None
+                
+                if image_count_3d < max_images_per_api:
+                    image_3d = generate_ai_image_via_3d_api(prompt_3d)
+                if image_count_flux < max_images_per_api:
+                    image_photo = generate_flux_image_via_api(prompt_photo)
+                
+                # 선택
+                selected_image = None
+                if image_photo and image_count_flux < max_images_per_api:
+                    selected_image = image_photo
+                    image_count_flux += 1
+                elif image_3d and image_count_3d < max_images_per_api:
+                    selected_image = image_3d
+                    image_count_3d += 1
                 
                 if selected_image and os.path.exists(selected_image):
                     try:
@@ -1764,7 +1831,6 @@ def create_advanced_ppt_from_content(
                         )
                         visual_added = True
                         
-                        # 이미지 캡션 추가
                         caption_box = slide.shapes.add_textbox(
                             Inches(5.2), Inches(4.6), Inches(4.3), Inches(0.3)
                         )
@@ -1775,7 +1841,6 @@ def create_advanced_ppt_from_content(
                         caption_p.font.color.rgb = theme['colors']['secondary']
                         caption_p.alignment = PP_ALIGN.CENTER
                         
-                        # 임시 파일 정리
                         for temp_path in [image_3d, image_photo]:
                             if temp_path and os.path.exists(temp_path):
                                 try:
@@ -1786,15 +1851,23 @@ def create_advanced_ppt_from_content(
                         logger.error(f"Failed to add conclusion image: {e}")
             
             elif visual_type[0] == 'diverse_images':
-                # 다양한 슬라이드 이미지 생성 (두 API 병렬)
-                logger.info(f"Generating diverse images for slide {i+1}")
+                # 다양한 슬라이드 이미지 생성 (API별 제한 확인)
+                logger.info(f"Generating diverse images for slide {i+1} (3D: {image_count_3d}/{max_images_per_api}, FLUX: {image_count_flux}/{max_images_per_api})")
                 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
+                selected_image = None
+                
+                # API별 제한에 따라 이미지 생성
+                if i % 2 == 0 and image_count_3d < max_images_per_api:
+                    image_3d = generate_ai_image_via_3d_api(prompt_3d)
+                    if image_3d:
+                        selected_image = image_3d
+                        image_count_3d += 1
+                elif image_count_flux < max_images_per_api:
+                    image_photo = generate_flux_image_via_api(prompt_photo)
+                    if image_photo:
+                        selected_image = image_photo
+                        image_count_flux += 1
                 
                 if selected_image and os.path.exists(selected_image):
                     try:
@@ -1805,13 +1878,8 @@ def create_advanced_ppt_from_content(
                         )
                         visual_added = True
                         
-                        # 임시 파일 정리
-                        for temp_path in [image_3d, image_photo]:
-                            if temp_path and os.path.exists(temp_path):
-                                try:
-                                    os.unlink(temp_path)
-                                except:
-                                    pass
+                        if selected_image:
+                            os.unlink(selected_image)
                     except Exception as e:
                         logger.error(f"Failed to add slide image: {e}")
             
@@ -1829,7 +1897,6 @@ def create_advanced_ppt_from_content(
         else:
             # 기본 레이아웃 (시각적 요소 없음)
             if layout_type == 'section_header':
-                # Section header content handling
                 content = slide_data.get('content', '')
                 if content:
                     logger.info(f"Adding content to section header slide {i+1}: {content[:50]}...")
@@ -1847,7 +1914,6 @@ def create_advanced_ppt_from_content(
                         paragraph.font.color.rgb = RGBColor(255, 255, 255)
                         paragraph.alignment = PP_ALIGN.CENTER
                 
-                # Add decorative line
                 line = slide.shapes.add_shape(
                     MSO_SHAPE.RECTANGLE, Inches(3), Inches(3.2), Inches(4), Pt(4)
                 )
@@ -1874,7 +1940,6 @@ def create_advanced_ppt_from_content(
                         left_tf.word_wrap = True
                         force_font_size(left_tf, 14, theme)
                         
-                        # Apply emoji bullets
                         for paragraph in left_tf.paragraphs:
                             text = paragraph.text.strip()
                             if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
@@ -1895,7 +1960,6 @@ def create_advanced_ppt_from_content(
                         right_tf.word_wrap = True
                         force_font_size(right_tf, 14, theme)
                         
-                        # Apply emoji bullets
                         for paragraph in right_tf.paragraphs:
                             text = paragraph.text.strip()
                             if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
@@ -1915,10 +1979,7 @@ def create_advanced_ppt_from_content(
                 
                 if content and content.strip():
                     textbox = slide.shapes.add_textbox(
-                        Inches(0.5),   # left
-                        Inches(1.5),   # top  
-                        Inches(9),     # width
-                        Inches(3.5)    # height
+                        Inches(0.5), Inches(1.5), Inches(9), Inches(3.5)
                     )
                     
                     tf = textbox.text_frame
@@ -1969,7 +2030,7 @@ def create_advanced_ppt_from_content(
             except Exception as e:
                 logger.warning(f"Failed to add slide notes: {e}")
         
-        # Add slide number with better design
+        # Add slide number
         slide_number_bg = slide.shapes.add_shape(
             MSO_SHAPE.ROUNDED_RECTANGLE,
             Inches(8.3), Inches(5.0), Inches(1.5), Inches(0.5)
@@ -1984,12 +2045,11 @@ def create_advanced_ppt_from_content(
         )
         slide_number_frame = slide_number_box.text_frame
         slide_number_frame.text = f"{i + 1} / {len(slides_data)}"
-        slide_number_frame.paragraphs[0].font.size = Pt(10)  # Increased from 8
+        slide_number_frame.paragraphs[0].font.size = Pt(10)
         slide_number_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
         slide_number_frame.paragraphs[0].font.bold = False
         slide_number_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
         
-        # Add subtle design element on alternating slides
         if i % 2 == 0:
             accent_shape = slide.shapes.add_shape(
                 MSO_SHAPE.OVAL,
@@ -2000,31 +2060,32 @@ def create_advanced_ppt_from_content(
             accent_shape.fill.fore_color.rgb = theme['colors']['accent']
             accent_shape.line.fill.background()
     
-    # Add thank you slide with consistent design
+    # 이미지 생성 로그
+    logger.info(f"Total images generated - 3D: {image_count_3d}, FLUX: {image_count_flux}, Diagrams: {diagram_count}")
+    
+    # Add thank you slide
     thank_you_layout = prs.slide_layouts[5] if len(prs.slide_layouts) > 5 else prs.slide_layouts[0]
     thank_you_slide = prs.slides.add_slide(thank_you_layout)
     
-    # Apply gradient background
     add_gradient_background(thank_you_slide, theme['colors']['secondary'], theme['colors']['primary'])
     
     if thank_you_slide.shapes.title:
         thank_you_slide.shapes.title.text = "감사합니다"
         try:
             if thank_you_slide.shapes.title.text_frame and thank_you_slide.shapes.title.text_frame.paragraphs:
-                thank_you_slide.shapes.title.text_frame.paragraphs[0].font.size = Pt(36)  # Increased from 28
+                thank_you_slide.shapes.title.text_frame.paragraphs[0].font.size = Pt(36)
                 thank_you_slide.shapes.title.text_frame.paragraphs[0].font.bold = True
                 thank_you_slide.shapes.title.text_frame.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
                 thank_you_slide.shapes.title.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
         except Exception as e:
             logger.warning(f"Thank you slide styling failed: {e}")
     
-    # Add contact or additional info placeholder
     info_box = thank_you_slide.shapes.add_textbox(
         Inches(2), Inches(3.5), Inches(6), Inches(1)
     )
     info_tf = info_box.text_frame
     info_tf.text = "AI로 생성된 프레젠테이션"
-    info_tf.paragraphs[0].font.size = Pt(18)  # Increased from 14
+    info_tf.paragraphs[0].font.size = Pt(18)
     info_tf.paragraphs[0].font.color.rgb = RGBColor(255, 255, 255)
     info_tf.paragraphs[0].alignment = PP_ALIGN.CENTER
     
@@ -2255,6 +2316,10 @@ def generate_ppt(
             yield None, "⚠️ 다이어그램 생성기 모듈을 찾을 수 없습니다. 다이어그램 없이 진행합니다.", ""
             include_diagrams = False
         
+        # 한글 폰트 확인
+        if include_diagrams and not os.path.exists(KOREAN_FONT_PATH):
+            yield None, f"⚠️ 한글 폰트를 찾을 수 없습니다: {KOREAN_FONT_PATH}\n다이어그램에 한글이 깨질 수 있습니다.", ""
+        
         # Process reference files if provided
         additional_context = ""
         chart_data = None
@@ -2327,12 +2392,12 @@ def generate_ppt(
         
         # AI 이미지 및 다이어그램 생성 알림
         visual_features = []
-        if include_ai_image and FLUX_API_ENABLED:
+        if include_ai_image and (AI_IMAGE_ENABLED or FLUX_API_ENABLED):
             visual_features.append("AI 3D 표지 이미지")
         if include_diagrams and DIAGRAM_GENERATORS_AVAILABLE:
-            visual_features.append("다이어그램")
+            visual_features.append("다이어그램 (최대 2개)")
         if include_flux_images and FLUX_API_ENABLED:
-            visual_features.append("AI 생성 이미지")
+            visual_features.append("AI 생성 이미지 (각 API별 최대 3개)")
         
         if visual_features:
             yield None, f"📝 슬라이드 생성 완료!\n\n🎨 생성 중: {', '.join(visual_features)}... (시간이 소요될 수 있습니다)", llm_response
@@ -2354,12 +2419,12 @@ def generate_ppt(
         success_msg += f"🎨 디자인 테마: {DESIGN_THEMES[design_theme]['name']}\n"
         success_msg += f"📐 레이아웃 스타일: {layout_style}\n"
         
-        if include_ai_image and FLUX_API_ENABLED:
+        if include_ai_image and (AI_IMAGE_ENABLED or FLUX_API_ENABLED):
             success_msg += f"🖼️ AI 생성 표지 이미지 포함\n"
         if include_diagrams and DIAGRAM_GENERATORS_AVAILABLE:
-            success_msg += f"📊 AI 생성 다이어그램 포함\n"
+            success_msg += f"📊 AI 생성 다이어그램 포함 (최대 2개)\n"
         if include_flux_images and FLUX_API_ENABLED:
-            success_msg += f"🎨 AI 생성 슬라이드 이미지 포함\n"
+            success_msg += f"🎨 AI 생성 슬라이드 이미지 포함 (API별 최대 3개)\n"
             
         success_msg += f"📝 생성된 슬라이드:\n"
         
@@ -2677,13 +2742,13 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
                 include_diagrams = gr.Checkbox(
                     label="📊 AI 다이어그램",
                     value=False,
-                    info="6가지 타입의 다이어그램 자동 생성"
+                    info="필요도가 높은 2개 슬라이드에 다이어그램 자동 생성"
                 )
                 
                 include_flux_images = gr.Checkbox(
                     label="🎨 슬라이드 이미지",
                     value=False,
-                    info="일부 슬라이드에 FLUX 이미지 추가"
+                    info="주요 슬라이드에 FLUX 이미지 추가 (API별 최대 3개)"
                 )
             
             reference_files = gr.File(
@@ -2732,19 +2797,17 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
         5. **참고 자료 업로드**: PDF, CSV, TXT 파일 지원
         6. **생성 버튼 클릭**: AI가 자동으로 PPT 생성
         
-        ### 🎨 새로운 기능 - 6가지 다이어그램 타입
-        - **Process Flow**: 프로세스와 워크플로우를 시각화
-        - **Concept Map**: 개념과 관계를 구조화하여 표현
-        - **WBS Diagram**: 프로젝트 작업 분해 구조도
-        - **Radial Diagram**: 중심 개념과 관련 요소들의 방사형 표현
-        - **Synoptic Chart**: 전체 개요와 요약을 한눈에 보여주는 차트
-        - **자동 감지**: 슬라이드 내용을 분석하여 적절한 다이어그램 타입 자동 선택
+        ### 🎨 개선된 기능 - 최적화된 시각 요소
+        - **다이어그램 개수 제한**: 전체 슬라이드 중 필요도가 가장 높은 2개 슬라이드에만 다이어그램 생성
+        - **이미지 개수 제한**: 각 API별로 최대 3개씩, 총 6개의 AI 생성 이미지
+        - **한글 폰트 지원**: NanumGothic-Regular.ttf를 사용하여 다이어그램의 한글 깨짐 문제 해결
+        - **스마트 배치**: 다이어그램과 이미지는 텍스트와 겹치지 않도록 우측에 자동 배치
         
         ### 💡 고급 팁
-        - **다이어그램 자동 생성**: 슬라이드 내용에 따라 6가지 다이어그램 중 가장 적합한 타입이 자동으로 선택됩니다
-        - **병렬 이미지 생성**: 3D 스타일과 포토리얼리스틱 이미지가 동시에 생성되어 시간이 절약됩니다
-        - **스마트 배치**: 다이어그램과 이미지는 텍스트와 겹치지 않도록 우측에 자동 배치됩니다
-        - **키워드 기반 감지**: 프로세스, 개념, 프로젝트, 중심, 개요 등의 키워드를 감지하여 다이어그램 타입을 결정합니다
+        - **다이어그램 우선��위**: 프로세스, WBS, 개념도 등의 키워드가 있는 슬라이드가 우선 선택됩니다
+        - **이미지 분배**: 3D 스타일과 포토리얼리스틱 이미지가 균형있게 분배됩니다
+        - **표지 이미지**: 주제에 맞는 프리미엄 표지 이미지가 자동 생성됩니다
+        - **한글 지원**: app.py와 같은 경로에 NanumGothic-Regular.ttf 파일을 배치하세요
         """
     )
     
@@ -2785,6 +2848,13 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
 
 # Initialize APIs on startup
 if __name__ == "__main__":
+    # 한글 폰트 확인
+    if os.path.exists(KOREAN_FONT_PATH):
+        logger.info(f"✅ 한글 폰트 파일을 찾았습니다: {KOREAN_FONT_PATH}")
+    else:
+        logger.warning(f"⚠️ 한글 폰트 파일을 찾을 수 없습니다: {KOREAN_FONT_PATH}")
+        logger.warning("다이어그램에서 한글이 깨질 수 있습니다. NanumGothic-Regular.ttf 파일을 app.py와 같은 경로에 배치하세요.")
+    
     # Try to initialize APIs in parallel
     with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
         futures = []
@@ -2807,4 +2877,4 @@ if __name__ == "__main__":
     else:
         logger.warning("⚠️ 다이어그램 생성기 모듈을 찾을 수 없습니다. 다이어그램 기능이 비활성화됩니다.")
     
-    demo.launch()  
+    demo.launch()