Fix file path and replace streamlit_app.py with v3

src/streamlit_app.py

@@ -97,12 +97,19 @@ def hex_to_rgb(h: str):
 
 def postprocess_masks(nuc_mask, myo_mask,
                       min_nuc_area=20, min_myo_area=500,
-                      myo_close_radius=3):
-    """Original closing-based postprocess — unchanged from V2."""
-    nuc_clean = remove_small_objects(
-        nuc_mask.astype(bool), min_size=int(min_nuc_area)
-    ).astype(np.uint8)
+                      nuc_close_radius=2, myo_close_radius=3):
+    """
+    Clean up raw predicted masks.
+    Nuclei:   optional closing to fill gaps, then remove small objects.
+    Myotubes: closing + opening to smooth edges, then remove small objects.
+    """
+    # Nuclei
+    nuc_bin = nuc_mask.astype(bool)
+    if int(nuc_close_radius) > 0:
+        nuc_bin = closing(nuc_bin, disk(int(nuc_close_radius)))
+    nuc_clean = remove_small_objects(nuc_bin, min_size=int(min_nuc_area)).astype(np.uint8)
 
+    # Myotubes
     selem     = disk(int(myo_close_radius))
     myo_bin   = closing(myo_mask.astype(bool), selem)
     myo_bin   = opening(myo_bin, selem)
@@ -231,73 +238,127 @@ def make_instance_overlay(rgb_u8: np.ndarray,
                            label_nuclei: bool = True,
                            label_myotubes: bool = True) -> np.ndarray:
     """
-    Per-instance coloured overlay rendered with matplotlib.
-    Nuclei → cool colourmap with white numeric IDs.
-    Myotubes → autumn colourmap with M1, M2… IDs.
-    Returns RGB uint8 array at original image resolution.
+    Per-instance coloured overlay rendered at high DPI so labels stay sharp
+    when the image is zoomed in.
+
+    Nuclei   → cool colourmap, white numeric IDs on solid dark-blue backing.
+    Myotubes → autumn colourmap, white M1/M2… IDs on solid dark-red backing.
+
+    Font sizes are fixed in data-space pixels so they look the same regardless
+    of image resolution.  Myotube labels are always 3× bigger than nucleus
+    labels so the two tiers are visually distinct at any zoom level.
     """
     orig_h, orig_w = rgb_u8.shape[:2]
     nuc_cmap = plt.cm.get_cmap("cool")
     myo_cmap = plt.cm.get_cmap("autumn")
 
+    # ── resize label maps to original image resolution ───────────────────────
     def _resize_lab(lab, h, w):
-        return np.array(Image.fromarray(lab.astype(np.int32)).resize((w, h), Image.NEAREST))
+        return np.array(
+            Image.fromarray(lab.astype(np.int32)).resize((w, h), Image.NEAREST)
+        )
 
     nuc_disp = _resize_lab(nuc_lab, orig_h, orig_w)
     myo_disp = _resize_lab(myo_lab, orig_h, orig_w)
-    base     = rgb_u8.astype(np.float32).copy()
-    n_myo    = int(myo_disp.max())
     n_nuc    = int(nuc_disp.max())
+    n_myo    = int(myo_disp.max())
 
+    # ── colour the mask regions ───────────────────────────────────────────────
+    base = rgb_u8.astype(np.float32).copy()
     if n_myo > 0:
         myo_norm = (myo_disp / max(n_myo, 1)).astype(np.float32)
         myo_rgba = (myo_cmap(myo_norm)[:, :, :3] * 255).astype(np.float32)
         mask = myo_disp > 0
         base[mask] = (1 - alpha) * base[mask] + alpha * myo_rgba[mask]
-
     if n_nuc > 0:
         nuc_norm = (nuc_disp / max(n_nuc, 1)).astype(np.float32)
         nuc_rgba = (nuc_cmap(nuc_norm)[:, :, :3] * 255).astype(np.float32)
         mask = nuc_disp > 0
         base[mask] = (1 - alpha) * base[mask] + alpha * nuc_rgba[mask]
-
     overlay = np.clip(base, 0, 255).astype(np.uint8)
 
-    dpi = 100
-    fig, ax = plt.subplots(figsize=(orig_w / dpi, orig_h / dpi), dpi=dpi)
+    # ── render at high DPI so the PNG is sharp when zoomed ───────────────────
+    # We render the figure at the ORIGINAL pixel size × a scale factor,
+    # then downsample back — this keeps labels crisp at zoom.
+    RENDER_SCALE = 2          # render at 2× then downsample → no blur
+    dpi          = 150
+    fig_w        = orig_w * RENDER_SCALE / dpi
+    fig_h        = orig_h * RENDER_SCALE / dpi
+
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h), dpi=dpi)
     ax.imshow(overlay)
+    ax.set_xlim(0, orig_w)
+    ax.set_ylim(orig_h, 0)
     ax.axis("off")
 
-    scale_x = orig_w / nuc_lab.shape[1]
-    scale_y = orig_h / nuc_lab.shape[0]
-    font_nuc = max(3, min(6, orig_w // 200))
-    font_myo = max(4, min(8, orig_w // 150))
+    # ── font sizes: fixed in figure points, independent of image size ────────
+    # At RENDER_SCALE=2, dpi=150: 1 data pixel ≈ 1/75 inch.
+    # We want nucleus labels ~8–10 pt and myotube labels ~18–22 pt.
+    font_nuc = 9    # pt  — clearly readable when zoomed, not overwhelming at full view
+    font_myo = 20   # pt  — dominant, impossible to miss
 
+    # ── nucleus labels ────────────────────────────────────────────────────────
     if label_nuclei:
         for prop in measure.regionprops(nuc_lab):
             r, c = prop.centroid
-            ax.text(c * scale_x, r * scale_y, str(prop.label),
-                    fontsize=font_nuc, color="white", ha="center", va="center",
-                    fontweight="bold",
-                    bbox=dict(boxstyle="round,pad=0.1", fc="steelblue", alpha=0.6, lw=0))
+            # scale centroid from prediction-space to display-space
+            cx = c * (orig_w / nuc_lab.shape[1])
+            cy = r * (orig_h / nuc_lab.shape[0])
+            ax.text(
+                cx, cy, str(prop.label),
+                fontsize=font_nuc,
+                color="white",
+                ha="center", va="center",
+                fontweight="bold",
+                bbox=dict(
+                    boxstyle="round,pad=0.25",
+                    fc="#003366",     # solid dark-blue — fully opaque
+                    ec="none",
+                    alpha=0.92,
+                ),
+                zorder=2,
+            )
 
+    # ── myotube labels ────────────────────────────────────────────────────────
     if label_myotubes:
         for prop in measure.regionprops(myo_lab):
             r, c = prop.centroid
-            ax.text(c * scale_x, r * scale_y, f"M{prop.label}",
-                    fontsize=font_myo, color="white", ha="center", va="center",
-                    fontweight="bold",
-                    bbox=dict(boxstyle="round,pad=0.1", fc="darkred", alpha=0.6, lw=0))
+            cx = c * (orig_w / myo_lab.shape[1])
+            cy = r * (orig_h / myo_lab.shape[0])
+            ax.text(
+                cx, cy, f"M{prop.label}",
+                fontsize=font_myo,
+                color="white",
+                ha="center", va="center",
+                fontweight="bold",
+                bbox=dict(
+                    boxstyle="round,pad=0.35",
+                    fc="#8B0000",     # solid dark-red — fully opaque
+                    ec="#FF6666",     # thin bright-red border so it pops
+                    linewidth=1.5,
+                    alpha=0.95,
+                ),
+                zorder=3,
+            )
 
+    # ── legend ────────────────────────────────────────────────────────────────
     patches = [
         mpatches.Patch(color=nuc_cmap(0.7), label=f"Nuclei (n={n_nuc})"),
         mpatches.Patch(color=myo_cmap(0.7), label=f"Myotubes (n={n_myo})"),
     ]
-    ax.legend(handles=patches, loc="upper right", fontsize=max(5, orig_w // 200),
-              framealpha=0.75, facecolor="#111", labelcolor="white")
+    ax.legend(
+        handles=patches,
+        loc="upper right",
+        fontsize=13,
+        framealpha=0.85,
+        facecolor="#111111",
+        labelcolor="white",
+        edgecolor="#444444",
+    )
 
     fig.tight_layout(pad=0)
     buf = io.BytesIO()
+    # Save at same high DPI — this is what makes the PNG sharp when zoomed
     fig.savefig(buf, format="png", bbox_inches="tight", pad_inches=0, dpi=dpi)
     plt.close(fig)
     buf.seek(0)
@@ -466,6 +527,7 @@ with st.sidebar:
     st.header("Postprocessing")
     min_nuc_area     = st.number_input("Min nucleus area (px)",  0, 10000,  20, 1)
     min_myo_area     = st.number_input("Min myotube area (px)",  0, 200000, 500, 10)
+    nuc_close_radius = st.number_input("Nuclei close radius",    0, 50,     2,   1)
     myo_close_radius = st.number_input("Myotube close radius",   0, 50,     3,   1)
 
     st.header("Watershed (nuclei splitting)")
@@ -568,6 +630,7 @@ if run:
                     nuc_raw, myo_raw,
                     min_nuc_area=int(min_nuc_area),
                     min_myo_area=int(min_myo_area),
+                    nuc_close_radius=int(nuc_close_radius),
                     myo_close_radius=int(myo_close_radius),
                 )
 
@@ -576,16 +639,33 @@ if run:
                     rgb_u8, nuc_pp, myo_pp, nuc_rgb, myo_rgb, float(alpha)
                 )
 
-                # Instance overlay for display
+                # Label maps — shared across all three overlays
                 nuc_lab = label_nuclei_watershed(nuc_pp,
                                                   min_distance=int(nuc_ws_min_dist),
                                                   min_nuc_area=int(nuc_ws_min_area))
                 myo_lab = label_cc(myo_pp)
+
+                # Combined instance overlay (both nuclei + myotubes)
                 inst_ov = make_instance_overlay(rgb_u8, nuc_lab, myo_lab,
                                                 alpha=float(alpha),
                                                 label_nuclei=label_nuc,
                                                 label_myotubes=label_myo)
 
+                # Nuclei-only overlay
+                nuc_only_ov = make_instance_overlay(rgb_u8, nuc_lab,
+                                                     np.zeros_like(myo_lab),
+                                                     alpha=float(alpha),
+                                                     label_nuclei=True,
+                                                     label_myotubes=False)
+
+                # Myotubes-only overlay
+                myo_only_ov = make_instance_overlay(rgb_u8,
+                                                     np.zeros_like(nuc_lab),
+                                                     myo_lab,
+                                                     alpha=float(alpha),
+                                                     label_nuclei=False,
+                                                     label_myotubes=True)
+
                 bio = compute_bio_metrics(
                     nuc_pp, myo_pp,
                     nuc_ws_min_distance=int(nuc_ws_min_dist),
@@ -598,19 +678,23 @@ if run:
                 all_bio_metrics[name] = {**bio, "_per_myotube_areas": per_areas}
 
                 artifacts[name] = {
-                    "original" : png_bytes(rgb_u8),
-                    "overlay"  : png_bytes(inst_ov),
-                    "nuc_pp"   : png_bytes((nuc_pp * 255).astype(np.uint8)),
-                    "myo_pp"   : png_bytes((myo_pp * 255).astype(np.uint8)),
+                    "original"    : png_bytes(rgb_u8),
+                    "overlay"     : png_bytes(inst_ov),
+                    "nuc_only_ov" : png_bytes(nuc_only_ov),
+                    "myo_only_ov" : png_bytes(myo_only_ov),
+                    "nuc_pp"      : png_bytes((nuc_pp * 255).astype(np.uint8)),
+                    "myo_pp"      : png_bytes((myo_pp * 255).astype(np.uint8)),
                 }
 
                 # ZIP contents
-                zf.writestr(f"{name}/overlay.png",          png_bytes(simple_ov))
-                zf.writestr(f"{name}/instance_overlay.png", png_bytes(inst_ov))
-                zf.writestr(f"{name}/nuclei_pp.png",        artifacts[name]["nuc_pp"])
-                zf.writestr(f"{name}/myotube_pp.png",       artifacts[name]["myo_pp"])
-                zf.writestr(f"{name}/nuclei_raw.png",       png_bytes((nuc_raw*255).astype(np.uint8)))
-                zf.writestr(f"{name}/myotube_raw.png",      png_bytes((myo_raw*255).astype(np.uint8)))
+                zf.writestr(f"{name}/overlay_combined.png",  png_bytes(simple_ov))
+                zf.writestr(f"{name}/overlay_instance.png",  png_bytes(inst_ov))
+                zf.writestr(f"{name}/overlay_nuclei.png",    png_bytes(nuc_only_ov))
+                zf.writestr(f"{name}/overlay_myotubes.png",  png_bytes(myo_only_ov))
+                zf.writestr(f"{name}/nuclei_pp.png",         artifacts[name]["nuc_pp"])
+                zf.writestr(f"{name}/myotube_pp.png",        artifacts[name]["myo_pp"])
+                zf.writestr(f"{name}/nuclei_raw.png",        png_bytes((nuc_raw*255).astype(np.uint8)))
+                zf.writestr(f"{name}/myotube_raw.png",       png_bytes((myo_raw*255).astype(np.uint8)))
 
                 prog.progress((i + 1) / len(uploads))
 
@@ -663,13 +747,33 @@ pick  = st.selectbox("Select image", names)
 col_img, col_metrics = st.columns([3, 2], gap="large")
 
 with col_img:
-    tabs = st.tabs(["Instance overlay", "Original", "Nuclei mask", "Myotube mask"])
-    art  = st.session_state.artifacts[pick]
+    tabs = st.tabs([
+        "🔵 Combined overlay",
+        "🟣 Nuclei only",
+        "🟠 Myotubes only",
+        "📷 Original",
+        "⬜ Nuclei mask",
+        "⬜ Myotube mask",
+    ])
+    art     = st.session_state.artifacts[pick]
+    bio_cur = st.session_state.bio_metrics.get(pick, {})
     FIXED_W = 700
-    with tabs[0]: st.image(art["overlay"],  width=FIXED_W)
-    with tabs[1]: st.image(art["original"], width=FIXED_W)
-    with tabs[2]: st.image(art["nuc_pp"],   width=FIXED_W)
-    with tabs[3]: st.image(art["myo_pp"],   width=FIXED_W)
+    with tabs[0]:
+        st.image(art["overlay"], width=FIXED_W)
+    with tabs[1]:
+        n_nuc = bio_cur.get("total_nuclei", "—")
+        st.caption(f"**Nuclei count: {n_nuc}**  — each nucleus has a unique ID label")
+        st.image(art["nuc_only_ov"], width=FIXED_W)
+    with tabs[2]:
+        n_myo = bio_cur.get("myotube_count", "—")
+        st.caption(f"**Myotube count: {n_myo}**  — each myotube has a unique M-label")
+        st.image(art["myo_only_ov"], width=FIXED_W)
+    with tabs[3]:
+        st.image(art["original"], width=FIXED_W)
+    with tabs[4]:
+        st.image(art["nuc_pp"],   width=FIXED_W)
+    with tabs[5]:
+        st.image(art["myo_pp"],   width=FIXED_W)
 
 with col_metrics:
     st.markdown("#### 📊 Live metrics")