Wire integrated dashboard renderer (src/integrated_report.py)

src/integrated_report.py

@@ -0,0 +1,598 @@
+"""Integrated DFU Clinical Assessment Report — single-image dashboard.
+
+Renders a unified clinical dashboard PNG that nurses and clinicians can review
+at a glance. Combines:
+
+  - Original photograph
+  - Binary ulcer mask
+  - Multi-class tissue map (background / foot / perilesion / ulcer)
+  - Class area distribution (horizontal bars)
+  - Fitzpatrick / ITA estimation with color-coded badge
+  - PWAT items 3-8 table (raw vs adjusted, delta, severity bars)
+  - Total raw / total adjusted + clinical interpretation by range
+  - Lighting-quality warnings when applicable
+
+Designed for clinical staff: clean typography, clear hierarchy, consistent
+palette, fixed 1920x1200 px layout.
+
+Usage:
+    from src.integrated_report import render_integrated_report
+    dashboard = render_integrated_report(rgb, binary_overlay, multi_overlay, result)
+    # dashboard: np.ndarray RGB (1200, 1920, 3) uint8
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from src.pwat_estimator import ITEM_NAMES
+
+
+# ── Palette and design constants ────────────────────────────────────────────
+
+DASH_W, DASH_H = 1920, 1200
+
+COL_BG = (248, 250, 252)            # slate-50
+COL_CARD = (255, 255, 255)
+COL_CARD_BORDER = (226, 232, 240)   # slate-200
+COL_INK = (15, 23, 42)              # slate-900
+COL_INK_SOFT = (71, 85, 105)        # slate-600
+COL_INK_MUTE = (148, 163, 184)      # slate-400
+COL_HEADER_BG = (15, 23, 42)
+COL_HEADER_FG = (248, 250, 252)
+COL_ACCENT = (14, 116, 144)         # cyan-700
+COL_DANGER = (220, 38, 38)          # red-600
+COL_WARN = (217, 119, 6)            # amber-600
+COL_OK = (5, 150, 105)              # emerald-600
+COL_INFO = (37, 99, 235)            # blue-600
+
+CLASS_COLOR = {
+    "foot":       (34, 197, 94),    # green-500
+    "perilesion": (249, 115, 22),   # orange-500
+    "ulcer":      (239, 68, 68),    # red-500
+    "background": (107, 114, 128),  # gray-500
+}
+
+CLASS_LABEL_EN = {
+    "foot": "Healthy foot",
+    "perilesion": "Perilesional",
+    "ulcer": "Ulcer",
+    "background": "Background",
+}
+
+FITZ_RGB = {
+    "I":   (254, 243, 199),
+    "II":  (253, 224, 138),
+    "III": (245, 158, 11),
+    "IV":  (180, 83, 9),
+    "V":   (120, 53, 15),
+    "VI":  (45, 16, 4),
+}
+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),
+}
+
+PWAT_INTERPRETATION = [
+    (0,  6,  "Healing well",                                COL_OK),
+    (7,  12, "Moderate compromise — clinical follow-up",    COL_WARN),
+    (13, 18, "Severe compromise — adjust treatment",        COL_DANGER),
+    (19, 24, "Critical — urgent reassessment",              (153, 27, 27)),
+]
+
+SEV_LABEL = {0: "Normal", 1: "Mild", 2: "Moderate", 3: "Severe", 4: "Extreme"}
+
+
+# ── Font helpers ─────────────────────────────────────────────────────────────
+
+_FONT_BOLD_CANDIDATES = [
+    "DejaVuSans-Bold.ttf",
+    "C:/Windows/Fonts/segoeuib.ttf",
+    "C:/Windows/Fonts/arialbd.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+    "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
+]
+_FONT_REG_CANDIDATES = [
+    "DejaVuSans.ttf",
+    "C:/Windows/Fonts/segoeui.ttf",
+    "C:/Windows/Fonts/arial.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    "/System/Library/Fonts/Supplemental/Arial.ttf",
+]
+
+
+def _load_font(candidates, size):
+    for path in candidates:
+        try:
+            return ImageFont.truetype(path, size)
+        except (OSError, IOError):
+            continue
+    return ImageFont.load_default()
+
+
+def _font_b(size: int):
+    return _load_font(_FONT_BOLD_CANDIDATES, size)
+
+
+def _font_r(size: int):
+    return _load_font(_FONT_REG_CANDIDATES, size)
+
+
+def _text_size(draw: ImageDraw.ImageDraw, text: str, font) -> tuple[int, int]:
+    box = draw.textbbox((0, 0), text, font=font)
+    return box[2] - box[0], box[3] - box[1]
+
+
+# ── Drawing helpers ──────────────────────────────────────────────────────────
+
+def _rounded_card(draw: ImageDraw.ImageDraw, xy, radius=14,
+                  fill=COL_CARD, border=COL_CARD_BORDER, border_w=1,
+                  shadow=True):
+    """Rounded card with subtle drop shadow."""
+    x1, y1, x2, y2 = xy
+    if shadow:
+        for off, alpha in [(2, 18), (4, 8)]:
+            shadow_color = (15, 23, 42, alpha)
+            draw.rounded_rectangle(
+                (x1 + off, y1 + off, x2 + off, y2 + off),
+                radius=radius, fill=shadow_color,
+            )
+    draw.rounded_rectangle((x1, y1, x2, y2), radius=radius,
+                           fill=fill, outline=border, width=border_w)
+
+
+def _fit_image_into(img_rgb: np.ndarray, w: int, h: int) -> np.ndarray:
+    """Letterbox an image into a w x h canvas preserving aspect ratio."""
+    if img_rgb is None or img_rgb.size == 0:
+        return np.full((h, w, 3), 240, dtype=np.uint8)
+    src_h, src_w = img_rgb.shape[:2]
+    scale = min(w / src_w, h / src_h)
+    new_w, new_h = int(src_w * scale), int(src_h * scale)
+    resized = cv2.resize(img_rgb, (new_w, new_h), interpolation=cv2.INTER_AREA)
+    canvas = np.full((h, w, 3), 245, dtype=np.uint8)
+    off_x = (w - new_w) // 2
+    off_y = (h - new_h) // 2
+    canvas[off_y:off_y + new_h, off_x:off_x + new_w] = resized
+    return canvas
+
+
+def _paste_image(base_img: Image.Image, np_rgb: np.ndarray, box: tuple[int, int, int, int]):
+    x1, y1, x2, y2 = box
+    fitted = _fit_image_into(np_rgb, x2 - x1, y2 - y1)
+    base_img.paste(Image.fromarray(fitted), (x1, y1))
+
+
+def _hbar(draw, x, y, w, h, value, vmax, color, bg=(229, 231, 235), radius=4):
+    """Rounded horizontal bar with proportional fill."""
+    draw.rounded_rectangle((x, y, x + w, y + h), radius=radius, fill=bg)
+    if vmax > 0 and value > 0:
+        fill_w = max(2, int(w * value / vmax))
+        draw.rounded_rectangle((x, y, x + fill_w, y + h), radius=radius, fill=color)
+
+
+def _interpretation_for(total: float) -> tuple[str, tuple]:
+    """Map a (possibly fractional) PWAT total to its clinical band.
+
+    Rounds to nearest integer first so that 6.7 falls into the 7-12 band
+    (matches how clinicians read these cutoffs).
+    """
+    rounded = int(round(max(0.0, min(24.0, total))))
+    for lo, hi, label, color in PWAT_INTERPRETATION:
+        if lo <= rounded <= hi:
+            return label, color
+    return PWAT_INTERPRETATION[-1][2], PWAT_INTERPRETATION[-1][3]
+
+
+def _draw_wrapped_text(draw, text, xy, max_w, font, fill, max_lines=3):
+    """Simple word-wrap by pixel width."""
+    if not text:
+        return
+    words = text.split()
+    lines, cur = [], ""
+    for w in words:
+        trial = (cur + " " + w).strip()
+        tw, _ = _text_size(draw, trial, font)
+        if tw <= max_w:
+            cur = trial
+        else:
+            if cur:
+                lines.append(cur)
+            cur = w
+            if len(lines) >= max_lines:
+                break
+    if cur and len(lines) < max_lines:
+        lines.append(cur)
+
+    if len(lines) == max_lines and len(" ".join(lines)) < len(text):
+        last = lines[-1]
+        while last and _text_size(draw, last + "...", font)[0] > max_w:
+            last = last[:-1]
+        lines[-1] = last + "..."
+
+    x, y = xy
+    line_h = font.size + 4 if hasattr(font, "size") else 18
+    for ln in lines:
+        draw.text((x, y), ln, fill=fill, font=font)
+        y += line_h
+
+
+# ── Dashboard blocks ─────────────────────────────────────────────────────────
+
+def _draw_header(img: Image.Image, draw: ImageDraw.ImageDraw):
+    H = 90
+    draw.rectangle((0, 0, DASH_W, H), fill=COL_HEADER_BG)
+
+    # Logo accent
+    dot_x, dot_y = 36, 32
+    draw.ellipse((dot_x, dot_y, dot_x + 26, dot_y + 26), fill=(34, 197, 94))
+    draw.ellipse((dot_x + 6, dot_y + 6, dot_x + 20, dot_y + 20), fill=COL_HEADER_BG)
+
+    title = "Integrated Diabetic Foot Ulcer Assessment Report"
+    subtitle = ("WoundNetB7  -  EfficientNet-B7 + ASPP + CBAM + CoordAttention + TAM "
+                " -  Ulcer Dice 0.927")
+    draw.text((78, 18), title, fill=COL_HEADER_FG, font=_font_b(28))
+    draw.text((78, 56), subtitle, fill=(148, 163, 184), font=_font_r(15))
+
+    # Right-side timestamp + advisory
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+    ts_w, _ = _text_size(draw, ts, _font_r(15))
+    draw.text((DASH_W - 36 - ts_w, 22), ts, fill=(148, 163, 184), font=_font_r(15))
+    advisory = "Research use only — not a clinical diagnosis"
+    adv_w, _ = _text_size(draw, advisory, _font_r(13))
+    draw.text((DASH_W - 36 - adv_w, 46), advisory, fill=(251, 191, 36), font=_font_r(13))
+
+
+def _draw_image_strip(img: Image.Image, draw: ImageDraw.ImageDraw,
+                      original_rgb, binary_rgb, multi_rgb, class_distribution: dict):
+    """Top row: original + binary + multiclass + class distribution."""
+    y0 = 110
+    y1 = y0 + 360
+    pad = 20
+    card_w = (DASH_W - pad * 5) // 4
+
+    titles = ["Original Image", "Binary Ulcer Mask",
+              "Multi-Class Segmentation", "Class Area Distribution"]
+    images = [original_rgb, binary_rgb, multi_rgb, None]
+
+    for i, (t, im) in enumerate(zip(titles, images)):
+        x1 = pad + i * (card_w + pad)
+        x2 = x1 + card_w
+        _rounded_card(draw, (x1, y0, x2, y1))
+
+        draw.text((x1 + 16, y0 + 12), t, fill=COL_INK, font=_font_b(15))
+
+        cx1, cy1, cx2, cy2 = x1 + 14, y0 + 42, x2 - 14, y1 - 14
+        if im is not None:
+            _paste_image(img, im, (cx1, cy1, cx2, cy2))
+        else:
+            _draw_class_distribution(draw, class_distribution, (cx1, cy1, cx2, cy2))
+
+
+def _draw_class_distribution(draw, dist: dict, box: tuple[int, int, int, int]):
+    x1, y1, x2, y2 = box
+    inner_w = x2 - x1
+
+    items = [("ulcer", dist.get("ulcer", 0)),
+             ("perilesion", dist.get("perilesion", 0)),
+             ("foot", dist.get("foot", 0)),
+             ("background", dist.get("background", 0))]
+
+    row_h = 56
+    cur_y = y1 + 6
+    for cls, pct in items:
+        color = CLASS_COLOR[cls]
+        label = CLASS_LABEL_EN[cls]
+
+        draw.rounded_rectangle((x1, cur_y, x1 + 14, cur_y + 14), radius=3, fill=color)
+
+        draw.text((x1 + 24, cur_y - 2), label, fill=COL_INK, font=_font_b(15))
+        pct_text = f"{pct:.1f} %"
+        pw, _ = _text_size(draw, pct_text, _font_b(15))
+        draw.text((x2 - pw, cur_y - 2), pct_text, fill=COL_INK, font=_font_b(15))
+
+        _hbar(draw, x1, cur_y + 22, inner_w, 10,
+              value=min(pct, 100), vmax=100, color=color,
+              bg=(241, 245, 249), radius=5)
+
+        cur_y += row_h
+
+
+def _draw_fitzpatrick_card(draw: ImageDraw.ImageDraw, fitz, x1: int, y1: int, x2: int, y2: int):
+    """Fitzpatrick / ITA card."""
+    _rounded_card(draw, (x1, y1, x2, y2))
+
+    draw.text((x1 + 22, y1 + 14),
+              "Fitzpatrick / ITA Skin Type Estimation",
+              fill=COL_INK, font=_font_b(18))
+    draw.text((x1 + 22, y1 + 42),
+              "Calibrated on 61 DFU images — 86.9% exact match — r=0.975",
+              fill=COL_INK_SOFT, font=_font_r(13))
+
+    if fitz is None or getattr(fitz, "confidence", 0) == 0:
+        draw.text((x1 + 22, y1 + 80),
+                  "Not estimable (insufficient healthy-skin pixels).",
+                  fill=COL_INK_MUTE, font=_font_r(15))
+        return
+
+    ftype = fitz.fitzpatrick_type
+    bg_c = FITZ_RGB.get(ftype, (229, 231, 235))
+    fg_c = FITZ_TEXT_RGB.get(ftype, COL_INK)
+
+    light_q = getattr(fitz, "lighting_quality", "good")
+    light_warn = getattr(fitz, "lighting_warning", "")
+    banner_y = y1 + 70
+    banner_h = 0
+    if light_q == "insufficient":
+        banner_h = 56
+        draw.rounded_rectangle((x1 + 22, banner_y, x2 - 22, banner_y + banner_h),
+                               radius=8, fill=(254, 242, 242),
+                               outline=(252, 165, 165), width=1)
+        draw.text((x1 + 36, banner_y + 8), "Insufficient lighting",
+                  fill=(185, 28, 28), font=_font_b(14))
+        _draw_wrapped_text(draw, light_warn,
+                           (x1 + 36, banner_y + 28), x2 - 22 - 36,
+                           _font_r(12), (153, 27, 27), max_lines=2)
+    elif light_q == "low":
+        banner_h = 56
+        draw.rounded_rectangle((x1 + 22, banner_y, x2 - 22, banner_y + banner_h),
+                               radius=8, fill=(255, 251, 235),
+                               outline=(252, 211, 77), width=1)
+        draw.text((x1 + 36, banner_y + 8), "Suboptimal lighting",
+                  fill=(180, 83, 9), font=_font_b(14))
+        _draw_wrapped_text(draw, light_warn,
+                           (x1 + 36, banner_y + 28), x2 - 22 - 36,
+                           _font_r(12), (146, 64, 14), max_lines=2)
+
+    body_y = y1 + 82 + banner_h
+
+    # Skin-tone badge
+    badge_w, badge_h = 220, 220
+    bx1, by1 = x1 + 22, body_y
+    bx2, by2 = bx1 + badge_w, by1 + badge_h
+    draw.rounded_rectangle((bx1, by1, bx2, by2), radius=18,
+                           fill=bg_c, outline=(180, 180, 180), width=2)
+    draw.text((bx1 + 24, by1 + 32), "TYPE", fill=fg_c, font=_font_b(20))
+    big = _font_b(110)
+    bw, _ = _text_size(draw, ftype, big)
+    draw.text((bx1 + (badge_w - bw) // 2, by1 + 60), ftype, fill=fg_c, font=big)
+    label_font = _font_r(18)
+    lw, _ = _text_size(draw, fitz.fitzpatrick_label, label_font)
+    draw.text((bx1 + (badge_w - lw) // 2, by2 - 36),
+              fitz.fitzpatrick_label, fill=fg_c, font=label_font)
+
+    # Detail rows on the right
+    dx = bx2 + 30
+    dy = by1 + 6
+    rows = [
+        ("ITA",                f"{fitz.ita_angle:.1f} +/- {fitz.ita_std:.1f} deg"),
+        ("L* healthy skin",    f"{fitz.l_skin_mean:.1f}"),
+        ("L* scene (global)",  f"{getattr(fitz, 'l_scene_mean', 0):.1f}"),
+        ("b* healthy skin",    f"{fitz.b_skin_mean:.1f}"),
+        ("Healthy pixels",     f"{fitz.healthy_pixels:,}"),
+        ("Confidence",         f"{fitz.confidence:.0%}"),
+    ]
+    for k, v in rows:
+        draw.text((dx, dy), k + ":", fill=COL_INK_SOFT, font=_font_r(14))
+        draw.text((dx + 170, dy), v, fill=COL_INK, font=_font_b(14))
+        dy += 28
+
+    # Confidence bar
+    cy = by2 - 22
+    _hbar(draw, dx, cy, x2 - 30 - dx, 8,
+          value=fitz.confidence, vmax=1.0,
+          color=COL_OK if fitz.confidence > 0.6
+                else (COL_WARN if fitz.confidence > 0.3 else COL_DANGER),
+          bg=(241, 245, 249))
+
+
+def _draw_pwat_card(draw: ImageDraw.ImageDraw, pwat, x1: int, y1: int, x2: int, y2: int):
+    """PWAT card: raw vs adjusted table + totals + interpretation."""
+    _rounded_card(draw, (x1, y1, x2, y2))
+
+    draw.text((x1 + 22, y1 + 14),
+              "PWAT Score (raw vs Fitzpatrick-adjusted)",
+              fill=COL_INK, font=_font_b(18))
+    fitz_label = pwat.fitzpatrick_type if pwat else "-"
+    sub = (f"Items 3-8 — 0-4 ordinal scale per item — "
+           f"calibrated correction for Fitzpatrick {fitz_label}")
+    draw.text((x1 + 22, y1 + 42), sub, fill=COL_INK_SOFT, font=_font_r(13))
+
+    if pwat is None or not pwat.scores_raw:
+        draw.text((x1 + 22, y1 + 90),
+                  "Not estimable (ulcer not detected or area too small).",
+                  fill=COL_INK_MUTE, font=_font_r(15))
+        return
+
+    table_x = x1 + 22
+    table_w = (x2 - x1) - 44
+    table_y = y1 + 78
+
+    col_label_w = 200
+    col_raw_w   = 90
+    col_adj_w   = 110
+    col_delta_w = 80
+    col_bar_w   = 100
+    col_sev_w   = table_w - col_label_w - col_raw_w - col_adj_w - col_delta_w - col_bar_w
+
+    # Header row
+    draw.rectangle((table_x, table_y, table_x + table_w, table_y + 28),
+                   fill=(241, 245, 249))
+    cx = table_x + 12
+    headers = [
+        ("PWAT Item",      col_label_w),
+        ("Raw",            col_raw_w),
+        ("Adjusted",       col_adj_w),
+        ("Delta",          col_delta_w),
+        ("Severity",       col_bar_w),
+        ("Interpretation", col_sev_w),
+    ]
+    for h, w in headers:
+        draw.text((cx, table_y + 6), h, fill=COL_INK_SOFT, font=_font_b(13))
+        cx += w
+
+    row_y = table_y + 32
+    row_h = 38
+    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)
+        delta = adj - raw
+        cx = table_x + 12
+
+        if (item % 2) == 0:
+            draw.rectangle((table_x, row_y - 4, table_x + table_w, row_y + row_h - 4),
+                           fill=(248, 250, 252))
+
+        draw.text((cx, row_y + 4), name, fill=COL_INK, font=_font_b(14))
+        cx += col_label_w
+
+        draw.text((cx, row_y + 4), str(raw), fill=COL_INK, font=_font_b(15))
+        cx += col_raw_w
+
+        draw.text((cx, row_y + 4), f"{adj:.1f}", fill=COL_ACCENT, font=_font_b(15))
+        cx += col_adj_w
+
+        if abs(delta) < 0.05:
+            d_txt = "0.0"
+            d_col = COL_INK_SOFT
+        else:
+            d_txt = f"{delta:+.1f}"
+            d_col = COL_OK if delta < 0 else COL_DANGER
+        draw.text((cx, row_y + 4), d_txt, fill=d_col, font=_font_b(15))
+        cx += col_delta_w
+
+        _hbar(draw, cx, row_y + 10, col_bar_w - 14, 12,
+              value=raw, vmax=4, color=COL_DANGER, bg=(229, 231, 235), radius=6)
+        cx += col_bar_w
+
+        draw.text((cx, row_y + 4), SEV_LABEL.get(raw, ""),
+                  fill=COL_INK_SOFT, font=_font_r(13))
+
+        draw.line((table_x, row_y + row_h - 4, table_x + table_w, row_y + row_h - 4),
+                  fill=(241, 245, 249), width=1)
+        row_y += row_h
+
+    # Totals block
+    totals_y = row_y + 10
+    totals_h = 110
+
+    block_x1 = table_x
+    block_x2 = table_x + table_w
+    draw.rounded_rectangle((block_x1, totals_y, block_x2, totals_y + totals_h),
+                           radius=10, fill=(15, 23, 42))
+
+    label, color = _interpretation_for(pwat.total_adjusted)
+
+    # Total raw
+    draw.text((block_x1 + 24, totals_y + 14),
+              "Total Raw", fill=(148, 163, 184), font=_font_r(13))
+    draw.text((block_x1 + 24, totals_y + 32),
+              str(pwat.total_raw), fill=COL_HEADER_FG, font=_font_b(36))
+    draw.text((block_x1 + 24, totals_y + 76),
+              "/ 24", fill=(100, 116, 139), font=_font_r(13))
+
+    # Total adjusted
+    draw.text((block_x1 + 180, totals_y + 14),
+              "Total Adjusted", fill=(148, 163, 184), font=_font_r(13))
+    draw.text((block_x1 + 180, totals_y + 30),
+              f"{pwat.total_adjusted:.1f}", fill=color, font=_font_b(44))
+    delta_total = pwat.total_adjusted - pwat.total_raw
+    if abs(delta_total) >= 0.05:
+        draw.text((block_x1 + 180, totals_y + 84),
+                  f"({delta_total:+.1f} bias correction)",
+                  fill=(148, 163, 184), font=_font_r(13))
+
+    # Clinical interpretation
+    interp_x = block_x1 + 410
+    draw.text((interp_x, totals_y + 14),
+              "Clinical Interpretation", fill=(148, 163, 184), font=_font_r(13))
+    draw.text((interp_x, totals_y + 32),
+              label, fill=color, font=_font_b(20))
+
+    # Mini gradient bar with marker
+    seg_x = interp_x
+    seg_y = totals_y + 70
+    seg_w = block_x2 - seg_x - 24
+    seg_h = 14
+    draw.rounded_rectangle((seg_x, seg_y, seg_x + seg_w, seg_y + seg_h),
+                           radius=4, fill=(30, 41, 59))
+    seg_total = 24
+    cur_x = seg_x
+    for lo, hi, _, c in PWAT_INTERPRETATION:
+        seg_len = int(seg_w * (hi - lo + 1) / seg_total)
+        draw.rectangle((cur_x, seg_y, cur_x + seg_len, seg_y + seg_h), fill=c)
+        cur_x += seg_len
+
+    pos = seg_x + int(seg_w * pwat.total_adjusted / seg_total)
+    draw.polygon([
+        (pos - 6, seg_y - 4),
+        (pos + 6, seg_y - 4),
+        (pos, seg_y + 2),
+    ], fill=COL_HEADER_FG)
+    tick_font = _font_r(11)
+    draw.text((seg_x, seg_y + seg_h + 4), "0",
+              fill=(148, 163, 184), font=tick_font)
+    draw.text((seg_x + seg_w - 14, seg_y + seg_h + 4), "24",
+              fill=(148, 163, 184), font=tick_font)
+
+
+def _draw_footer(draw: ImageDraw.ImageDraw):
+    y = DASH_H - 32
+    draw.line((0, y - 8, DASH_W, y - 8), fill=(226, 232, 240), width=1)
+    txt = ("WoundNetB7 — Doctoral Thesis — Marcelo Marquez-Murillo  |  "
+           "Dice 0.927 (95% CI 0.917-0.936)  |  "
+           "Debiasing 46.6% gap reduction (p < 1e-55)  |  "
+           "PWAT items: 3=Necrotic Type, 4=Necrotic Amount, "
+           "5=Granulation Type, 6=Granulation Amount, "
+           "7=Edges, 8=Periulcer Skin")
+    draw.text((24, y - 1), txt, fill=COL_INK_MUTE, font=_font_r(11))
+
+
+# ── Public API ───────────────────────────────────────────────────────────────
+
+def render_integrated_report(
+    original_rgb: np.ndarray,
+    binary_overlay_rgb: np.ndarray,
+    multiclass_overlay_rgb: np.ndarray,
+    result,
+) -> np.ndarray:
+    """Render the integrated dashboard as a single image.
+
+    Args:
+        original_rgb:           (H, W, 3) RGB uint8 — uploaded image
+        binary_overlay_rgb:     (H, W, 3) RGB uint8 — binary mask overlay
+        multiclass_overlay_rgb: (H, W, 3) RGB uint8 — multiclass overlay
+        result:                 AnalysisResult with class_distribution, fitzpatrick, pwat
+
+    Returns:
+        np.ndarray RGB uint8 of shape (1200, 1920, 3)
+    """
+    canvas = Image.new("RGB", (DASH_W, DASH_H), COL_BG)
+    draw = ImageDraw.Draw(canvas, "RGBA")
+
+    _draw_header(canvas, draw)
+
+    _draw_image_strip(canvas, draw,
+                      original_rgb, binary_overlay_rgb, multiclass_overlay_rgb,
+                      result.class_distribution)
+
+    pad = 20
+    row_y0 = 490
+    row_y1 = DASH_H - 56
+    fitz_w = 720
+    fitz_x1 = pad
+    fitz_x2 = fitz_x1 + fitz_w
+    pwat_x1 = fitz_x2 + pad
+    pwat_x2 = DASH_W - pad
+
+    _draw_fitzpatrick_card(draw, result.fitzpatrick,
+                           fitz_x1, row_y0, fitz_x2, row_y1)
+    _draw_pwat_card(draw, result.pwat,
+                    pwat_x1, row_y0, pwat_x2, row_y1)
+
+    _draw_footer(draw)
+
+    return np.array(canvas)