Upload 2 files

app.py

@@ -2,7 +2,6 @@ import streamlit as st
 import pandas as pd
 import matplotlib.pyplot as plt
 import zipfile
-from shapely.geometry import Polygon
 from PIL import Image
 from io import BytesIO
 from concurrent.futures import ThreadPoolExecutor
@@ -17,39 +16,51 @@ import time
 
 st.set_page_config(page_title="Scratch Assay Segmentation", layout="wide")
 
-APP_VERSION = "3.0"
+APP_VERSION = "4.0"
 DEFAULT_IMGSZ = 640
 
-# Model nomenclature aligned with the companion manuscript (Mariotto et al.,
-# Cytometry Part A 2026): Model 2 = Roboflow 3.0 Instance Segmentation Extra
-# Large with black-edge padding (Roboflow project version 24); Model 6 =
-# YOLOv11 Instance Segmentation Accurate variant with white-edge padding
-# (Roboflow project version 37). The .pt filenames are kept as the upstream
-# Roboflow version identifiers for traceability with the private model repo.
+# Public model repository. The weights are AGPL-3.0, as they derive from
+# Ultralytics YOLO11, and are downloadable without a token — the manuscript
+# claims that the exact file behind any prediction can be inspected and
+# redeployed independently, and a token-gated repository would make that false.
+HF_MODEL_REPO = "nmariotto/scratch-assay-segmentation"
+
+# Configurations M and S of the companion manuscript (Mariotto et al.,
+# Cytometry Part A). They differ ONLY in model scale; initialisation (COCO),
+# padding colour (black) and training schedule are identical. The five
+# configurations evaluated are not distinguishable in mean Average Precision,
+# so neither of these is "the accurate one": the choice is latency against
+# recall, and the labels say so.
 MODEL_OPTIONS = {
-    "Model 2": "24.pt",
-    "Model 6": "37.pt",
+    "M — default (22.4 M parameters)": "M.pt",
+    "S — fast mode (10.1 M parameters)": "S.pt",
 }
 
-# Stable, filesystem-safe key used for Drive folder names and Sheet logging.
-# Decoupled from the user-visible label so future relabeling does not affect
-# stored data.
+# Stable, filesystem-safe key for Drive folders and Sheet logging, decoupled
+# from the user-visible label so relabeling does not fragment stored data.
 MODEL_STORAGE_KEY = {
-    "Model 2": "Model_2",
-    "Model 6": "Model_6",
+    "M — default (22.4 M parameters)": "M",
+    "S — fast mode (10.1 M parameters)": "S",
+}
+
+# Measured on the held-out test set (n = 234), mean ± SD over five seeds;
+# latency is the median over 40 images on 16 CPU cores. Shown in the interface
+# so the trade-off is stated rather than discovered.
+MODEL_INFO = {
+    "M": "mAP@50 93.4 ± 1.1% · recall 78.3 ± 3.0% · ~345 ms per image on CPU",
+    "S": "mAP@50 94.0 ± 0.7% · recall 74.3 ± 2.3% · ~174 ms per image on CPU",
 }
 
 
 # =========================
-# Local model init (Hugging Face private repo)
+# Model init — public Hugging Face repository
 # =========================
 @st.cache_resource
 def load_model(model_filename):
     local_model_path = hf_hub_download(
-        repo_id=st.secrets["HF_MODEL_REPO"],
+        repo_id=HF_MODEL_REPO,
         filename=model_filename,
         repo_type="model",
-        token=st.secrets["HF_TOKEN"],
     )
     return YOLO(local_model_path)
 
@@ -74,26 +85,54 @@ sheet = sheets_client.open_by_url(st.secrets["feedback_sheet_url"]).sheet1
 # =========================
 # Helpers
 # =========================
-def calculate_polygon_area(points):
-    polygon = Polygon([(p["x"], p["y"]) for p in points])
-    return polygon.area
-
-
 def safe_predict(model, image_array, conf_threshold):
+    """Same call as the evaluation pipeline: retina_masks gives masks at the
+    original resolution instead of the model's internal 160 x 160 grid."""
     for _ in range(3):
         try:
-            results = model.predict(
+            return model.predict(
                 source=image_array,
                 imgsz=DEFAULT_IMGSZ,
                 conf=conf_threshold,
+                retina_masks=True,
                 verbose=False,
             )
-            return results
         except Exception:
             time.sleep(1)
     return None
 
 
+def mask_area_px(result, height, width):
+    """Wound area in pixels, computed exactly as in the manuscript.
+
+    The published figures come from `etapa3/predict_areas.py`, which counts the
+    pixels of the UNION of every predicted mask. Two earlier choices in this app
+    made it disagree with them:
+
+      · it kept only the highest-confidence mask, so an image whose wound is
+        split into two non-contiguous regions was under-reported. Rare (2 of the
+        234 test images) but silent;
+      · it took the shapely area of the mask POLYGON rather than counting mask
+        pixels. Measured against the pipeline over 14 test images, that
+        under-reported by 0.6% at the median and 2.3% at worst, and the error
+        grew as the wound shrank — the polygon cuts corners, and the smaller the
+        wound the larger the share of it that is boundary. It biased exactly the
+        regime the manuscript already identifies as least reliable.
+
+    Returns (area_px, n_masks, union_mask) with union_mask at (height, width).
+    """
+    if result.masks is None or len(result.masks) == 0:
+        return 0, 0, None
+    md = result.masks.data.cpu().numpy() > 0.5
+    union = np.any(md, axis=0)
+    if union.shape != (height, width):
+        import cv2
+        union = cv2.resize(
+            union.astype(np.uint8), (width, height), interpolation=cv2.INTER_NEAREST
+        ).astype(bool)
+    return int(union.sum()), int(md.shape[0]), union
+
+
 def resize_image(image):
     return image.resize((640, 640))
 
@@ -137,12 +176,26 @@ def get_image_bytes(image):
     return buf
 
 
+def sem_segmentacao(safe_name, image):
+    return {
+        "Imagem": safe_name,
+        "Área Segmentada (px²)": None,
+        "Área Segmentada (µm²)": None,
+        "Área do campo (%)": None,
+        "Regiões": 0,
+        "SemSegmentacao": True,
+        "Exibir": image,
+        "Original": get_image_bytes(image),
+        "Segmentada": None,
+        "Contorno": None,
+    }
+
+
 def process_image(uploaded_file, model, model_confidence, fov_um=None, pixel_size_um=None):
     try:
         safe_name = uploaded_file.name.replace(" ", "_")
         image = Image.open(uploaded_file).convert("RGB")
         image_np = np.array(image)
-
         width_px, height_px = image.size
 
         effective_pixel_size_um = None
@@ -151,92 +204,58 @@ def process_image(uploaded_file, model, model_confidence, fov_um=None, pixel_siz
         elif fov_um is not None and fov_um > 0:
             effective_pixel_size_um = fov_um / float(width_px)
 
-        conf_threshold = model_confidence / 100.0
-        results = safe_predict(model, image_np, conf_threshold)
-
+        results = safe_predict(model, image_np, model_confidence / 100.0)
         if not results or len(results) == 0:
-            return {
-                "Imagem": safe_name,
-                "Área Segmentada (px²)": None,
-                "Área Segmentada (µm²)": None,
-                "SemSegmentacao": True,
-                "Exibir": image,
-                "Original": get_image_bytes(image),
-                "Segmentada": None,
-                "Poligono": None,
-            }
+            return sem_segmentacao(safe_name, image)
 
         result = results[0]
-
-        if result.masks is None or len(result.masks.xyn) == 0:
-            return {
-                "Imagem": safe_name,
-                "Área Segmentada (px²)": None,
-                "Área Segmentada (µm²)": None,
-                "SemSegmentacao": True,
-                "Exibir": image,
-                "Original": get_image_bytes(image),
-                "Segmentada": None,
-                "Poligono": None,
-            }
-
-        best_idx = 0
-        if result.boxes is not None and result.boxes.conf is not None and len(result.boxes.conf) > 0:
-            best_idx = int(result.boxes.conf.argmax().item())
-
-        contour_norm = result.masks.xyn[best_idx]
-        if contour_norm is None or len(contour_norm) < 3:
-            return {
-                "Imagem": safe_name,
-                "Área Segmentada (px²)": None,
-                "Área Segmentada (µm²)": None,
-                "SemSegmentacao": True,
-                "Exibir": image,
-                "Original": get_image_bytes(image),
-                "Segmentada": None,
-                "Poligono": None,
-            }
-
-        points = [
-            {"x": float(x * width_px), "y": float(y * height_px)}
-            for x, y in contour_norm
-        ]
-
-        area_px2 = calculate_polygon_area(points)
+        area_px2, n_masks, union = mask_area_px(result, height_px, width_px)
+        if area_px2 == 0 or union is None:
+            return sem_segmentacao(safe_name, image)
 
         area_um2 = None
         if effective_pixel_size_um is not None:
             area_um2 = area_px2 * (effective_pixel_size_um ** 2)
 
-        x = [p["x"] for p in points] + [points[0]["x"]]
-        y = [p["y"] for p in points] + [points[0]["y"]]
-
-        original_buffer = get_image_bytes(image)
+        # Overlay: every contour is drawn, so what the user sees is what was
+        # counted. The contours are for display only; the number above comes
+        # from the mask raster.
+        contornos = []
+        if result.masks is not None and result.masks.xyn is not None:
+            for c in result.masks.xyn:
+                if c is not None and len(c) >= 3:
+                    contornos.append(
+                        [[float(x * width_px) for x, _ in c] + [float(c[0][0] * width_px)],
+                         [float(y * height_px) for _, y in c] + [float(c[0][1] * height_px)]]
+                    )
 
         segmented_buffer = BytesIO()
         fig, ax = plt.subplots(figsize=(6, 6), dpi=300)
         ax.imshow(image)
-        ax.plot(x, y, color="red", linewidth=2)
+        for xs, ys in contornos:
+            ax.plot(xs, ys, color="red", linewidth=2)
         ax.axis("off")
         plt.savefig(segmented_buffer, format="png", bbox_inches="tight", pad_inches=0)
-        plt.close()
+        plt.close(fig)
 
-        polygon_buffer = BytesIO()
-        fig2, ax2 = plt.subplots(figsize=(6, 6), dpi=300)
-        ax2.plot(x, y, "r-", linewidth=2)
-        ax2.scatter(x, y, color="red", s=5)
-        ax2.set_title("Polygon contour")
-        ax2.grid(True)
-        plt.savefig(polygon_buffer, format="png", bbox_inches="tight")
-        plt.close()
+        # Contour coordinates as data, in place of the polygon picture that used
+        # to be shown. A CSV of vertices can be re-plotted or re-measured; a PNG
+        # of the same polygon cannot.
+        linhas = ["region,vertex,x_px,y_px"]
+        for i, (xs, ys) in enumerate(contornos, start=1):
+            for j, (x, y) in enumerate(zip(xs[:-1], ys[:-1]), start=1):
+                linhas.append(f"{i},{j},{x:.2f},{y:.2f}")
+        contorno_csv = BytesIO("\n".join(linhas).encode("utf-8"))
 
         return {
             "Imagem": safe_name,
             "Área Segmentada (px²)": area_px2,
             "Área Segmentada (µm²)": area_um2,
-            "Original": original_buffer,
+            "Área do campo (%)": 100.0 * area_px2 / float(width_px * height_px),
+            "Regiões": n_masks,
+            "Original": get_image_bytes(image),
             "Segmentada": segmented_buffer,
-            "Poligono": polygon_buffer,
+            "Contorno": contorno_csv,
             "Exibir": image,
             "SemSegmentacao": False,
         }
@@ -250,12 +269,8 @@ def save_feedback(result, avaliacao, observacao, selected_model_label):
     image_base_name = image_name.rsplit(".", 1)[0]
     storage_key = MODEL_STORAGE_KEY[selected_model_label]
 
-    # 1) Sheet - store the stable storage key (Model_2 / Model_6) rather than
-    # the user-visible label, so the spreadsheet stays clean across future
-    # label tweaks.
     sheet.append_row([image_name, avaliacao, observacao, storage_key, APP_VERSION])
 
-    # 2) Drive curation
     if avaliacao in ["Acceptable", "Bad", "No segmentation"]:
         sufixo = (
             "aceitavel" if avaliacao == "Acceptable"
@@ -273,30 +288,36 @@ def save_feedback(result, avaliacao, observacao, selected_model_label):
         buf.seek(0)
         upload_to_drive(buf, f"original_{storage_key}_v{APP_VERSION}_{sufixo}.png", subfolder)
 
-        if avaliacao != "No segmentation" and result.get("Segmentada") and result.get("Poligono"):
+        if avaliacao != "No segmentation" and result.get("Segmentada"):
             resized_segmented = resize_image(Image.open(BytesIO(result["Segmentada"].getvalue())))
-            resized_polygon = resize_image(Image.open(BytesIO(result["Poligono"].getvalue())))
-
-            for img_obj, nome in zip([resized_segmented, resized_polygon], ["segmentada", "poligono"]):
-                buf = BytesIO()
-                img_obj.save(buf, format="PNG")
-                buf.seek(0)
-                upload_to_drive(
-                    buf,
-                    f"{nome}_{storage_key}_v{APP_VERSION}_{sufixo}.png",
-                    subfolder,
-                )
+            buf = BytesIO()
+            resized_segmented.save(buf, format="PNG")
+            buf.seek(0)
+            upload_to_drive(
+                buf, f"segmentada_{storage_key}_v{APP_VERSION}_{sufixo}.png", subfolder
+            )
 
 
 def render_metrics(result):
     area_px2 = result["Área Segmentada (px²)"]
     area_um2 = result["Área Segmentada (µm²)"]
+    area_pct = result["Área do campo (%)"]
 
     st.markdown("**Segmented area**")
     if area_px2 is not None:
-        st.markdown(f"- {area_px2:.2f} px²")
+        st.markdown(f"- {area_px2:,.0f} px²")
     if area_um2 is not None:
-        st.markdown(f"- {area_um2:.2f} µm²")
+        st.markdown(f"- {area_um2:,.2f} µm²")
+    if area_pct is not None:
+        st.markdown(f"- {area_pct:.2f}% of the field")
+        if area_pct < 5.0:
+            st.warning(
+                "The remaining gap is below 5% of the field. In the validation "
+                "study, agreement with manual measurement degrades in this "
+                "regime; treat this value as the least reliable point of a series."
+            )
+    if result.get("Regiões", 0) > 1:
+        st.caption(f"{result['Regiões']} disconnected regions; the area is their union.")
 
 
 def render_feedback_block(result, selected_model_label, prefix_key=""):
@@ -336,11 +357,14 @@ with col_input_2:
     selected_model_label = st.selectbox("Segmentation model", list(MODEL_OPTIONS.keys()), index=0)
 
 model = load_model(MODEL_OPTIONS[selected_model_label])
-
-st.caption(f"Selected model: {selected_model_label}")
+st.caption(MODEL_INFO[MODEL_STORAGE_KEY[selected_model_label]])
 
 with st.expander("⚙️ Advanced Settings", expanded=False):
     model_confidence = st.slider("Model confidence (%)", 20, 100, 80)
+    st.caption(
+        "80% is the operating point at which the reported precision and recall "
+        "were measured."
+    )
     st.markdown(
         "### Physical calibration (optional)\n"
         "Provide the physical scale for conversion from pixel area to physical units (µm²). "
@@ -368,17 +392,31 @@ with st.sidebar:
     st.markdown("## Info")
     with st.expander("About / Citation", expanded=False):
         st.markdown(
-            """
-This tool was developed by the **Medical Physics Laboratory** of the Department of **Biophysics and Pharmacology – IBB, UNESP**.
+            f"""
+This tool was developed by the **Medical Physics Laboratory** of the Department of
+**Biophysics and Pharmacology – IBB, UNESP**.
 **FAPESP Process:** 2024/01849-4.
 **Coordination:** Prof. Allan Alves.
 **Development:** Nycolas Mariotto.
 
-Model nomenclature in this interface follows the companion manuscript
-(Mariotto et al., *Cytometry Part A*, 2026):
-- **Model 2**: Roboflow 3.0 Instance Segmentation Extra Large with black-edge padding (Roboflow project version 24).
-- **Model 6**: YOLOv11 Instance Segmentation Accurate variant with white-edge padding (Roboflow project version 37).
+The two configurations offered here are those of the companion manuscript
+(Mariotto et al., *Cytometry Part A*). They differ **only in model scale**:
+initialisation, padding and training schedule are identical.
+
+- **M** — default. {MODEL_INFO['M']}
+- **S** — fast mode. {MODEL_INFO['S']}
+
+Neither is the more accurate: across the five configurations evaluated, mean
+mAP@50 spans 93.3–94.0% and no pairwise difference is distinguishable. The choice
+is latency against recall.
 
+**What this tool is for.** Comparing conditions across many wells. Agreement with
+a careful manual measurement has 95% limits of agreement of about ±0.3 in closure
+fraction, so a single automated measurement is **not** a substitute for a single
+manual one.
+
+Weights: [{HF_MODEL_REPO}](https://huggingface.co/{HF_MODEL_REPO}) — AGPL-3.0,
+derived from Ultralytics YOLO11.
 Companion archive: Zenodo DOI [10.5281/zenodo.20298129](https://doi.org/10.5281/zenodo.20298129).
             """
         )
@@ -403,30 +441,38 @@ if upload_option == "Single image":
 
         if result:
             results.append(result)
-
             st.markdown(f"#### {result['Imagem']}")
 
             if result["SemSegmentacao"]:
                 st.image(result["Exibir"], caption="Original", use_container_width=True)
                 st.warning("No segmentation was detected for this image.")
             else:
-                col1, col2, col3 = st.columns(3)
+                col1, col2 = st.columns(2)
                 with col1:
                     st.image(result["Exibir"], caption="Original", use_container_width=True)
                 with col2:
                     st.image(result["Segmentada"], caption="Segmentation", use_container_width=True)
-                with col3:
-                    st.image(result["Poligono"], caption="Polygon", use_container_width=True)
 
                 render_metrics(result)
 
                 st.markdown("### Export")
-                st.download_button(
-                    "Download segmented overlay (PNG)",
-                    data=result["Segmentada"],
-                    file_name=f"segmented_{result['Imagem']}.png",
-                    mime="image/png",
-                )
+                e1, e2 = st.columns(2)
+                with e1:
+                    st.download_button(
+                        "Download segmented overlay (PNG)",
+                        data=result["Segmentada"],
+                        file_name=f"segmented_{result['Imagem']}.png",
+                        mime="image/png",
+                        use_container_width=True,
+                    )
+                with e2:
+                    st.download_button(
+                        "Download contour coordinates (CSV)",
+                        data=result["Contorno"],
+                        file_name=f"contour_{result['Imagem']}.csv",
+                        mime="text/csv",
+                        use_container_width=True,
+                    )
 
             st.markdown("---")
             render_feedback_block(result, selected_model_label, prefix_key="single_")
@@ -478,18 +524,20 @@ elif upload_option == "Image folder":
                     st.image(result["Exibir"], caption="Original", use_container_width=True)
                     st.warning("No segmentation was detected for this image.")
                 else:
-                    col1, col2, col3 = st.columns(3)
+                    col1, col2 = st.columns(2)
                     with col1:
                         st.image(result["Exibir"], caption="Original", use_container_width=True)
                     with col2:
                         st.image(result["Segmentada"], caption="Segmentation", use_container_width=True)
-                    with col3:
-                        st.image(result["Poligono"], caption="Polygon", use_container_width=True)
 
                     render_metrics(result)
 
-                    zip_file.writestr(f"segmentada_{result['Imagem']}.png", result["Segmentada"].getvalue())
-                    zip_file.writestr(f"poligono_{result['Imagem']}.png", result["Poligono"].getvalue())
+                    zip_file.writestr(
+                        f"segmentada_{result['Imagem']}.png", result["Segmentada"].getvalue()
+                    )
+                    zip_file.writestr(
+                        f"contorno_{result['Imagem']}.csv", result["Contorno"].getvalue()
+                    )
 
                 render_feedback_block(result, selected_model_label, prefix_key="folder_")
 
@@ -504,7 +552,7 @@ elif upload_option == "Image folder":
                     {
                         "Image": r["Imagem"],
                         "Segmented Area (px²)": (
-                            r["Área Segmentada (px²)"]
+                            f"{r['Área Segmentada (px²)']:.0f}"
                             if (not r["SemSegmentacao"] and r["Área Segmentada (px²)"] is not None)
                             else "No Segmentation"
                         ),
@@ -513,6 +561,12 @@ elif upload_option == "Image folder":
                             if (not r["SemSegmentacao"] and r["Área Segmentada (µm²)"] is not None)
                             else ""
                         ),
+                        "Field (%)": (
+                            f"{r['Área do campo (%)']:.2f}"
+                            if (not r["SemSegmentacao"] and r["Área do campo (%)"] is not None)
+                            else ""
+                        ),
+                        "Regions": r.get("Regiões", 0),
                     }
                     for r in results
                 ]
@@ -536,9 +590,9 @@ elif upload_option == "Image folder":
                 )
             with c2:
                 st.download_button(
-                    "Download segmented images (ZIP)",
+                    "Download segmented images and contours (ZIP)",
                     data=zip_images_buffer,
                     file_name="segmented_images.zip",
                     mime="application/zip",
                     use_container_width=True,
-                )
+                )

requirements.txt

@@ -2,7 +2,6 @@ streamlit
 pandas
 matplotlib
 Pillow
-shapely
 openpyxl
 google-auth
 google-api-python-client
@@ -12,4 +11,4 @@ ultralytics
 torch
 torchvision
 opencv-python-headless
-numpy
+numpy