Update Streamlit app to v8 and self_train to v2

src/streamlit_app.py

@@ -4,20 +4,25 @@ MyoSight  —  Myotube & Nuclei Analyser
 ========================================
 Drop-in replacement for streamlit_app.py on Hugging Face Spaces.
 
-New features vs the original Myotube Analyzer V2:
+Features:
   ✦ Animated count-up metrics (9 counters)
   ✦ Instance overlay — nucleus IDs (1,2,3…) + myotube IDs (M1,M2…)
+  ✦ Contour outline overlay — see exactly what each detection covers
   ✦ Watershed nuclei splitting for accurate counts
   ✦ Myotube surface area (total, mean, max µm²) + per-tube bar chart
   ✦ Active learning — upload corrected masks → saved to corrections/
   ✦ Low-confidence auto-flagging → image queued for retraining
   ✦ Retraining queue status panel
   ✦ All original sidebar controls preserved
-  ✦ Myotube merging fixes (v7):
-      — myo_erode_radius: erosion before labelling breaks thin bridges (Fix 1)
-      — myo_max_area_px + myo_split_min_seeds: nucleus-seeded watershed splits
-        oversized merged regions (Fix 2+3)
-      — Validated against 57-well manual count dataset
+
+  v8 changes (validated against 57-well manual count dataset):
+  ✦ REMOVED myotube closing — was merging adjacent myotubes into single blobs
+    (caused 86% of images to undercount; r=0.245 → see validation report).
+  ✦ Unified postprocessing: opening + erode/dilate (matches training script).
+  ✦ Added aspect-ratio shape filter to reject round debris false positives.
+  ✦ Added contour outline tab per collaborator request.
+  ✦ Fixed active learning correction upload bug (art["original"] → art["rgb_u8"]).
+  ✦ Unified threshold defaults across all scripts (thr_myo=0.40, thr_nuc=0.45).
 """
 
 import io
@@ -46,7 +51,7 @@ from huggingface_hub import hf_hub_download
 import scipy.ndimage as ndi
 from skimage.morphology import remove_small_objects, disk, closing, opening, binary_dilation, binary_erosion
 from skimage import measure
-from skimage.segmentation import watershed
+from skimage.segmentation import watershed, find_boundaries
 from skimage.feature import peak_local_max
 
 
@@ -103,39 +108,68 @@ def hex_to_rgb(h: str):
 
 def postprocess_masks(nuc_mask, myo_mask,
                       min_nuc_area=20, min_myo_area=500,
-                      nuc_close_radius=2, myo_close_radius=3,
-                      myo_erode_radius=0):
+                      nuc_close_radius=2,
+                      myo_open_radius=2,
+                      myo_erode_radius=2,
+                      min_myo_aspect_ratio=0.0):
     """
     Clean up raw predicted masks.
 
-    Nuclei:   optional closing to fill gaps, then remove small objects.
-    Myotubes: closing + opening to smooth edges, optional erosion to break
-              thin bridges between touching myotubes, then remove small objects.
-
-    myo_erode_radius  — disk radius for morphological erosion applied AFTER
-                        closing/opening and BEFORE connected-components labelling.
-                        Separates adjacent/touching myotubes that would otherwise
-                        be merged into a single connected region.
-                        Start at 1–2 px; increase to 3–4 px for dense networks.
-                        Set to 0 to disable (default, preserves original behaviour).
+    v8 — unified postprocessing (matches training script):
+      Nuclei:   optional closing to fill gaps, then remove small objects.
+      Myotubes: opening (noise removal) → erode+dilate (bridge breaking) →
+                size filter → optional aspect-ratio shape filter.
+
+    NO closing for myotubes — closing merges adjacent myotubes into single
+    connected components, causing severe undercounting in dense cultures.
+    Validation showed r=0.245 with closing vs manual counts.
+
+    myo_open_radius   — disk radius for morphological opening.  Removes small
+                        noise/debris without merging separate objects.
+    myo_erode_radius  — disk radius for erode+dilate bridge-breaking.  Separates
+                        touching myotubes that share thin pixel bridges.
+                        Start at 2 px; increase for dense cultures.  Set 0 to disable.
+    min_myo_aspect_ratio — minimum major/minor axis ratio.  Myotubes are elongated
+                        (aspect > 2); round debris blobs (aspect ~1) are rejected.
+                        Set 0 to disable.  Recommended: 1.5–2.0 for sparse cultures.
     """
-    # Nuclei
+    # Nuclei — closing fills small gaps, then size filter
     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 — close → open → optional erode
-    selem   = disk(int(myo_close_radius))
-    myo_bin = closing(myo_mask.astype(bool), selem)
-    myo_bin = opening(myo_bin, selem)
+    # Myotubes — opening + erode/dilate + size filter + shape filter
+    myo_bin = myo_mask.astype(bool)
+    if int(myo_open_radius) > 0:
+        myo_bin = opening(myo_bin, disk(int(myo_open_radius)))
     if int(myo_erode_radius) > 0:
-        myo_bin = binary_erosion(myo_bin, disk(int(myo_erode_radius)))
-    myo_clean = remove_small_objects(myo_bin, min_size=int(min_myo_area)).astype(np.uint8)
+        se = disk(int(myo_erode_radius))
+        myo_bin = binary_erosion(myo_bin, se)
+        myo_bin = binary_dilation(myo_bin, se)   # re-dilate to restore size
+    myo_bin = remove_small_objects(myo_bin, min_size=int(min_myo_area))
+    if float(min_myo_aspect_ratio) > 0:
+        myo_bin = _filter_by_aspect_ratio(myo_bin, float(min_myo_aspect_ratio))
+    myo_clean = myo_bin.astype(np.uint8)
 
     return nuc_clean, myo_clean
 
 
+def _filter_by_aspect_ratio(mask_bin: np.ndarray, min_aspect: float) -> np.ndarray:
+    """Keep only regions with major/minor axis ratio >= min_aspect."""
+    lab, _ = ndi.label(mask_bin.astype(np.uint8))
+    keep = np.zeros_like(mask_bin, dtype=bool)
+    for prop in measure.regionprops(lab):
+        if prop.minor_axis_length > 0:
+            aspect = prop.major_axis_length / prop.minor_axis_length
+            if aspect >= min_aspect:
+                keep[lab == prop.label] = True
+        else:
+            # Degenerate (line-like) — keep it (very elongated)
+            keep[lab == prop.label] = True
+    return keep
+
+
 def label_cc(mask: np.ndarray) -> np.ndarray:
     lab, _ = ndi.label(mask.astype(np.uint8))
     return lab
@@ -521,6 +555,45 @@ def make_coloured_overlay(rgb_u8: np.ndarray,
     return np.clip(base, 0, 255).astype(np.uint8)
 
 
+def make_outline_overlay(rgb_u8: np.ndarray,
+                          nuc_lab: np.ndarray,
+                          myo_lab: np.ndarray,
+                          nuc_color: tuple = (0, 255, 255),
+                          myo_color: tuple = (0, 255, 0),
+                          line_width: int = 2) -> np.ndarray:
+    """
+    Draw contour outlines around each detected instance on the original image.
+    Shows exactly what the model considers each myotube/nucleus boundary.
+    """
+    orig_h, orig_w = rgb_u8.shape[:2]
+
+    def _resize_lab(lab, h, w):
+        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)
+
+    out = rgb_u8.copy()
+
+    # Myotube outlines
+    if myo_disp.max() > 0:
+        myo_bounds = find_boundaries(myo_disp, mode='outer')
+        if line_width > 1:
+            myo_bounds = binary_dilation(myo_bounds, footprint=disk(line_width - 1))
+        out[myo_bounds] = myo_color
+
+    # Nuclei outlines
+    if nuc_disp.max() > 0:
+        nuc_bounds = find_boundaries(nuc_disp, mode='outer')
+        if line_width > 1:
+            nuc_bounds = binary_dilation(nuc_bounds, footprint=disk(max(line_width - 2, 0)))
+        out[nuc_bounds] = nuc_color
+
+    return out
+
+
 def collect_label_positions(nuc_lab: np.ndarray,
                              myo_lab: np.ndarray,
                              img_w: int, img_h: int) -> dict:
@@ -1066,8 +1139,8 @@ with st.sidebar:
                                   options=[256, 384, 512, 640, 768, 1024], value=512)
 
     st.header("Thresholds")
-    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)
+    thr_nuc = st.slider("Nuclei threshold",  0.05, 0.95, 0.45, 0.01)
+    thr_myo = st.slider("Myotube threshold", 0.05, 0.95, 0.40, 0.01)
 
     st.header("Fusion Index method")
     fi_method = st.radio(
@@ -1101,41 +1174,47 @@ with st.sidebar:
     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)
+    myo_open_radius  = st.number_input("Myotube open radius",    0, 50,     2,   1,
+        help="Opening removes small noise without merging separate myotubes. "
+             "Replaces the old closing radius which was merging adjacent myotubes.")
 
-    st.header("Myotube splitting (fix merging)")
+    st.header("Myotube separation")
     st.caption(
-        "Validation showed MyoSight merges touching/branching myotubes into "
-        "single objects, under-counting by ~50–90% in dense cultures. "
-        "These three controls correct that."
+        "These controls break apart touching/bridged myotubes that would "
+        "otherwise be counted as a single object."
     )
     myo_erode_radius = st.number_input(
         "Myotube erode radius (px)", 0, 15, 2, 1,
         help=(
-            "Erodes the myotube mask before labelling to break thin bridges "
-            "between adjacent touching myotubes. Start at 2 px; increase to "
-            "3-4 px for very dense/mature cultures. Set 0 to disable. "
-            "This is Fix 1 — the fastest and most impactful change."
+            "Erode + re-dilate breaks thin pixel bridges between adjacent "
+            "myotubes while preserving their overall size. "
+            "Start at 2 px; increase to 3–4 px for very dense cultures. "
+            "Set 0 to disable."
+        )
+    )
+    min_myo_aspect_ratio = st.number_input(
+        "Min myotube aspect ratio", 0.0, 10.0, 0.0, 0.1,
+        help=(
+            "Rejects round blobs (debris/artifacts) that are not real myotubes. "
+            "Myotubes are elongated (aspect ratio > 3). Round objects have ~1. "
+            "Set to 1.5–2.0 to filter false positives in sparse cultures. "
+            "Set to 0 to disable (default)."
         )
     )
     myo_max_area_px = st.number_input(
-        "Max myotube area before split (px²)", 0, 500000, 8000, 500,
+        "Max myotube area before split (px²)", 0, 500000, 20000, 500,
         help=(
-            "Any connected myotube region larger than this is treated as a merged "
-            "network and split using nucleus-seeded watershed (Fix 2+3). "
-            "Rule of thumb: set to ~(expected nuc/myo) x (avg nucleus area px2) x 3. "
-            "With ~5 nuc/myo and ~300 px nuclei, try 8000-15000 px2. "
-            "Set to 0 to disable automatic splitting."
+            "Any connected myotube region larger than this is split using "
+            "nucleus-seeded watershed. Set to 0 to disable. "
+            "Increase for cultures with legitimately large single myotubes."
         )
     )
     myo_split_min_seeds = st.number_input(
-        "Min nuclei seeds to split", 2, 20, 3, 1,
+        "Min nuclei seeds to split", 2, 20, 2, 1,
         help=(
-            "A merged region needs at least this many nucleus centroids inside "
-            "it before watershed splitting is attempted. Prevents over-splitting "
-            "of legitimately large single myotubes. "
-            "Increase if single large myotubes are being incorrectly split. "
-            "Decrease if merged regions with few nuclei are being missed."
+            "Minimum nucleus centroids required before splitting a large region. "
+            "Set to 2 to split merged pairs; increase if single large myotubes "
+            "are being incorrectly split."
         )
     )
 
@@ -1244,8 +1323,9 @@ if run:
                     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),
+                    myo_open_radius=int(myo_open_radius),
                     myo_erode_radius=int(myo_erode_radius),
+                    min_myo_aspect_ratio=float(min_myo_aspect_ratio),
                 )
 
                 # Flat overlay for ZIP (no labels — just colour regions)
@@ -1297,6 +1377,9 @@ if run:
                     "rgb_u8"         : rgb_u8,
                     "nuc_lab"        : nuc_lab,
                     "myo_lab"        : myo_lab,
+                    # postprocessed masks (for outline generation)
+                    "nuc_pp_arr"     : nuc_pp,
+                    "myo_pp_arr"     : myo_pp,
                     # static mask PNGs
                     "nuc_pp"         : png_bytes((nuc_pp * 255).astype(np.uint8)),
                     "myo_pp"         : png_bytes((myo_pp * 255).astype(np.uint8)),
@@ -1310,10 +1393,14 @@ if run:
                 }
 
                 # ZIP built with current colour settings at run time
+                outline_ov = make_outline_overlay(rgb_u8, nuc_lab, myo_lab,
+                                                   nuc_color=nuc_rgb, myo_color=(0, 255, 0),
+                                                   line_width=2)
                 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}/overlay_outlines.png",  png_bytes(outline_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",        artifacts[name]["nuc_raw_bytes"])
@@ -1385,10 +1472,14 @@ with c3:
                                               (_nl > 0).astype(np.uint8),
                                               (_ml > 0).astype(np.uint8),
                                               nuc_rgb, myo_rgb, float(alpha))
+                outline = make_outline_overlay(_r, _nl, _ml,
+                                               nuc_color=nuc_rgb, myo_color=(0, 255, 0),
+                                               line_width=2)
                 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}/overlay_outlines.png",  png_bytes(outline))
                 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"])
@@ -1412,6 +1503,7 @@ col_img, col_metrics = st.columns([3, 2], gap="large")
 with col_img:
     tabs = st.tabs([
         "🔵 Combined",
+        "📐 Outlines",
         "🟣 Nuclei only",
         "🟠 Myotubes only",
         "📷 Original",
@@ -1455,6 +1547,21 @@ with col_img:
         st.components.v1.html(html_combined, height=680, scrolling=False)
 
     with tabs[1]:
+        # Outline overlay — shows contour boundaries around each detection
+        outline_img = make_outline_overlay(
+            _rgb, _nl, _ml,
+            nuc_color=nuc_rgb, myo_color=(0, 255, 0),
+            line_width=2,
+        )
+        outline_b64 = _b64png_disp(outline_img)
+        outline_lpos = lpos  # show both labels on outline view
+        html_outline = make_svg_viewer(
+            outline_b64, iw, ih, outline_lpos,
+            show_nuclei=label_nuc, show_myotubes=label_myo,
+        )
+        st.components.v1.html(html_outline, height=680, scrolling=False)
+
+    with tabs[2]:
         nuc_only_lpos = {"nuclei": lpos["nuclei"], "myotubes": []}
         html_nuc = make_svg_viewer(
             nuc_only_b64, iw, ih, nuc_only_lpos,
@@ -1462,7 +1569,7 @@ with col_img:
         )
         st.components.v1.html(html_nuc, height=680, scrolling=False)
 
-    with tabs[2]:
+    with tabs[3]:
         myo_only_lpos = {"nuclei": [], "myotubes": lpos["myotubes"]}
         html_myo = make_svg_viewer(
             myo_only_b64, iw, ih, myo_only_lpos,
@@ -1470,11 +1577,11 @@ with col_img:
         )
         st.components.v1.html(html_myo, height=680, scrolling=False)
 
-    with tabs[3]:
-        st.image(art["rgb_u8"], use_container_width=True)
     with tabs[4]:
-        st.image(art["nuc_pp"],   use_container_width=True)
+        st.image(art["rgb_u8"], use_container_width=True)
     with tabs[5]:
+        st.image(art["nuc_pp"],   use_container_width=True)
+    with tabs[6]:
         st.image(art["myo_pp"],   use_container_width=True)
 
 with col_metrics:
@@ -1550,8 +1657,7 @@ if enable_al:
         if corr_nuc is None or corr_myo is None:
             st.error("Please upload BOTH a nuclei mask and a myotube mask.")
         else:
-            orig_bytes = st.session_state.artifacts[al_pick]["original"]
-            orig_rgb   = np.array(Image.open(io.BytesIO(orig_bytes)).convert("RGB"))
+            orig_rgb   = st.session_state.artifacts[al_pick]["rgb_u8"]
             nuc_arr    = (np.array(Image.open(corr_nuc).convert("L")) > 0).astype(np.uint8)
             myo_arr    = (np.array(Image.open(corr_myo).convert("L")) > 0).astype(np.uint8)
             add_to_queue(orig_rgb, nuc_mask=nuc_arr, myo_mask=myo_arr,