Update process_flow_generator.py

process_flow_generator.py

@@ -3,84 +3,70 @@ import json
 from tempfile import NamedTemporaryFile
 import os
 from PIL import Image
+import platform
+import subprocess
+
+def setup_korean_font_env():
+    """한글 폰트 환경 설정"""
+    CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+    FONT_PATH = os.path.join(CURRENT_DIR, 'NanumGothic-Regular.ttf')
+    
+    # 폰트 파일 존재 확인
+    if not os.path.exists(FONT_PATH):
+        print(f"[경고] 한글 폰트 파일을 찾을 수 없습니다: {FONT_PATH}")
+        return None
+    
+    # 환경 변수 설정
+    os.environ['GDFONTPATH'] = CURRENT_DIR
+    
+    # fonts.conf 생성
+    fonts_conf_path = os.path.join(CURRENT_DIR, 'fonts.conf')
+    fonts_conf_content = f"""<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
+<fontconfig>
+    <dir>{CURRENT_DIR}</dir>
+    <cachedir>/tmp/fontconfig-cache</cachedir>
+    
+    <match target="pattern">
+        <test name="family">
+            <string>NanumGothic</string>
+        </test>
+        <edit name="family" mode="assign" binding="same">
+            <string>NanumGothic-Regular</string>
+        </edit>
+    </match>
+    
+    <match target="pattern">
+        <test name="family">
+            <string>NanumGothic-Regular</string>
+        </test>
+        <edit name="file" mode="assign" binding="same">
+            <string>{FONT_PATH}</string>
+        </edit>
+    </match>
+    
+    <alias binding="same">
+        <family>NanumGothic</family>
+        <default>
+            <family>NanumGothic-Regular</family>
+        </default>
+    </alias>
+</fontconfig>"""
+    
+    with open(fonts_conf_path, 'w', encoding='utf-8') as f:
+        f.write(fonts_conf_content)
+    
+    os.environ['FONTCONFIG_FILE'] = fonts_conf_path
+    os.environ['FONTCONFIG_PATH'] = CURRENT_DIR
+    
+    return FONT_PATH
+
+# 폰트 설정 초기화
+FONT_PATH = setup_korean_font_env()
 
 def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
     """
     Generates a Process Flow Diagram (Flowchart) from JSON input.
-    Args:
-        json_input (str): A JSON string describing the process flow structure.
-                          It must follow the Expected JSON Format Example below.
-    Expected JSON Format Example:
-    {
-      "start_node": "Start Inference Request",
-      "nodes": [
-        {
-          "id": "user_input",
-          "label": "Receive User Input (Data)",
-          "type": "io"
-        },
-        {
-          "id": "preprocess_data",
-          "label": "Preprocess Data",
-          "type": "process"
-        },
-        {
-          "id": "validate_data",
-          "label": "Validate Data Format/Type",
-          "type": "decision"
-        },
-        {
-          "id": "data_valid_yes",
-          "label": "Data Valid?",
-          "type": "decision"
-        },
-        {
-          "id": "load_model",
-          "label": "Load AI Model (if not cached)",
-          "type": "process"
-        },
-        {
-          "id": "run_inference",
-          "label": "Run AI Model Inference",
-          "type": "process"
-        },
-        {
-          "id": "postprocess_output",
-          "label": "Postprocess Model Output",
-          "type": "process"
-        },
-        {
-          "id": "send_response",
-          "label": "Send Response to User",
-          "type": "io"
-        },
-        {
-          "id": "log_error",
-          "label": "Log Error & Notify User",
-          "type": "process"
-        },
-        {
-          "id": "end_inference_process",
-          "label": "End Inference Process",
-          "type": "end"
-        }
-      ],
-      "connections": [
-        {"from": "start_node", "to": "user_input", "label": "Request"},
-        {"from": "user_input", "to": "preprocess_data", "label": "Data Received"},
-        {"from": "preprocess_data", "to": "validate_data", "label": "Cleaned"},
-        {"from": "validate_data", "to": "data_valid_yes", "label": "Check"},
-        {"from": "data_valid_yes", "to": "load_model", "label": "Yes"},
-        {"from": "data_valid_yes", "to": "log_error", "label": "No"},
-        {"from": "load_model", "to": "run_inference", "label": "Model Ready"},
-        {"from": "run_inference", "to": "postprocess_output", "label": "Output Generated"},
-        {"from": "postprocess_output", "to": "send_response", "label": "Ready"},
-        {"from": "send_response", "to": "end_inference_process", "label": "Response Sent"},
-        {"from": "log_error", "to": "end_inference_process", "label": "Error Handled"}
-      ]
-    }
-    Returns:
-        str: The filepath to the generated PNG image file.
     """
     try:
         if not json_input.strip():
@@ -103,33 +89,41 @@ def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
             "default": "box"           # Fallback
         }
 
-        # 한글 폰트 설정
-        # GDFONTPATH가 설정되어 있으면 폰트 파일명(확장자 제외) 사용
-        korean_font = 'NanumGothic-Regular'
-
+        # Graphviz 다이어그램 생성 - 크기와 여백 조정
         dot = graphviz.Digraph(
             name='ProcessFlowDiagram',
             format='png',
+            encoding='utf-8',
             graph_attr={
-                'rankdir': 'TB',        # Top-to-Bottom flow is common for flowcharts
+                'rankdir': 'TB',        # Top-to-Bottom flow
                 'splines': 'ortho',     # Straight lines with 90-degree bends
-                'bgcolor': 'white',     # White background
-                'pad': '0.5',           # Padding around the graph
-                'nodesep': '0.6',       # Spacing between nodes on same rank
-                'ranksep': '0.8',       # Spacing between ranks
-                'fontname': korean_font,  # 그래프 전체 한글 폰트
-                'charset': 'UTF-8'      # UTF-8 인코딩
+                'bgcolor': 'white',     
+                'pad': '0.2',           # 전체 패딩 줄임 (0.5 -> 0.2)
+                'margin': '0.2',        # 마진 추가
+                'nodesep': '0.4',       # 노드 간 간격 줄임 (0.6 -> 0.4)
+                'ranksep': '0.6',       # 랭크 간 간격 줄임 (0.8 -> 0.6)
+                'fontname': 'NanumGothic-Regular',
+                'charset': 'UTF-8',
+                'dpi': '96',            # DPI 줄임 (150 -> 96)
+                'size': '10,7.5',       # 전체 그래프 크기 제한 (인치 단위)
+                'ratio': 'compress'     # 비율 압축
             },
             node_attr={
-                'fontname': korean_font  # 모든 노드의 기본 폰트
+                'fontname': 'NanumGothic-Regular',
+                'fontsize': '12',       # 폰트 크기 줄임 (14 -> 12)
+                'charset': 'UTF-8',
+                'height': '0.6',        # 노드 높이 지정
+                'width': '2.0',         # 노드 너비 지정
+                'margin': '0.2,0.1'     # 노드 내부 마진
             },
             edge_attr={
-                'fontname': korean_font  # 모든 엣지의 기본 폰트
+                'fontname': 'NanumGothic-Regular',
+                'fontsize': '9',        # 엣지 폰트 크기 줄임 (10 -> 9)
+                'charset': 'UTF-8'
             }
         )
         
-        base_color = '#19191a' # Hardcoded base color
-
+        base_color = '#19191a'
         fill_color_for_nodes = base_color
         font_color_for_nodes = 'white' if base_color == '#19191a' or base_color.lower() in ['#000000', '#19191a'] else 'black'
         
@@ -140,38 +134,46 @@ def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
         start_node_id = data['start_node']
         dot.node(
             start_node_id,
-            start_node_id, # Label is typically the ID itself for start/end
+            start_node_id,
             shape=node_shapes['start'],
             style='filled,rounded',
-            fillcolor='#2196F3', # A distinct blue for Start
+            fillcolor='#2196F3',
             fontcolor='white',
-            fontsize='14',
-            fontname=korean_font  # 한글 폰트 추가
+            fontsize='12',
+            height='0.5',
+            width='1.8'
         )
 
-        # Add all other nodes (process, decision, etc.)
+        # Add all other nodes
         for node_id, node_info in all_defined_nodes.items():
-            if node_id == start_node_id: # Skip if it's the start node, already added
+            if node_id == start_node_id:
                 continue
 
             node_type = node_info.get("type", "default")
             shape = node_shapes.get(node_type, "box")
-
             node_label = node_info['label']
 
-            # Use distinct color for end node if it exists
+            # 노드 타입에 따른 크기 조정
+            if node_type == 'decision':
+                height = '0.8'
+                width = '1.5'
+            else:
+                height = '0.6'
+                width = '2.0'
+
             if node_type == 'end':
-                 dot.node(
+                dot.node(
                     node_id,
                     node_label,
                     shape=shape,
                     style='filled,rounded',
-                    fillcolor='#F44336', # A distinct red for End
+                    fillcolor='#F44336',
                     fontcolor='white',
-                    fontsize='14',
-                    fontname=korean_font  # 한글 폰트 추가
+                    fontsize='12',
+                    height='0.5',
+                    width='1.8'
                 )
-            else: # Regular process, decision, etc. nodes use the selected base color
+            else:
                 dot.node(
                     node_id,
                     node_label,
@@ -179,8 +181,9 @@ def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
                     style='filled,rounded',
                     fillcolor=fill_color_for_nodes, 
                     fontcolor=font_color_for_nodes,
-                    fontsize='14',
-                    fontname=korean_font  # 한글 폰트 ���가
+                    fontsize='12',
+                    height=height,
+                    width=width
                 )
 
         # Add connections (edges)
@@ -189,117 +192,157 @@ def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
                 connection['from'],
                 connection['to'],
                 label=connection.get('label', ''),
-                color='#4a4a4a', # Dark gray for lines
+                color='#4a4a4a',
                 fontcolor='#4a4a4a',
-                fontsize='10',
-                fontname=korean_font  # 한글 폰트 추가
+                fontsize='9'
             )
         
+        # PNG로 직접 렌더링 (크기 조정됨)
         with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
             dot.render(tmp.name, format=output_format, cleanup=True)
-            return f"{tmp.name}.{output_format}"
+            png_path = f"{tmp.name}.{output_format}"
+            
+            # 생성된 이미지를 PIL로 열어서 크기 확인 및 조정
+            from PIL import Image
+            with Image.open(png_path) as img:
+                width, height = img.size
+                print(f"[프로세스 플로우] 생성된 이미지 크기: {width}x{height}")
+                
+                # 이미지가 너무 크면 리사이즈
+                max_width = 1200
+                max_height = 900
+                
+                if width > max_width or height > max_height:
+                    # 비율 유지하면서 리사이즈
+                    ratio = min(max_width/width, max_height/height)
+                    new_width = int(width * ratio)
+                    new_height = int(height * ratio)
+                    
+                    img_resized = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                    
+                    # 여백 추가하여 중앙 정렬
+                    final_img = Image.new('RGB', (max_width, max_height), 'white')
+                    x = (max_width - new_width) // 2
+                    y = (max_height - new_height) // 2
+                    final_img.paste(img_resized, (x, y))
+                    
+                    # 새로운 파일로 저장
+                    new_path = png_path.replace('.png', '_resized.png')
+                    final_img.save(new_path)
+                    os.unlink(png_path)  # 원본 삭제
+                    return new_path
+                
+            return png_path
 
     except json.JSONDecodeError:
         return "Error: Invalid JSON format"
     except Exception as e:
         return f"Error: {str(e)}"
 
-# PPT 통합을 위한 추가 함수
 def generate_process_flow_for_ppt(topic: str, context: str, style: str = "Business Workflow") -> Image.Image:
     """
     PPT 생성기에서 사용할 프로세스 플로우 다이어그램 생성
+    """
+    print(f"[프로세스 플로우] 생성 시작 - 주제: {topic}, 컨텍스트: {context}")
     
-    Args:
-        topic: 프레젠테이션 주제
-        context: 슬라이드 컨텍스트
-        style: 스타일 타입
+    # 한글 폰트 재설정 (매번 확인)
+    setup_korean_font_env()
     
-    Returns:
-        PIL Image 객체
-    """
-    # 컨텍스트에 따른 프로세스 플로우 JSON 생성
-    if "프로세스" in context or "process" in context.lower():
-        # 비즈니스 프로세스 플로우
+    # 컨텍스트 분석하여 적절한 프로세스 플로우 JSON 생성
+    context_lower = context.lower()
+    
+    # 노드 수를 줄이고 레이블을 짧게 만들어 공간 절약
+    if "프로젝트" in context or "project" in context_lower:
         flow_json = {
             "start_node": "시작",
             "nodes": [
-                {"id": "analyze", "label": "현황 분석", "type": "process"},
-                {"id": "plan", "label": "계획 수립", "type": "process"},
-                {"id": "review", "label": "검토 필요?", "type": "decision"},
-                {"id": "implement", "label": "실행", "type": "process"},
-                {"id": "monitor", "label": "모니터링", "type": "process"},
-                {"id": "complete", "label": "완료", "type": "end"}
+                {"id": "plan", "label": "기획", "type": "process"},
+                {"id": "design", "label": "설계", "type": "process"},
+                {"id": "develop", "label": "개발", "type": "process"},
+                {"id": "test", "label": "테스트", "type": "decision"},
+                {"id": "deploy", "label": "배포", "type": "process"},
+                {"id": "end", "label": "완료", "type": "end"}
             ],
             "connections": [
-                {"from": "시작", "to": "analyze", "label": ""},
-                {"from": "analyze", "to": "plan", "label": "분석 완료"},
-                {"from": "plan", "to": "review", "label": ""},
-                {"from": "review", "to": "implement", "label": "승인"},
-                {"from": "review", "to": "plan", "label": "재검토"},
-                {"from": "implement", "to": "monitor", "label": ""},
-                {"from": "monitor", "to": "complete", "label": "목표 달성"}
+                {"from": "시작", "to": "plan", "label": ""},
+                {"from": "plan", "to": "design", "label": ""},
+                {"from": "design", "to": "develop", "label": ""},
+                {"from": "develop", "to": "test", "label": ""},
+                {"from": "test", "to": "deploy", "label": "통과"},
+                {"from": "test", "to": "develop", "label": "수정"},
+                {"from": "deploy", "to": "end", "label": ""}
             ]
         }
-    elif "일정" in context or "timeline" in context.lower():
-        # 프로젝트 일정 플로우
+    elif "작동" in context or "기능" in context:
         flow_json = {
-            "start_node": "프로젝트 시작",
+            "start_node": "시작",
             "nodes": [
-                {"id": "phase1", "label": "1단계: 기획", "type": "process"},
-                {"id": "milestone1", "label": "기획 검토", "type": "decision"},
-                {"id": "phase2", "label": "2단계: 개발", "type": "process"},
-                {"id": "phase3", "label": "3단계: 테스트", "type": "process"},
-                {"id": "launch", "label": "런칭", "type": "io"},
-                {"id": "end", "label": "프로젝트 종료", "type": "end"}
+                {"id": "input", "label": "입력", "type": "io"},
+                {"id": "validate", "label": "검증", "type": "decision"},
+                {"id": "process", "label": "처리", "type": "process"},
+                {"id": "output", "label": "출력", "type": "io"},
+                {"id": "end", "label": "종료", "type": "end"}
             ],
             "connections": [
-                {"from": "프로젝트 시작", "to": "phase1", "label": ""},
-                {"from": "phase1", "to": "milestone1", "label": "4주"},
-                {"from": "milestone1", "to": "phase2", "label": "승인"},
-                {"from": "milestone1", "to": "phase1", "label": "보완"},
-                {"from": "phase2", "to": "phase3", "label": "8주"},
-                {"from": "phase3", "to": "launch", "label": "2주"},
-                {"from": "launch", "to": "end", "label": ""}
+                {"from": "시작", "to": "input", "label": ""},
+                {"from": "input", "to": "validate", "label": ""},
+                {"from": "validate", "to": "process", "label": "유효"},
+                {"from": "validate", "to": "input", "label": "재입력"},
+                {"from": "process", "to": "output", "label": ""},
+                {"from": "output", "to": "end", "label": ""}
             ]
         }
     else:
-        # 기본 워크플로우
+        # 기본 프로세스 플로우 (더 간단하게)
         flow_json = {
             "start_node": "시작",
             "nodes": [
-                {"id": "input", "label": "입력 단계", "type": "io"},
-                {"id": "process", "label": "처리 단계", "type": "process"},
-                {"id": "check", "label": "검증", "type": "decision"},
-                {"id": "output", "label": "출력 단계", "type": "io"},
-                {"id": "end", "label": "종료", "type": "end"}
+                {"id": "analyze", "label": "분석", "type": "process"},
+                {"id": "plan", "label": "계획", "type": "process"},
+                {"id": "execute", "label": "실행", "type": "process"},
+                {"id": "check", "label": "검토", "type": "decision"},
+                {"id": "complete", "label": "완료", "type": "end"}
             ],
             "connections": [
-                {"from": "시작", "to": "input", "label": ""},
-                {"from": "input", "to": "process", "label": "데이터"},
-                {"from": "process", "to": "check", "label": ""},
-                {"from": "check", "to": "output", "label": "통과"},
-                {"from": "check", "to": "process", "label": "재처리"},
-                {"from": "output", "to": "end", "label": ""}
+                {"from": "시작", "to": "analyze", "label": ""},
+                {"from": "analyze", "to": "plan", "label": ""},
+                {"from": "plan", "to": "execute", "label": ""},
+                {"from": "execute", "to": "check", "label": ""},
+                {"from": "check", "to": "complete", "label": "승인"},
+                {"from": "check", "to": "plan", "label": "수정"}
             ]
         }
     
     # JSON을 문자열로 변환
     json_str = json.dumps(flow_json, ensure_ascii=False)
     
+    print(f"[프로세스 플로우] JSON 생성 완료")
+    
     # 프로세스 플로우 다이어그램 생성
     png_path = generate_process_flow_diagram(json_str, 'png')
     
     if png_path.startswith("Error:"):
+        print(f"[프로세스 플로우] 생성 실패: {png_path}")
         # 에러 발생 시 기본 이미지 반환
-        from PIL import Image, ImageDraw, ImageFont
-        img = Image.new('RGB', (800, 600), 'white')
+        from PIL import ImageDraw, ImageFont
+        img = Image.new('RGB', (1200, 900), 'white')
         draw = ImageDraw.Draw(img)
-        draw.text((400, 300), png_path, fill='red', anchor='mm')
+        
+        try:
+            if FONT_PATH and os.path.exists(FONT_PATH):
+                font = ImageFont.truetype(FONT_PATH, 20)
+            else:
+                font = ImageFont.load_default()
+        except:
+            font = ImageFont.load_default()
+        
+        draw.text((600, 450), "프로세스 플로우 생성 실패", fill='red', anchor='mm', font=font)
         return img
     
+    print(f"[프로세스 플로우] PNG 생성 성공: {png_path}")
+    
     # PNG 파일을 PIL Image로 변환
     with Image.open(png_path) as img:
-        # 이미지 복사본 생성 (파일 닫기 위해)
         img_copy = img.copy()
     
     # 임시 파일 삭제