Update app to V6

src/streamlit_app.py

@@ -39,7 +39,7 @@ import matplotlib.patches as mpatches
 from huggingface_hub import hf_hub_download
 
 import scipy.ndimage as ndi
-from skimage.morphology import remove_small_objects, disk, closing, opening
+from skimage.morphology import remove_small_objects, disk, closing, opening, binary_dilation
 from skimage import measure
 from skimage.segmentation import watershed
 from skimage.feature import peak_local_max
@@ -161,34 +161,170 @@ def compute_surface_area(myo_mask: np.ndarray, px_um: float = 1.0) -> dict:
     }
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Cytoplasm-hole nucleus classifier  (MyoFuse method, Lair et al. 2025)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def classify_nucleus_in_myotube(nuc_coords: np.ndarray,
+                                 myc_channel: np.ndarray,
+                                 myo_mask_full: np.ndarray,
+                                 ring_width: int = 6,
+                                 hole_ratio_thr: float = 0.85) -> bool:
+    """
+    Determine whether a nucleus is GENUINELY inside a myotube
+    using the cytoplasm-hole method (MyoFuse, Lair et al. 2025).
+
+    A fused nucleus inside a myotube physically displaces the cytoplasm,
+    creating a local dip (dark "hole") in the MyHC signal beneath it.
+    An unfused nucleus sitting on top of a myotube in Z does NOT create
+    this dip — its underlying MyHC signal stays bright.
+
+    Algorithm
+    ---------
+    1. Check the nucleus pixel footprint overlaps the myotube mask at all.
+       If not — definitely not fused.
+    2. Measure mean MyHC intensity under the nucleus pixels (I_nuc).
+    3. Build a ring around the nucleus (dilated - eroded footprint) clipped
+       to the myotube mask — this is the local cytoplasm reference (I_ring).
+    4. Compute hole_ratio = I_nuc / I_ring.
+       If hole_ratio < hole_ratio_thr → nucleus has created a cytoplasmic
+       hole → genuinely fused.
+       If hole_ratio ≥ hole_ratio_thr → nucleus sits on top in Z → not fused.
+
+    Parameters
+    ----------
+    nuc_coords    : (N,2) array of (row, col) pixel coords for this nucleus
+    myc_channel   : 2D float32 array of MyHC channel at FULL image resolution
+    myo_mask_full : 2D binary mask of myotubes at FULL image resolution
+    ring_width    : dilation radius (px) for the cytoplasm ring
+    hole_ratio_thr: threshold below which the nucleus is counted as fused
+                    (default 0.85, consistent with MyoFuse calibration)
+
+    Returns
+    -------
+    True if nucleus is genuinely fused (inside myotube cytoplasm)
+    """
+    rows, cols = nuc_coords[:, 0], nuc_coords[:, 1]
+    H, W = myc_channel.shape
+
+    # Step 1 — must overlap myotube mask at all
+    in_myo = myo_mask_full[rows, cols]
+    if in_myo.sum() == 0:
+        return False
+
+    # Step 2 — mean MyHC under nucleus
+    I_nuc = float(myc_channel[rows, cols].mean())
+
+    # Step 3 — build ring around nucleus footprint, clipped to myotube mask
+    nuc_footprint = np.zeros((H, W), dtype=bool)
+    nuc_footprint[rows, cols] = True
+
+    nuc_dilated = binary_dilation(nuc_footprint, footprint=disk(ring_width))
+    ring_mask   = nuc_dilated & ~nuc_footprint & myo_mask_full.astype(bool)
+
+    if ring_mask.sum() < 4:
+        # Ring too small (nucleus near edge of myotube) — fall back to overlap test
+        return in_myo.mean() >= 0.10
+
+    I_ring = float(myc_channel[ring_mask].mean())
+
+    if I_ring < 1e-6:
+        # No myotube signal at all in ring — something is wrong, use overlap
+        return in_myo.mean() >= 0.10
+
+    # Step 4 — hole ratio test
+    hole_ratio = I_nuc / I_ring
+    return hole_ratio < hole_ratio_thr
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Biological metrics  (counting + fusion + surface area)
 # ─────────────────────────────────────────────────────────────────────────────
 
 def compute_bio_metrics(nuc_mask, myo_mask,
-                        min_overlap_frac=0.1,
+                        myc_channel_full=None,
+                        min_overlap_frac=0.10,
                         nuc_ws_min_distance=3,
                         nuc_ws_min_area=6,
-                        px_um=1.0) -> dict:
+                        px_um=1.0,
+                        ring_width=6,
+                        hole_ratio_thr=0.85) -> dict:
+    """
+    Compute all biological metrics.
+
+    If myc_channel_full (the raw MyHC grayscale image at original resolution)
+    is supplied, uses the cytoplasm-hole method (MyoFuse, Lair et al. 2025)
+    to classify each nucleus — eliminates Z-stack overlap false positives and
+    gives an accurate, non-overestimated fusion index.
+
+    If myc_channel_full is None, falls back to the original pixel-overlap
+    method for backward compatibility.
+    """
     nuc_lab = label_nuclei_watershed(nuc_mask,
                                      min_distance=nuc_ws_min_distance,
                                      min_nuc_area=nuc_ws_min_area)
     myo_lab = label_cc(myo_mask)
     total   = int(nuc_lab.max())
 
+    # Resize masks/channel to the SAME space for comparison
+    # nuc_lab and myo_mask are at model resolution (e.g. 512×512).
+    # myc_channel_full is at original image resolution.
+    # We resize everything to original resolution for the cytoplasm-hole test.
+    if myc_channel_full is not None:
+        H_full, W_full = myc_channel_full.shape
+        # Resize label maps up to original resolution
+        nuc_lab_full = np.array(
+            Image.fromarray(nuc_lab.astype(np.int32))
+                 .resize((W_full, H_full), Image.NEAREST)
+        )
+        myo_mask_full = np.array(
+            Image.fromarray((myo_mask * 255).astype(np.uint8))
+                 .resize((W_full, H_full), Image.NEAREST)
+        ) > 0
+        # Normalise MyHC channel to 0-1 float
+        myc_f = myc_channel_full.astype(np.float32)
+        if myc_f.max() > 1.0:
+            myc_f = myc_f / 255.0
+    else:
+        nuc_lab_full  = nuc_lab
+        myo_mask_full = myo_mask.astype(bool)
+        myc_f         = None
+
     pos, nm = 0, {}
-    for prop in measure.regionprops(nuc_lab):
-        coords = prop.coords
-        ids    = myo_lab[coords[:, 0], coords[:, 1]]
-        ids    = ids[ids > 0]
-        if ids.size == 0:
-            continue
-        unique, counts = np.unique(ids, return_counts=True)
-        mt   = int(unique[np.argmax(counts)])
-        frac = counts.max() / len(coords)
-        if frac >= min_overlap_frac:
+    for prop in measure.regionprops(nuc_lab_full):
+        coords = prop.coords   # (N,2) in full-res space
+
+        if myc_f is not None:
+            # ── Cytoplasm-hole method (accurate, MyoFuse 2025) ────────────────
+            is_fused = classify_nucleus_in_myotube(
+                coords, myc_f, myo_mask_full,
+                ring_width=ring_width,
+                hole_ratio_thr=hole_ratio_thr,
+            )
+        else:
+            # ── Legacy pixel-overlap fallback ─────────────────────────────────
+            ids   = myo_mask_full.astype(np.uint8)[coords[:, 0], coords[:, 1]]
+            frac  = ids.sum() / max(len(coords), 1)
+            is_fused = frac >= min_overlap_frac
+
+        if is_fused:
+            # Find which myotube this nucleus belongs to (use model-res myo_lab)
+            # Scale coords back to model resolution
+            if myc_f is not None:
+                r_m = np.clip((coords[:, 0] * nuc_lab.shape[0] / H_full).astype(int),
+                              0, nuc_lab.shape[0] - 1)
+                c_m = np.clip((coords[:, 1] * nuc_lab.shape[1] / W_full).astype(int),
+                              0, nuc_lab.shape[1] - 1)
+                ids_mt = myo_lab[r_m, c_m]
+            else:
+                ids_mt = myo_lab[coords[:, 0], coords[:, 1]]
+
+            ids_mt = ids_mt[ids_mt > 0]
+            if ids_mt.size > 0:
+                unique, counts = np.unique(ids_mt, return_counts=True)
+                mt = int(unique[np.argmax(counts)])
+                nm.setdefault(mt, []).append(prop.label)
             pos += 1
-            nm.setdefault(mt, []).append(prop.label)
 
     per   = [len(v) for v in nm.values()]
     fused = sum(n for n in per if n >= 2)
@@ -209,7 +345,7 @@ def compute_bio_metrics(nuc_mask, myo_mask,
         "total_area_um2"           : sa["total_area_um2"],
         "mean_area_um2"            : sa["mean_area_um2"],
         "max_area_um2"             : sa["max_area_um2"],
-        "_per_myotube_areas"       : sa["per_myotube_areas"],  # _ prefix = kept out of CSV
+        "_per_myotube_areas"       : sa["per_myotube_areas"],
     }
 
 
@@ -235,12 +371,17 @@ def make_simple_overlay(rgb_u8, nuc_mask, myo_mask, nuc_color, myo_color, alpha)
 def make_coloured_overlay(rgb_u8: np.ndarray,
                            nuc_lab: np.ndarray,
                            myo_lab: np.ndarray,
-                           alpha: float = 0.45) -> np.ndarray:
+                           alpha: float = 0.45,
+                           nuc_color: tuple = None,
+                           myo_color: tuple = None) -> np.ndarray:
     """
     Colour the mask regions only — NO text baked in.
     Returns an RGB uint8 array at original image resolution.
-    Text labels are rendered separately as SVG so they stay
-    perfectly sharp at any zoom level.
+
+    nuc_color / myo_color: RGB tuple e.g. (0, 255, 255).
+      If None, uses per-instance colourmaps (cool / autumn).
+      If provided, uses a flat solid colour for all instances of that type —
+      this is what the sidebar colour pickers control.
     """
     orig_h, orig_w = rgb_u8.shape[:2]
     nuc_cmap = plt.cm.get_cmap("cool")
@@ -258,15 +399,24 @@ def make_coloured_overlay(rgb_u8: np.ndarray,
 
     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 myo_color is not None:
+            colour_layer = np.array(myo_color, dtype=np.float32)
+            base[mask] = (1 - alpha) * base[mask] + alpha * colour_layer
+        else:
+            myo_norm = (myo_disp / max(n_myo, 1)).astype(np.float32)
+            myo_rgba = (myo_cmap(myo_norm)[:, :, :3] * 255).astype(np.float32)
+            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]
+        if nuc_color is not None:
+            colour_layer = np.array(nuc_color, dtype=np.float32)
+            base[mask] = (1 - alpha) * base[mask] + alpha * colour_layer
+        else:
+            nuc_norm = (nuc_disp / max(n_nuc, 1)).astype(np.float32)
+            nuc_rgba = (nuc_cmap(nuc_norm)[:, :, :3] * 255).astype(np.float32)
+            base[mask] = (1 - alpha) * base[mask] + alpha * nuc_rgba[mask]
 
     return np.clip(base, 0, 255).astype(np.uint8)
 
@@ -819,6 +969,34 @@ with st.sidebar:
     thr_nuc = st.slider("Nuclei threshold",  0.05, 0.95, 0.50, 0.01)
     thr_myo = st.slider("Myotube threshold", 0.05, 0.95, 0.50, 0.01)
 
+    st.header("Fusion Index method")
+    fi_method = st.radio(
+        "FI classification method",
+        ["Cytoplasm-hole (accurate, Lair 2025)", "Pixel-overlap (legacy)"],
+        index=0,
+        help=(
+            "Cytoplasm-hole: checks for a MyHC signal dip beneath each nucleus — "
+            "eliminates false positives from nuclei sitting above/below myotubes in Z. "
+            "Pixel-overlap: legacy method that overestimates FI (Lair et al. 2025)."
+        )
+    )
+    use_hole_method = fi_method.startswith("Cytoplasm")
+    hole_ratio_thr = st.slider(
+        "Hole ratio threshold", 0.50, 0.99, 0.85, 0.01,
+        help=(
+            "A nucleus is counted as fused if its MyHC signal is less than "
+            "this fraction of the surrounding cytoplasm ring signal. "
+            "Lower = stricter (fewer nuclei counted as fused). "
+            "0.85 is the value validated by Lair et al. 2025."
+        ),
+        disabled=not use_hole_method,
+    )
+    ring_width_px = st.number_input(
+        "Cytoplasm ring width (px)", 2, 20, 6, 1,
+        help="Width of the ring around each nucleus used to measure local MyHC intensity.",
+        disabled=not use_hole_method,
+    )
+
     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)
@@ -897,11 +1075,15 @@ if run:
                     dtype=np.uint8
                 )
 
-                ch1 = get_channel(rgb_u8, src1)
-                ch2 = get_channel(rgb_u8, src2)
+                ch1 = get_channel(rgb_u8, src1)   # MyHC channel
+                ch2 = get_channel(rgb_u8, src2)   # DAPI / nuclei channel
                 if inv1: ch1 = 255 - ch1
                 if inv2: ch2 = 255 - ch2
 
+                # Keep the full-resolution MyHC channel for the cytoplasm-hole
+                # FI classifier — must be at original image resolution
+                myc_full = ch1.copy()  # uint8, original resolution
+
                 H = W = int(image_size)
                 x1 = resize_u8_to_float01(ch1, W, H, Image.BILINEAR)
                 x2 = resize_u8_to_float01(ch2, W, H, Image.BILINEAR)
@@ -951,27 +1133,29 @@ if run:
 
                 bio = compute_bio_metrics(
                     nuc_pp, myo_pp,
+                    myc_channel_full=myc_full if use_hole_method else None,
                     nuc_ws_min_distance=int(nuc_ws_min_dist),
                     nuc_ws_min_area=int(nuc_ws_min_area),
                     px_um=float(px_um),
+                    ring_width=int(ring_width_px),
+                    hole_ratio_thr=float(hole_ratio_thr),
                 )
+                bio["fi_method"] = "cytoplasm-hole" if use_hole_method else "pixel-overlap"
                 per_areas = bio.pop("_per_myotube_areas", [])
                 bio["image"] = name
                 results.append(bio)
                 all_bio_metrics[name] = {**bio, "_per_myotube_areas": per_areas}
 
-                import base64 as _b64
-                def _b64png(arr): return _b64.b64encode(png_bytes(arr)).decode()
-
                 artifacts[name] = {
-                    # raw bytes for static display / ZIP
-                    "original"       : png_bytes(rgb_u8),
+                    # raw pixel data — overlays built at display time from these
+                    "rgb_u8"         : rgb_u8,
+                    "nuc_lab"        : nuc_lab,
+                    "myo_lab"        : myo_lab,
+                    # static mask PNGs
                     "nuc_pp"         : png_bytes((nuc_pp * 255).astype(np.uint8)),
                     "myo_pp"         : png_bytes((myo_pp * 255).astype(np.uint8)),
-                    # base64 pixel images for SVG viewer (no text baked in)
-                    "inst_b64"       : _b64png(inst_px),
-                    "nuc_only_b64"   : _b64png(nuc_only_px),
-                    "myo_only_b64"   : _b64png(myo_only_px),
+                    "nuc_raw_bytes"  : png_bytes((nuc_raw*255).astype(np.uint8)),
+                    "myo_raw_bytes"  : png_bytes((myo_raw*255).astype(np.uint8)),
                     # label positions for SVG viewer
                     "label_positions": label_positions,
                     # image dimensions
@@ -979,15 +1163,15 @@ if run:
                     "img_h"          : orig_h_img,
                 }
 
-                # ZIP — flat colour PNGs (no text labels, clean for downstream use)
+                # ZIP built with current colour settings at run time
                 zf.writestr(f"{name}/overlay_combined.png",  png_bytes(simple_ov))
                 zf.writestr(f"{name}/overlay_instance.png",  png_bytes(inst_px))
                 zf.writestr(f"{name}/overlay_nuclei.png",    png_bytes(nuc_only_px))
                 zf.writestr(f"{name}/overlay_myotubes.png",  png_bytes(myo_only_px))
                 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}/nuclei_raw.png",        artifacts[name]["nuc_raw_bytes"])
+                zf.writestr(f"{name}/myotube_raw.png",       artifacts[name]["myo_raw_bytes"])
 
                 prog.progress((i + 1) / len(uploads))
 
@@ -1018,7 +1202,7 @@ st.subheader("📋 Results")
 display_cols = [c for c in st.session_state.df.columns if not c.startswith("_")]
 st.dataframe(st.session_state.df[display_cols], use_container_width=True, height=320)
 
-c1, c2 = st.columns(2)
+c1, c2, c3 = st.columns(3)
 with c1:
     st.download_button("⬇️ Download metrics.csv",
                        st.session_state.df[display_cols].to_csv(index=False).encode(),
@@ -1027,6 +1211,46 @@ with c2:
     st.download_button("⬇️ Download results.zip",
                        st.session_state.zip_bytes,
                        file_name="results.zip", mime="application/zip")
+with c3:
+    # Rebuild ZIP with CURRENT colour / alpha settings — no model rerun needed
+    if st.button("🎨 Rebuild ZIP with current colours", help=(
+        "Regenerates the overlay images in the ZIP using the current "
+        "colour picker and alpha values from the sidebar."
+    )):
+        import base64 as _b64_zip
+        new_zip_buf = io.BytesIO()
+        with zipfile.ZipFile(new_zip_buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+            for img_name, art in st.session_state.artifacts.items():
+                _r  = art["rgb_u8"]
+                _nl = art["nuc_lab"]
+                _ml = art["myo_lab"]
+                _zn = np.zeros_like(_nl)
+                _zm = np.zeros_like(_ml)
+                ov_comb = make_coloured_overlay(_r, _nl, _ml,
+                                                alpha=float(alpha),
+                                                nuc_color=nuc_rgb, myo_color=myo_rgb)
+                ov_nuc  = make_coloured_overlay(_r, _nl, _zm,
+                                                alpha=float(alpha),
+                                                nuc_color=nuc_rgb, myo_color=None)
+                ov_myo  = make_coloured_overlay(_r, _zn, _ml,
+                                                alpha=float(alpha),
+                                                nuc_color=None, myo_color=myo_rgb)
+                simple  = make_simple_overlay(_r,
+                                              (_nl > 0).astype(np.uint8),
+                                              (_ml > 0).astype(np.uint8),
+                                              nuc_rgb, myo_rgb, float(alpha))
+                zf.writestr(f"{img_name}/overlay_combined.png",  png_bytes(simple))
+                zf.writestr(f"{img_name}/overlay_instance.png",  png_bytes(ov_comb))
+                zf.writestr(f"{img_name}/overlay_nuclei.png",    png_bytes(ov_nuc))
+                zf.writestr(f"{img_name}/overlay_myotubes.png",  png_bytes(ov_myo))
+                zf.writestr(f"{img_name}/nuclei_pp.png",         art["nuc_pp"])
+                zf.writestr(f"{img_name}/myotube_pp.png",        art["myo_pp"])
+                zf.writestr(f"{img_name}/nuclei_raw.png",        art["nuc_raw_bytes"])
+                zf.writestr(f"{img_name}/myotube_raw.png",       art["myo_raw_bytes"])
+            df_cols = [c for c in st.session_state.df.columns if not c.startswith("_")]
+            zf.writestr("metrics.csv", st.session_state.df[df_cols].to_csv(index=False).encode())
+        st.session_state.zip_bytes = new_zip_buf.getvalue()
+        st.success("ZIP rebuilt with current colours. Click Download results.zip above to save.")
 
 st.divider()
 
@@ -1054,9 +1278,32 @@ with col_img:
     iw      = art["img_w"]
     ih      = art["img_h"]
 
+    # Build coloured overlays RIGHT NOW using the current sidebar colour / alpha.
+    # This means changing colour picker or alpha slider instantly updates the
+    # viewer — no rerun needed for display changes.
+    import base64 as _b64_disp
+    def _b64png_disp(arr):
+        return _b64_disp.b64encode(png_bytes(arr)).decode()
+
+    _rgb  = art["rgb_u8"]
+    _nl   = art["nuc_lab"]
+    _ml   = art["myo_lab"]
+    _zero_nuc = np.zeros_like(_nl)
+    _zero_myo = np.zeros_like(_ml)
+
+    inst_b64     = _b64png_disp(make_coloured_overlay(_rgb, _nl, _ml,
+                                  alpha=float(alpha),
+                                  nuc_color=nuc_rgb, myo_color=myo_rgb))
+    nuc_only_b64 = _b64png_disp(make_coloured_overlay(_rgb, _nl, _zero_myo,
+                                  alpha=float(alpha),
+                                  nuc_color=nuc_rgb, myo_color=None))
+    myo_only_b64 = _b64png_disp(make_coloured_overlay(_rgb, _zero_nuc, _ml,
+                                  alpha=float(alpha),
+                                  nuc_color=None, myo_color=myo_rgb))
+
     with tabs[0]:
         html_combined = make_svg_viewer(
-            art["inst_b64"], iw, ih, lpos,
+            inst_b64, iw, ih, lpos,
             show_nuclei=True, show_myotubes=True,
         )
         st.components.v1.html(html_combined, height=680, scrolling=False)
@@ -1064,7 +1311,7 @@ with col_img:
     with tabs[1]:
         nuc_only_lpos = {"nuclei": lpos["nuclei"], "myotubes": []}
         html_nuc = make_svg_viewer(
-            art["nuc_only_b64"], iw, ih, nuc_only_lpos,
+            nuc_only_b64, iw, ih, nuc_only_lpos,
             show_nuclei=True, show_myotubes=False,
         )
         st.components.v1.html(html_nuc, height=680, scrolling=False)
@@ -1072,13 +1319,13 @@ with col_img:
     with tabs[2]:
         myo_only_lpos = {"nuclei": [], "myotubes": lpos["myotubes"]}
         html_myo = make_svg_viewer(
-            art["myo_only_b64"], iw, ih, myo_only_lpos,
+            myo_only_b64, iw, ih, myo_only_lpos,
             show_nuclei=False, show_myotubes=True,
         )
         st.components.v1.html(html_myo, height=680, scrolling=False)
 
     with tabs[3]:
-        st.image(art["original"], use_container_width=True)
+        st.image(art["rgb_u8"], use_container_width=True)
     with tabs[4]:
         st.image(art["nuc_pp"],   use_container_width=True)
     with tabs[5]: