Add high-resolution ASCII diagram converter for academic presentations

tests/ascii_png.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Improved ASCII to High-Resolution Image Converter
+Optimized for academic conferences (NeurIPS) with fallback font support
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+import os
+from pathlib import Path
+
+def create_ascii_diagram(ascii_text: str, output_path: str = "oncall_ai_flowchart.png") -> bool:
+    """
+    Convert ASCII diagram to high-resolution image with academic quality
+    
+    Args:
+        ascii_text: ASCII art text content
+        output_path: Output PNG file path
+        
+    Returns:
+        Boolean indicating success
+    """
+    
+    # Font selection with fallback options
+    font_paths = [
+        "/System/Library/Fonts/SFNSMono.ttf",           # macOS Big Sur+
+        "/System/Library/Fonts/Monaco.ttf",             # macOS fallback
+        "/System/Library/Fonts/Menlo.ttf",              # macOS alternative  
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",  # Linux
+        "C:/Windows/Fonts/consola.ttf",                 # Windows
+        None  # PIL default font fallback
+    ]
+    
+    font = None
+    font_size = 14  # Slightly smaller for better readability
+    
+    # Try fonts in order of preference
+    for font_path in font_paths:
+        try:
+            if font_path is None:
+                font = ImageFont.load_default()
+                print("🔤 Using PIL default font")
+                break
+            elif os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, font_size)
+                print(f"✅ Using font: {font_path}")
+                break
+        except Exception as e:
+            print(f"⚠️ Font loading failed: {font_path} - {e}")
+            continue
+    
+    if font is None:
+        print("❌ No suitable font found")
+        return False
+    
+    # Process text lines
+    lines = ascii_text.strip().split("\n")
+    lines = [line.rstrip() for line in lines]  # Remove trailing whitespace
+    
+    # Calculate dimensions using modern PIL methods
+    try:
+        # Modern Pillow 10.0+ method
+        line_metrics = [font.getbbox(line) for line in lines]
+        max_width = max([metrics[2] - metrics[0] for metrics in line_metrics])
+        line_height = max([metrics[3] - metrics[1] for metrics in line_metrics])
+    except AttributeError:
+        # Fallback for older Pillow versions
+        try:
+            line_sizes = [font.getsize(line) for line in lines]
+            max_width = max([size[0] for size in line_sizes])
+            line_height = max([size[1] for size in line_sizes])
+        except AttributeError:
+            # Ultimate fallback
+            max_width = len(max(lines, key=len)) * font_size * 0.6
+            line_height = font_size * 1.2
+    
+    # Image dimensions with padding
+    padding = 40
+    img_width = int(max_width + padding * 2)
+    img_height = int(line_height * len(lines) + padding * 2)
+    
+    print(f"📐 Image dimensions: {img_width} x {img_height}")
+    print(f"📏 Max line width: {max_width}, Line height: {line_height}")
+    
+    # Create high-resolution image
+    img = Image.new("RGB", (img_width, img_height), "white")
+    draw = ImageDraw.Draw(img)
+    
+    # Draw text lines
+    for i, line in enumerate(lines):
+        y_pos = padding + i * line_height
+        draw.text((padding, y_pos), line, font=font, fill="black")
+    
+    # Save with high DPI for academic use
+    try:
+        img.save(output_path, dpi=(300, 300), optimize=True)
+        print(f"✅ High-resolution diagram saved: {output_path}")
+        print(f"📊 Image size: {img_width}x{img_height} at 300 DPI")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save image: {e}")
+        return False
+
+# Example usage with your OnCall.ai flowchart
+if __name__ == "__main__":
+    
+    # Your OnCall.ai ASCII flowchart
+    oncall_ascii = """
++-------------------------------------------------------+-------------------------------------------------------------+
+|                     User Query                        |         Pipeline Architecture Overview                     |
+|              (Medical emergency question)             |        5-Level Fallback System Design                      |
++-------------------------------------------------------+-------------------------------------------------------------+
+                             |
+                             v
++-------------------------------------------------------+-------------------------------------------------------------+
+| 🎯 Level 1: Predefined Mapping                         | [High Precision, Low Coverage]                             |
+| +---------------------------------------------------+  | → Handles common, well-defined conditions                  |
+| | • Direct condition mapping (medical_conditions.py)|  |                                                            |
+| | • Regex pattern matching                          |  | Examples:                                                  |
+| | • Instant response for known conditions           |  | • "chest pain" → acute coronary syndrome                   |
+| | • Processing time: ~0.001s                        |  | • "stroke symptoms" → acute stroke                         |
+| +---------------------------------------------------+  | • "heart attack" → myocardial infarction                   |
++-------------------------------------------------------+-------------------------------------------------------------+
+                             |
+                        [if fails]
+                             v
++-------------------------------------------------------+-------------------------------------------------------------+
+| 🤖 Level 2+4: LLM Analysis (Combined)                 | [Medium Precision, Medium Coverage]                        |
+| +---------------------------------------------------+ | → Handles complex queries understandable by AI             |
+| | • Single Med42-70B call for dual tasks            | |                                                            |
+| | • Extract condition + Validate medical query      | | Examples:                                                  |
+| | • 40% time optimization (25s → 15s)               | | • "elderly patient with multiple symptoms"                 |
+| | • Processing time: 12-15s                         | | • "complex cardiovascular presentation"                    |
+| +---------------------------------------------------+ | • "differential diagnosis for confusion"                   |
++-------------------------------------------------------+-------------------------------------------------------------+
+           |                                 |
+    [condition found]                 [medical but no condition]
+           |                                 |
+           |                                 v
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |   | 🔍 Level 3: Semantic Search                           | [Medium Precision, High Coverage]                          |
+           |   | +---------------------------------------------------+ | → Handles semantically similar, vague queries              |
+           |   | | • PubMedBERT embeddings (768 dimensions)          | |                                                            |
+           |   | | • Angular distance calculation                    | | Examples:                                                  |
+           |   | | • Sliding window chunk search                     | | • "feeling unwell with breathing issues"                   |
+           |   | | • Processing time: 1-2s                           | | • "patient experiencing discomfort"                        |
+           |   | +---------------------------------------------------+ | • "concerning symptoms in elderly"                         |
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |                                 |
+           |                            [if fails]
+           |                                 v
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |   | ✅ Level 4: Medical Validation                        | [Low Precision, Filtering]                                 |
+           |   | +---------------------------------------------------+ | → Ensures queries are medically relevant                   |
+           |   | | • Medical keyword validation                      | |                                                            |
+           |   | | • LLM-based medical query confirmation            | | Examples:                                                  |
+           |   | | • Non-medical query rejection                     | | • Rejects: "how to cook pasta"                             |
+           |   | | • Processing time: <1s                            | | • Accepts: "persistent headache"                           |
+           |   | +---------------------------------------------------+ | • Filters: "car repair" vs "chest pain"                    |
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |                                 |
+           |                            [if passes]
+           |                                 v
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |   | 🏥 Level 5: Generic Medical Search                    | [Low Precision, Full Coverage]                             |
+           |   | +---------------------------------------------------+ | → Final fallback; always provides an answer                |
+           |   | | • Broad medical content search                    | |                                                            |
+           |   | | • Generic medical terminology matching            | | Examples:                                                  |
+           |   | | • Always provides medical guidance                | | • "I don't feel well" → general advice                     |
+           |   | | • Processing time: ~1s                            | | • "something wrong" → seek medical care                    |
+           |   | +---------------------------------------------------+ | • "health concern" → basic guidance                        |
+           |   +-------------------------------------------------------+-------------------------------------------------------------+
+           |                                 |
+           +─────────────────────────────────+
+                             |
+                             v
++-------------------------------------------------------+-------------------------------------------------------------+
+|                  📋 Medical Response                  |              System Performance Metrics                    |
+| +---------------------------------------------------+ |                                                            |
+| | • Evidence-based clinical advice                  | | • Average pipeline time: 15.5s                             |
+| | • Retrieved medical guidelines (8-9 per query)    | | • Condition extraction: 2.6s average                       |
+| | • Confidence scoring and citations                | | • Retrieval relevance: 0.245-0.326                         |
+| | • 100% coverage guarantee                         | | • Overall success rate: 69.2%                              |
+| +---------------------------------------------------+ | • Clinical actionability: 9.0/10 (RAG)                     |
++-------------------------------------------------------+-------------------------------------------------------------+
+    """
+    
+    # Execute conversion
+    success = create_ascii_diagram(oncall_ascii, "5_layer_fallback.png")
+    
+    if success:
+        print("\n🎉 Ready for NeurIPS presentation!")
+        print("💡 You can now insert this high-quality diagram into your paper or poster")
+    else:
+        print("\n❌ Conversion failed - check font availability")

tests/ascii_png_5steps_general_pipeline.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Improved ASCII to High-Resolution Image Converter
+Optimized for academic conferences (NeurIPS) with fallback font support
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+import os
+from pathlib import Path
+
+def create_ascii_diagram(ascii_text: str, output_path: str = "oncall_ai_flowchart.png") -> bool:
+    """
+    Convert ASCII diagram to high-resolution image with academic quality
+    
+    Args:
+        ascii_text: ASCII art text content
+        output_path: Output PNG file path
+        
+    Returns:
+        Boolean indicating success
+    """
+    
+    # Font selection with fallback options
+    font_paths = [
+        "/System/Library/Fonts/SFNSMono.ttf",           # macOS Big Sur+
+        "/System/Library/Fonts/Monaco.ttf",             # macOS fallback
+        "/System/Library/Fonts/Menlo.ttf",              # macOS alternative  
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",  # Linux
+        "C:/Windows/Fonts/consola.ttf",                 # Windows
+        None  # PIL default font fallback
+    ]
+    
+    font = None
+    font_size = 14  # Slightly smaller for better readability
+    
+    # Try fonts in order of preference
+    for font_path in font_paths:
+        try:
+            if font_path is None:
+                font = ImageFont.load_default()
+                print("🔤 Using PIL default font")
+                break
+            elif os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, font_size)
+                print(f"✅ Using font: {font_path}")
+                break
+        except Exception as e:
+            print(f"⚠️ Font loading failed: {font_path} - {e}")
+            continue
+    
+    if font is None:
+        print("❌ No suitable font found")
+        return False
+    
+    # Process text lines
+    lines = ascii_text.strip().split("\n")
+    lines = [line.rstrip() for line in lines]  # Remove trailing whitespace
+    
+    # Calculate dimensions using modern PIL methods
+    try:
+        # Modern Pillow 10.0+ method
+        line_metrics = [font.getbbox(line) for line in lines]
+        max_width = max([metrics[2] - metrics[0] for metrics in line_metrics])
+        line_height = max([metrics[3] - metrics[1] for metrics in line_metrics])
+    except AttributeError:
+        # Fallback for older Pillow versions
+        try:
+            line_sizes = [font.getsize(line) for line in lines]
+            max_width = max([size[0] for size in line_sizes])
+            line_height = max([size[1] for size in line_sizes])
+        except AttributeError:
+            # Ultimate fallback
+            max_width = len(max(lines, key=len)) * font_size * 0.6
+            line_height = font_size * 1.2
+    
+    # Image dimensions with padding
+    padding = 40
+    img_width = int(max_width + padding * 2)
+    img_height = int(line_height * len(lines) + padding * 2)
+    
+    print(f"📐 Image dimensions: {img_width} x {img_height}")
+    print(f"📏 Max line width: {max_width}, Line height: {line_height}")
+    
+    # Create high-resolution image
+    img = Image.new("RGB", (img_width, img_height), "white")
+    draw = ImageDraw.Draw(img)
+    
+    # Draw text lines
+    for i, line in enumerate(lines):
+        y_pos = padding + i * line_height
+        draw.text((padding, y_pos), line, font=font, fill="black")
+    
+    # Save with high DPI for academic use
+    try:
+        img.save(output_path, dpi=(300, 300), optimize=True)
+        print(f"✅ High-resolution diagram saved: {output_path}")
+        print(f"📊 Image size: {img_width}x{img_height} at 300 DPI")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save image: {e}")
+        return False
+
+# Example usage with your OnCall.ai flowchart
+if __name__ == "__main__":
+    
+    # Your OnCall.ai ASCII flowchart
+    oncall_ascii = """
++---------------------------------------------------+-------------------------------------------------------------+
+| User Input                                        | 1. STEP 1: Condition Extraction                             |
+|   ↓                                               |    - Processes user input through 5-level fallback          |
+| STEP 1: Condition Extraction (5-level fallback)   |    - Extracts medical conditions and keywords               |
+|   ↓                                               |    - Handles complex symptom descriptions & terminology     |
+| STEP 2: System Understanding Display (Transparent)|-------------------------------------------------------------|
+|   ↓                                               | 2. STEP 2: System Understanding Display                     |
+| STEP 3: Medical Guidelines Retrieval              |    - Shows transparent interpretation of user query         |
+|   ↓                                               |    - No user interaction required                           |
+| STEP 4: Evidence-based Advice Generation          |    - Builds confidence in system understanding              |
+|   ↓                                               |-------------------------------------------------------------|
+| STEP 5: Performance Summary & Technical Details   | 3. STEP 3: Medical Guidelines Retrieval                     |
+|   ↓                                               |    - Searches dual-index system (emergency + treatment)     |
+| Multi-format Output                               |    - Returns 8-9 relevant guidelines per query              |
+| (Advice + Guidelines + Metrics)                   |    - Maintains emergency/treatment balance                  |
+|                                                   |-------------------------------------------------------------|
+|                                                   | 4. STEP 4: Evidence-based Advice Generation                 |
+|                                                   |    - Uses RAG-based prompt construction                     |
+|                                                   |    - Integrates specialized medical LLM (Med42-70B)         |
+|                                                   |    - Generates clinically appropriate guidance              |
+|                                                   |-------------------------------------------------------------|
+|                                                   | 5. STEP 5: Performance Summary                              |
+|                                                   |    - Aggregates timing and confidence metrics               |
+|                                                   |    - Provides technical metadata for transparency           |
+|                                                   |    - Enables system performance monitoring                  |
++---------------------------------------------------+-------------------------------------------------------------+
+|                                  General Pipeline 5 steps Mechanism Overview                                    |
+    """
+    
+    # Execute conversion
+    success = create_ascii_diagram(oncall_ascii, "5level_general_pipeline.png")
+    
+    if success:
+        print("\n🎉 Ready for NeurIPS presentation!")
+        print("💡 You can now insert this high-quality diagram into your paper or poster")
+    else:
+        print("\n❌ Conversion failed - check font availability")

tests/ascii_png_chunk.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Improved ASCII to High-Resolution Image Converter
+Optimized for academic conferences (NeurIPS) with fallback font support
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+import os
+from pathlib import Path
+
+def create_ascii_diagram(ascii_text: str, output_path: str = "oncall_ai_flowchart.png") -> bool:
+    """
+    Convert ASCII diagram to high-resolution image with academic quality
+    
+    Args:
+        ascii_text: ASCII art text content
+        output_path: Output PNG file path
+        
+    Returns:
+        Boolean indicating success
+    """
+    
+    # Font selection with fallback options
+    font_paths = [
+        "/System/Library/Fonts/SFNSMono.ttf",           # macOS Big Sur+
+        "/System/Library/Fonts/Monaco.ttf",             # macOS fallback
+        "/System/Library/Fonts/Menlo.ttf",              # macOS alternative  
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",  # Linux
+        "C:/Windows/Fonts/consola.ttf",                 # Windows
+        None  # PIL default font fallback
+    ]
+    
+    font = None
+    font_size = 14  # Slightly smaller for better readability
+    
+    # Try fonts in order of preference
+    for font_path in font_paths:
+        try:
+            if font_path is None:
+                font = ImageFont.load_default()
+                print("🔤 Using PIL default font")
+                break
+            elif os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, font_size)
+                print(f"✅ Using font: {font_path}")
+                break
+        except Exception as e:
+            print(f"⚠️ Font loading failed: {font_path} - {e}")
+            continue
+    
+    if font is None:
+        print("❌ No suitable font found")
+        return False
+    
+    # Process text lines
+    lines = ascii_text.strip().split("\n")
+    lines = [line.rstrip() for line in lines]  # Remove trailing whitespace
+    
+    # Calculate dimensions using modern PIL methods
+    try:
+        # Modern Pillow 10.0+ method
+        line_metrics = [font.getbbox(line) for line in lines]
+        max_width = max([metrics[2] - metrics[0] for metrics in line_metrics])
+        line_height = max([metrics[3] - metrics[1] for metrics in line_metrics])
+    except AttributeError:
+        # Fallback for older Pillow versions
+        try:
+            line_sizes = [font.getsize(line) for line in lines]
+            max_width = max([size[0] for size in line_sizes])
+            line_height = max([size[1] for size in line_sizes])
+        except AttributeError:
+            # Ultimate fallback
+            max_width = len(max(lines, key=len)) * font_size * 0.6
+            line_height = font_size * 1.2
+    
+    # Image dimensions with padding
+    padding = 40
+    img_width = int(max_width + padding * 2)
+    img_height = int(line_height * len(lines) + padding * 2)
+    
+    print(f"📐 Image dimensions: {img_width} x {img_height}")
+    print(f"📏 Max line width: {max_width}, Line height: {line_height}")
+    
+    # Create high-resolution image
+    img = Image.new("RGB", (img_width, img_height), "white")
+    draw = ImageDraw.Draw(img)
+    
+    # Draw text lines
+    for i, line in enumerate(lines):
+        y_pos = padding + i * line_height
+        draw.text((padding, y_pos), line, font=font, fill="black")
+    
+    # Save with high DPI for academic use
+    try:
+        img.save(output_path, dpi=(300, 300), optimize=True)
+        print(f"✅ High-resolution diagram saved: {output_path}")
+        print(f"📊 Image size: {img_width}x{img_height} at 300 DPI")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save image: {e}")
+        return False
+
+# Example usage with your OnCall.ai flowchart
+if __name__ == "__main__":
+    
+    # Your OnCall.ai ASCII flowchart
+    oncall_ascii = """
+┌──────────────────────────────────────┐          ┌──────────────────────────────────────┐
+│              OFFLINE STAGE           │          │               ONLINE STAGE           │
+├──────────────────────────────────────┤          ├──────────────────────────────────────┤
+│ data_processing.py                   │          │ retrieval.py                         │
+│  • Text cleaning                     │          │  • Query keyword extraction          │
+│  • Keyword-centered chunking         │          │  • Vector search                     │
+│    (overlap)                         │          │    (emergency / treatment)           │
+│  • Metadata annotation               │          │  • Dynamic grouping via metadata     │
+│  • Embedding generation              │          │  • Ranking & Top-K selection         │
+│  • Annoy index construction          │          │  • Return final results              │
+└──────────────────────────────────────┘          └──────────────────────────────────────┘
+
+|                      Offline vs. Online responsibility separation                      |
+    """
+    
+    # Execute conversion
+    success = create_ascii_diagram(oncall_ascii, "offline_online_responsibility_separation.png")
+    
+    if success:
+        print("\n🎉 Ready for NeurIPS presentation!")
+        print("💡 You can now insert this high-quality diagram into your paper or poster")
+    else:
+        print("\n❌ Conversion failed - check font availability")

tests/ascii_png_template.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Improved ASCII to High-Resolution Image Converter
+Optimized for academic conferences (NeurIPS) with fallback font support
+"""
+
+from PIL import Image, ImageDraw, ImageFont
+import os
+from pathlib import Path
+
+def create_ascii_diagram(ascii_text: str, output_path: str = "oncall_ai_flowchart.png") -> bool:
+    """
+    Convert ASCII diagram to high-resolution image with academic quality
+    
+    Args:
+        ascii_text: ASCII art text content
+        output_path: Output PNG file path
+        
+    Returns:
+        Boolean indicating success
+    """
+    
+    # Font selection with fallback options
+    font_paths = [
+        "/System/Library/Fonts/SFNSMono.ttf",           # macOS Big Sur+
+        "/System/Library/Fonts/Monaco.ttf",             # macOS fallback
+        "/System/Library/Fonts/Menlo.ttf",              # macOS alternative  
+        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",  # Linux
+        "C:/Windows/Fonts/consola.ttf",                 # Windows
+        None  # PIL default font fallback
+    ]
+    
+    font = None
+    font_size = 14  # Slightly smaller for better readability
+    
+    # Try fonts in order of preference
+    for font_path in font_paths:
+        try:
+            if font_path is None:
+                font = ImageFont.load_default()
+                print("🔤 Using PIL default font")
+                break
+            elif os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, font_size)
+                print(f"✅ Using font: {font_path}")
+                break
+        except Exception as e:
+            print(f"⚠️ Font loading failed: {font_path} - {e}")
+            continue
+    
+    if font is None:
+        print("❌ No suitable font found")
+        return False
+    
+    # Process text lines
+    lines = ascii_text.strip().split("\n")
+    lines = [line.rstrip() for line in lines]  # Remove trailing whitespace
+    
+    # Calculate dimensions using modern PIL methods
+    try:
+        # Modern Pillow 10.0+ method
+        line_metrics = [font.getbbox(line) for line in lines]
+        max_width = max([metrics[2] - metrics[0] for metrics in line_metrics])
+        line_height = max([metrics[3] - metrics[1] for metrics in line_metrics])
+    except AttributeError:
+        # Fallback for older Pillow versions
+        try:
+            line_sizes = [font.getsize(line) for line in lines]
+            max_width = max([size[0] for size in line_sizes])
+            line_height = max([size[1] for size in line_sizes])
+        except AttributeError:
+            # Ultimate fallback
+            max_width = len(max(lines, key=len)) * font_size * 0.6
+            line_height = font_size * 1.2
+    
+    # Image dimensions with padding
+    padding = 40
+    img_width = int(max_width + padding * 2)
+    img_height = int(line_height * len(lines) + padding * 2)
+    
+    print(f"📐 Image dimensions: {img_width} x {img_height}")
+    print(f"📏 Max line width: {max_width}, Line height: {line_height}")
+    
+    # Create high-resolution image
+    img = Image.new("RGB", (img_width, img_height), "white")
+    draw = ImageDraw.Draw(img)
+    
+    # Draw text lines
+    for i, line in enumerate(lines):
+        y_pos = padding + i * line_height
+        draw.text((padding, y_pos), line, font=font, fill="black")
+    
+    # Save with high DPI for academic use
+    try:
+        img.save(output_path, dpi=(300, 300), optimize=True)
+        print(f"✅ High-resolution diagram saved: {output_path}")
+        print(f"📊 Image size: {img_width}x{img_height} at 300 DPI")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save image: {e}")
+        return False
+
+# Example usage with your OnCall.ai flowchart
+if __name__ == "__main__":
+    
+    # Your OnCall.ai ASCII flowchart
+    oncall_ascii = """
+Metric 5: Clinical Actionability (1-10 scale)
+  1-2 points: Almost no actionable advice; extremely abstract or empty responses.
+  3-4 points: Provides some directional suggestions but too vague, lacks clear steps.
+  5-6 points: Offers basic executable steps but lacks details or insufficient explanation for key aspects.
+  7-8 points: Clear and complete steps that clinicians can follow, with occasional gaps needing supplementation.
+  9-10 points: Extremely actionable with precise, step-by-step executable guidance; can be used "as-is" immediately.
+
+Metric 6: Clinical Evidence Quality (1-10 scale)
+  1-2 points: Almost no evidence support; cites completely irrelevant or unreliable sources.
+  3-4 points: References lower quality literature or guidelines, or sources lack authority.
+  5-6 points: Uses general quality literature/guidelines but lacks depth or currency.
+  7-8 points: References reliable, authoritative sources (renowned journals or authoritative guidelines) with accurate explanations.
+  9-10 points: Rich and high-quality evidence sources (systematic reviews, RCTs, etc.) combined with latest research; enhances recommendation credibility.
+    """
+    
+    # Execute conversion
+    success = create_ascii_diagram(oncall_ascii, "Metric5_6.png")
+    
+    if success:
+        print("\n🎉 Ready for NeurIPS presentation!")
+        print("💡 You can now insert this high-quality diagram into your paper or poster")
+    else:
+        print("\n❌ Conversion failed - check font availability")