feat: add downloadable clinical report (PNG 300 DPI + JSON)

app.py

@@ -5,6 +5,7 @@ Pipeline visualization:
   2. Multiclass segmentation (background / foot / perilesion / ulcer)
   3. Fitzpatrick/ITA skin type estimation
   4. PWAT scores (raw) + PWAT adjusted by Fitzpatrick debiasing
+  5. Downloadable clinical report (PNG composite + JSON)
 
 Launch locally: python app.py
 Deploy to HF: push this repo to a Hugging Face Space (GPU recommended).
@@ -13,7 +14,12 @@ import gradio as gr
 import numpy as np
 import cv2
 import json
+import tempfile
+import os
+from datetime import datetime
+from PIL import Image, ImageDraw, ImageFont
 from pipeline import WoundNetB7Pipeline
+from src.pwat_estimator import ITEM_NAMES
 
 pipe = WoundNetB7Pipeline(models_dir="models", use_tta=True)
 
@@ -27,9 +33,327 @@ FITZ_TEXT_COLORS = {
     "IV": "#ffffff", "V": "#ffffff", "VI": "#ffffff",
 }
 
+FITZ_RGB = {
+    "I": (254, 243, 199), "II": (253, 230, 138), "III": (251, 191, 36),
+    "IV": (180, 83, 9), "V": (120, 53, 15), "VI": (69, 26, 3),
+}
+
+FITZ_TEXT_RGB = {
+    "I": (31, 41, 55), "II": (31, 41, 55), "III": (31, 41, 55),
+    "IV": (255, 255, 255), "V": (255, 255, 255), "VI": (255, 255, 255),
+}
+
+
+# ── Report Generation ────────────────────────────────────────────────────────
+
+def _get_font(size):
+    """Get a font, falling back to default if custom fonts unavailable."""
+    for name in ["DejaVuSans-Bold.ttf", "DejaVuSans.ttf", "arial.ttf", "LiberationSans-Bold.ttf"]:
+        try:
+            return ImageFont.truetype(name, size)
+        except (OSError, IOError):
+            continue
+    return ImageFont.load_default()
+
+
+def _get_font_regular(size):
+    for name in ["DejaVuSans.ttf", "arial.ttf", "LiberationSans-Regular.ttf"]:
+        try:
+            return ImageFont.truetype(name, size)
+        except (OSError, IOError):
+            continue
+    return ImageFont.load_default()
+
+
+def _draw_text_block(draw, x, y, lines, font, fill=(50, 50, 50), line_spacing=6):
+    """Draw multiple lines of text, return y after last line."""
+    for line in lines:
+        draw.text((x, y), line, fill=fill, font=font)
+        bbox = font.getbbox(line)
+        y += (bbox[3] - bbox[1]) + line_spacing
+    return y
+
+
+def generate_report_image(image_rgb, binary_overlay, multiclass_overlay, result):
+    """Generate a composite clinical report image (PNG, 300 DPI quality)."""
+    # Layout: 2400 x 3200 px (portrait, ~8x10.7 inches at 300 DPI)
+    W, H = 2400, 3200
+    BG = (255, 255, 255)
+    report = Image.new("RGB", (W, H), BG)
+    draw = ImageDraw.Draw(report)
+
+    font_title = _get_font(42)
+    font_subtitle = _get_font(28)
+    font_body = _get_font_regular(24)
+    font_small = _get_font_regular(20)
+    font_label = _get_font(22)
+    font_big = _get_font(52)
+
+    MARGIN = 60
+    COL_W = (W - 3 * MARGIN) // 2
+    IMG_H = 550
+
+    # ── Header ──
+    draw.rectangle([(0, 0), (W, 120)], fill=(31, 41, 55))
+    draw.text((MARGIN, 28), "WoundNetB7 — Informe de Analisis DFU", fill=(255, 255, 255), font=font_title)
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+    draw.text((W - MARGIN - 300, 35), timestamp, fill=(156, 163, 175), font=font_body)
+    draw.text((MARGIN, 78), "EfficientNet-B7 + ASPP + CBAM + CoordAttention + TAM  |  Ulcer Dice: 0.927",
+              fill=(156, 163, 175), font=font_small)
+
+    y = 145
+
+    # ── Row 1: Original + Binary Segmentation ──
+    draw.text((MARGIN, y), "1. Imagen Original", fill=(31, 41, 55), font=font_subtitle)
+    draw.text((MARGIN + COL_W + MARGIN, y), "2. Segmentacion Binaria (Ulcera)", fill=(31, 41, 55), font=font_subtitle)
+    y += 40
+
+    # Resize and paste images
+    orig_pil = Image.fromarray(image_rgb).resize((COL_W, IMG_H), Image.LANCZOS)
+    binary_pil = Image.fromarray(binary_overlay).resize((COL_W, IMG_H), Image.LANCZOS)
+    report.paste(orig_pil, (MARGIN, y))
+    report.paste(binary_pil, (MARGIN + COL_W + MARGIN, y))
+
+    # Border
+    for bx in [MARGIN, MARGIN + COL_W + MARGIN]:
+        draw.rectangle([(bx, y), (bx + COL_W, y + IMG_H)], outline=(209, 213, 219), width=2)
+
+    y += IMG_H + 20
+
+    # Image info
+    h_img, w_img = result.image_size
+    ulcer_pct = result.class_distribution.get("ulcer", 0)
+    draw.text((MARGIN, y), f"Resolucion: {w_img}x{h_img} px", fill=(107, 114, 128), font=font_small)
+    draw.text((MARGIN + COL_W + MARGIN, y),
+              f"Area ulcera: {ulcer_pct:.1f}% de la imagen", fill=(107, 114, 128), font=font_small)
+    y += 35
+
+    # ── Row 2: Multiclass + Seg Stats ──
+    draw.line([(MARGIN, y), (W - MARGIN, y)], fill=(229, 231, 235), width=2)
+    y += 15
+    draw.text((MARGIN, y), "3. Segmentacion Multiclase (4 clases)", fill=(31, 41, 55), font=font_subtitle)
+    draw.text((MARGIN + COL_W + MARGIN, y), "Distribucion de Clases", fill=(31, 41, 55), font=font_subtitle)
+    y += 40
+
+    multi_pil = Image.fromarray(multiclass_overlay).resize((COL_W, IMG_H), Image.LANCZOS)
+    report.paste(multi_pil, (MARGIN, y))
+    draw.rectangle([(MARGIN, y), (MARGIN + COL_W, y + IMG_H)], outline=(209, 213, 219), width=2)
+
+    # Seg stats panel
+    stats_x = MARGIN + COL_W + MARGIN
+    stats_y = y + 20
+    class_info = [
+        ("Pie", result.class_distribution.get("foot", 0), (34, 197, 94)),
+        ("Perilesion", result.class_distribution.get("perilesion", 0), (249, 115, 22)),
+        ("Ulcera", result.class_distribution.get("ulcer", 0), (239, 68, 68)),
+        ("Fondo", result.class_distribution.get("background", 0), (107, 114, 128)),
+    ]
+    bar_w = COL_W - 140
+    for cls_name, pct, color in class_info:
+        draw.text((stats_x, stats_y), f"{cls_name}", fill=color, font=font_label)
+        draw.text((stats_x + 160, stats_y), f"{pct:.1f}%", fill=(50, 50, 50), font=font_body)
+        stats_y += 32
+        # Bar background
+        draw.rectangle([(stats_x, stats_y), (stats_x + bar_w, stats_y + 18)],
+                       fill=(229, 231, 235), outline=None)
+        # Bar fill
+        fill_w = max(1, int(bar_w * pct / 100))
+        draw.rectangle([(stats_x, stats_y), (stats_x + fill_w, stats_y + 18)],
+                       fill=color, outline=None)
+        stats_y += 35
+
+    # Legend
+    stats_y += 10
+    legend_items = [
+        ((34, 197, 94), "Pie: tejido sano"),
+        ((249, 115, 22), "Perilesion: zona periulceral"),
+        ((239, 68, 68), "Ulcera: lecho de la herida"),
+    ]
+    for color, text in legend_items:
+        draw.rectangle([(stats_x, stats_y + 2), (stats_x + 16, stats_y + 18)], fill=color)
+        draw.text((stats_x + 24, stats_y), text, fill=(50, 50, 50), font=font_small)
+        stats_y += 28
+
+    y += IMG_H + 20
+
+    # ── Row 3: Fitzpatrick + PWAT ──
+    draw.line([(MARGIN, y), (W - MARGIN, y)], fill=(229, 231, 235), width=2)
+    y += 15
+    draw.text((MARGIN, y), "4. Fitzpatrick / ITA", fill=(31, 41, 55), font=font_subtitle)
+    draw.text((MARGIN + COL_W + MARGIN, y), "5. PWAT Scores (Raw vs Ajustado)", fill=(31, 41, 55), font=font_subtitle)
+    y += 45
+
+    # Fitzpatrick panel
+    fitz = result.fitzpatrick
+    fitz_x = MARGIN
+    if fitz and fitz.confidence > 0:
+        # Colored badge
+        ftype = fitz.fitzpatrick_type
+        badge_bg = FITZ_RGB.get(ftype, (229, 231, 235))
+        badge_fg = FITZ_TEXT_RGB.get(ftype, (50, 50, 50))
+        badge_w, badge_h = 220, 120
+        draw.rounded_rectangle(
+            [(fitz_x, y), (fitz_x + badge_w, y + badge_h)],
+            radius=16, fill=badge_bg, outline=(180, 180, 180), width=2
+        )
+        draw.text((fitz_x + 30, y + 15), f"Tipo {ftype}", fill=badge_fg, font=font_big)
+        draw.text((fitz_x + 30, y + 78), fitz.fitzpatrick_label, fill=badge_fg, font=font_small)
+
+        # Details
+        det_x = fitz_x + badge_w + 30
+        det_lines = [
+            f"ITA: {fitz.ita_angle:.1f} +/- {fitz.ita_std:.1f} grados",
+            f"L* medio (piel sana): {fitz.l_skin_mean:.1f}",
+            f"b* medio (piel sana): {fitz.b_skin_mean:.1f}",
+            f"Pixeles sanos: {fitz.healthy_pixels:,}",
+            f"Ratio piel sana: {fitz.healthy_ratio:.1%}",
+            f"Confianza: {fitz.confidence:.0%}",
+        ]
+        _draw_text_block(draw, det_x, y, det_lines, font_body, line_spacing=8)
+    else:
+        draw.text((fitz_x, y), "No estimable (insuficiente piel sana)", fill=(107, 114, 128), font=font_body)
+
+    # PWAT panel
+    pwat = result.pwat
+    pwat_x = MARGIN + COL_W + MARGIN
+    if pwat and pwat.scores_raw:
+        ftype_str = pwat.fitzpatrick_type or "III"
+
+        # Table header
+        col_positions = [pwat_x, pwat_x + 260, pwat_x + 420, pwat_x + 600, pwat_x + 740]
+        headers = ["Item", "Raw", "Ajustado", "Delta"]
+        for i, (hx, htext) in enumerate(zip(col_positions, headers)):
+            draw.text((hx, y), htext, fill=(55, 65, 81), font=font_label)
+        py = y + 35
+        draw.line([(pwat_x, py), (pwat_x + COL_W - 40, py)], fill=(55, 65, 81), width=2)
+        py += 8
+
+        for item in [3, 4, 5, 6, 7, 8]:
+            name = ITEM_NAMES.get(item, f"Item {item}")
+            raw = pwat.scores_raw.get(item, 0)
+            adj = pwat.scores_adjusted.get(item, 0.0)
+            diff = adj - raw
+            diff_str = f"{diff:+.1f}" if abs(diff) > 0.01 else "0.0"
+            diff_color = (5, 150, 105) if diff < -0.05 else (107, 114, 128)
+
+            draw.text((col_positions[0], py), name, fill=(50, 50, 50), font=font_body)
+            draw.text((col_positions[1], py), str(raw), fill=(50, 50, 50), font=font_body)
+            draw.text((col_positions[2], py), f"{adj:.1f}", fill=(50, 50, 50), font=font_body)
+            draw.text((col_positions[3], py), diff_str, fill=diff_color, font=font_label)
+
+            # Mini bar (raw)
+            bar_x = col_positions[1] + 40
+            bar_y = py + 6
+            bar_total = 120
+            draw.rectangle([(bar_x, bar_y), (bar_x + bar_total, bar_y + 10)], fill=(229, 231, 235))
+            draw.rectangle([(bar_x, bar_y), (bar_x + int(bar_total * raw / 4), bar_y + 10)], fill=(239, 68, 68))
+
+            py += 38
+
+        # Total row
+        draw.line([(pwat_x, py), (pwat_x + COL_W - 40, py)], fill=(55, 65, 81), width=2)
+        py += 8
+        draw.text((col_positions[0], py), "TOTAL", fill=(31, 41, 55), font=font_label)
+        draw.text((col_positions[1], py), str(pwat.total_raw), fill=(31, 41, 55), font=font_label)
+        draw.text((col_positions[2], py), f"{pwat.total_adjusted:.1f}", fill=(31, 41, 55), font=font_label)
+        total_diff = pwat.total_adjusted - pwat.total_raw
+        total_diff_str = f"{total_diff:+.1f}" if abs(total_diff) > 0.01 else "0.0"
+        total_color = (5, 150, 105) if total_diff < -0.05 else (107, 114, 128)
+        draw.text((col_positions[3], py), total_diff_str, fill=total_color, font=font_label)
+
+        py += 40
+        draw.text((pwat_x, py), f"Correccion aplicada: Fitzpatrick tipo {ftype_str}",
+                  fill=(107, 114, 128), font=font_small)
+    else:
+        draw.text((pwat_x, y), "No estimable (ulcera no detectada)", fill=(107, 114, 128), font=font_body)
+
+    # ── Footer ──
+    draw.rectangle([(0, H - 90), (W, H)], fill=(249, 250, 251))
+    draw.line([(0, H - 90), (W, H - 90)], fill=(209, 213, 219), width=1)
+    footer_lines = [
+        "WoundNetB7  |  Tesis Doctoral  |  Marcelo Marquez-Murillo",
+        "Ulcer Dice: 0.927 (CI 95%: [0.917, 0.936])  |  Debiasing: 46.6% max group gap reduction (p < 1e-55)",
+    ]
+    draw.text((MARGIN, H - 80), footer_lines[0], fill=(107, 114, 128), font=font_small)
+    draw.text((MARGIN, H - 52), footer_lines[1], fill=(156, 163, 175), font=font_small)
+
+    return report
+
+
+def generate_report_files(image_rgb, binary_overlay, multiclass_overlay, result):
+    """Generate downloadable report files (PNG + JSON)."""
+    tmpdir = tempfile.mkdtemp(prefix="woundnetb7_report_")
+
+    # PNG report
+    report_img = generate_report_image(image_rgb, binary_overlay, multiclass_overlay, result)
+    png_path = os.path.join(tmpdir, "WoundNetB7_Informe_DFU.png")
+    report_img.save(png_path, "PNG", dpi=(300, 300))
+
+    # JSON report
+    report_data = result.to_dict()
+    report_data["report_metadata"] = {
+        "generated_at": datetime.now().isoformat(),
+        "model": "WoundNetB7 (EfficientNet-B7 + ASPP + CBAM + CoordAttention + TAM)",
+        "ulcer_dice": 0.927,
+        "dice_ci_95": [0.917, 0.936],
+        "tta_folds": 6,
+        "debiasing": "Fitzpatrick-calibrated ITA (86.9% accuracy, r=0.975)",
+    }
+    json_path = os.path.join(tmpdir, "WoundNetB7_Informe_DFU.json")
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(report_data, f, indent=2, ensure_ascii=False)
+
+    return [png_path, json_path]
+
+
+# ── Gradio callbacks ─────────────────────────────────────────────────────────
+
+# Store last analysis result for report generation
+_last_analysis = {}
+
+
+def analyze_image(image):
+    """Main analysis function called by Gradio."""
+    if image is None:
+        empty = np.zeros((100, 100, 3), dtype=np.uint8)
+        _last_analysis.clear()
+        return empty, empty, "", "", "", "{}"
+
+    img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    result = pipe.analyze(img_bgr, use_tta=True)
+
+    binary_overlay = pipe.visualize_binary(img_bgr, result)
+    multiclass_overlay = pipe.visualize_multiclass(img_bgr, result)
+
+    # Cache for report
+    _last_analysis["image_rgb"] = image
+    _last_analysis["binary"] = binary_overlay
+    _last_analysis["multiclass"] = multiclass_overlay
+    _last_analysis["result"] = result
+
+    seg_stats = build_seg_stats_html(result)
+    fitz_html = build_fitz_html(result.fitzpatrick)
+    pwat_html = build_pwat_html(result.pwat)
+    json_out = json.dumps(result.to_dict(), indent=2, ensure_ascii=False)
+
+    return binary_overlay, multiclass_overlay, seg_stats, fitz_html, pwat_html, json_out
+
+
+def download_report():
+    """Generate and return downloadable report files."""
+    if not _last_analysis:
+        return None
+    return generate_report_files(
+        _last_analysis["image_rgb"],
+        _last_analysis["binary"],
+        _last_analysis["multiclass"],
+        _last_analysis["result"],
+    )
+
+
+# ── HTML builders ─────────────────────────────────────────────────────────────
 
 def build_fitz_html(fitz):
-    """Build Fitzpatrick/ITA HTML card."""
     if fitz is None or fitz.confidence == 0:
         return "<p style='color:#6b7280;'>No se pudo estimar (insuficientes pixeles de piel sana).</p>"
 
@@ -55,12 +379,9 @@ def build_fitz_html(fitz):
 
 
 def build_pwat_html(pwat):
-    """Build PWAT scores comparison table (raw vs adjusted)."""
     if pwat is None or not pwat.scores_raw:
         return "<p style='color:#6b7280;'>No se pudo estimar PWAT (ulcera no detectada o muy pequena).</p>"
 
-    from src.pwat_estimator import ITEM_NAMES
-
     rows = ""
     for item in [3, 4, 5, 6, 7, 8]:
         name = ITEM_NAMES.get(item, f"Item {item}")
@@ -68,11 +389,9 @@ def build_pwat_html(pwat):
         adj = pwat.scores_adjusted.get(item, 0.0)
         diff = adj - raw
 
-        # Color code: green if adjusted lower (debiased), neutral otherwise
         diff_color = "#059669" if diff < -0.05 else "#6b7280"
         diff_str = f"{diff:+.1f}" if abs(diff) > 0.01 else "0.0"
 
-        # Bar visualization (0-4 scale)
         raw_pct = raw / 4 * 100
         adj_pct = adj / 4 * 100
 
@@ -134,7 +453,6 @@ def build_pwat_html(pwat):
 
 
 def build_seg_stats_html(result):
-    """Build segmentation statistics HTML."""
     dist = result.class_distribution
     colors = {"background": "#374151", "foot": "#22c55e", "perilesion": "#f97316", "ulcer": "#ef4444"}
 
@@ -164,40 +482,9 @@ def build_seg_stats_html(result):
     """
 
 
-def analyze_image(image):
-    """Main analysis function called by Gradio."""
-    if image is None:
-        empty = np.zeros((100, 100, 3), dtype=np.uint8)
-        return empty, empty, "", "", "", "{}"
-
-    img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-
-    result = pipe.analyze(img_bgr, use_tta=True)
-
-    # Visualizations
-    binary_overlay = pipe.visualize_binary(img_bgr, result)
-    multiclass_overlay = pipe.visualize_multiclass(img_bgr, result)
-
-    # HTML outputs
-    seg_stats = build_seg_stats_html(result)
-    fitz_html = build_fitz_html(result.fitzpatrick)
-    pwat_html = build_pwat_html(result.pwat)
-
-    # JSON
-    json_out = json.dumps(result.to_dict(), indent=2, ensure_ascii=False)
-
-    return binary_overlay, multiclass_overlay, seg_stats, fitz_html, pwat_html, json_out
-
-
 # ── Gradio UI ────────────────────────────────────────────────────────────────
 
 css = """
-.pipeline-step {
-    border: 1px solid #e5e7eb;
-    border-radius: 12px;
-    padding: 16px;
-    margin-bottom: 8px;
-}
 .step-header {
     display: flex;
     align-items: center;
@@ -321,10 +608,25 @@ with gr.Blocks(
     """)
     output_pwat = gr.HTML()
 
+    # ── Download Report ──
+    gr.HTML("""
+    <div class="step-header" style="margin-top:16px;">
+      <div class="step-number" style="background:#059669;">&#8681;</div>
+      <div class="step-title">Descargar Informe Clinico</div>
+    </div>
+    <p style="font-size:0.88em; color:#6b7280; margin-bottom:8px;">
+      Genera un informe compuesto (PNG 300 DPI) con todas las visualizaciones
+      y un archivo JSON con los datos estructurados. Primero analiza una imagen.
+    </p>
+    """)
+    download_btn = gr.Button("Descargar Informe", variant="secondary", size="lg")
+    output_files = gr.File(label="Archivos del Informe", file_count="multiple")
+
     # ── JSON (collapsible) ──
     with gr.Accordion("JSON completo (para integracion)", open=False):
         output_json = gr.Code(label="JSON Output", language="json")
 
+    # ── Wire events ──
     analyze_btn.click(
         fn=analyze_image,
         inputs=[input_image],
@@ -338,6 +640,12 @@ with gr.Blocks(
         ],
     )
 
+    download_btn.click(
+        fn=download_report,
+        inputs=[],
+        outputs=[output_files],
+    )
+
     gr.HTML("""
     <div style="text-align:center; padding:16px 0; font-size:0.82em; color:#9ca3af; border-top:1px solid #e5e7eb; margin-top:20px;">
       WoundNetB7 &bull; Tesis Doctoral &bull; Marcelo Marquez-Murillo &bull;