Update app.py

app.py

@@ -1,48 +1,30 @@
-"""Gradio app for cell fluorescence quantification.
-
-Upload one or more fluorescence images (blue = DAPI / nuclei,
-red = cytoplasmic marker). The app automatically detects up to N cells
-per image, draws the two concentric outlines (outer = cell, inner =
-nucleus), and reports per-cell measurements:
-    - Total cell area     = nucleus + surrounding cytoplasm pixels
-    - Nucleus area
-    - Cytoplasm area      = Cell area - Nucleus area
-    - Total Cell IntDen   = sum of red-channel intensity in the cell
-    - Nucleus IntDen      = sum of red-channel intensity in the nucleus
-    - Cytoplasm IntDen    = Cell IntDen - Nucleus IntDen
-    - Mean Cytoplasm Fluorescence = Cytoplasm IntDen / Cytoplasm area
+"""Gradio app: detect cells in a fluorescence image and return red-channel
+grayscale images with cell + nucleus outlines drawn in yellow.
+
+One output image is produced per detected cell, matching the documentation
+style: grayscale background + two concentric yellow outlines, nothing else.
 """
 from __future__ import annotations
 
-import io
 import os
-import tempfile
 
+import cv2
 import gradio as gr
 import numpy as np
-import pandas as pd
 from PIL import Image
 
-from quantification import analyze_image, cells_to_records, draw_overlay
+from quantification import analyze_image
 
 DEFAULT_N_CELLS = 5
 DEFAULT_DILATION_RADIUS = 12
+OUTLINE_COLOR_BGR_AS_RGB = (255, 255, 0)  # yellow in RGB
+OUTLINE_THICKNESS = 2
 
-COLUMN_ORDER = [
-    "Image",
-    "Cell",
-    "Total cell area",
-    "Nucleus area",
-    "Cytoplasm area",
-    "Total Cell IntDen",
-    "Nucleus IntDen",
-    "Cytoplasm IntDen",
-    "Mean Cytoplasm Fluorescence",
-]
+EXAMPLES_DIR = os.path.join(os.path.dirname(__file__), "examples")
+DEFAULT_EXAMPLE = os.path.join(EXAMPLES_DIR, "Picture1.jpg")
 
 
 def _ensure_rgb(arr: np.ndarray) -> np.ndarray:
-    """Make sure we have a uint8 RGB array."""
     if arr.ndim == 2:
         arr = np.stack([arr, arr, arr], axis=-1)
     if arr.shape[2] == 4:
@@ -52,111 +34,71 @@ def _ensure_rgb(arr: np.ndarray) -> np.ndarray:
     return arr
 
 
-def process_files(
-    files: list[str] | None,
-    n_cells: int,
-    dilation_radius: int,
-):
-    """Run the pipeline on each uploaded image and return UI outputs."""
-    if not files:
-        return [], pd.DataFrame(columns=COLUMN_ORDER), None, "Upload one or more images to begin."
-
-    gallery_items: list[tuple[np.ndarray, str]] = []
-    all_rows: list[dict] = []
-
-    for file_path in files:
-        try:
-            image_pil = Image.open(file_path).convert("RGB")
-        except Exception as exc:  # noqa: BLE001
-            gallery_items.append((
-                np.zeros((200, 200, 3), dtype=np.uint8),
-                f"{os.path.basename(file_path)} (failed: {exc})",
-            ))
-            continue
-
-        image_rgb = _ensure_rgb(np.array(image_pil))
-        image_name = os.path.basename(file_path)
-
-        cells = analyze_image(
-            image_rgb,
-            n_cells=int(n_cells),
-            dilation_radius=int(dilation_radius),
-        )
-        annotated = draw_overlay(image_rgb, cells)
-        gallery_items.append((annotated, f"{image_name} — {len(cells)} cell(s) detected"))
-
-        for row in cells_to_records(cells):
-            row_with_image = {"Image": image_name, **row}
-            all_rows.append(row_with_image)
-
-    if not all_rows:
-        df = pd.DataFrame(columns=COLUMN_ORDER)
-    else:
-        df = pd.DataFrame(all_rows)
-        df = df[COLUMN_ORDER]
-
-    # Build a downloadable Excel/CSV file
-    csv_path = None
-    if not df.empty:
-        tmp_dir = tempfile.mkdtemp(prefix="cellquant_")
-        csv_path = os.path.join(tmp_dir, "cell_quantification.csv")
-        df.to_csv(csv_path, index=False)
-
-    n_images = len(files)
-    n_cells_detected = len(all_rows)
-    if n_cells_detected == 0:
-        status = (
-            f"Processed {n_images} image(s) but no cells were detected. "
-            "Check that the image has a clear blue nucleus channel."
+def _draw_cell_outline(
+    gray_rgb: np.ndarray,
+    cell_mask: np.ndarray,
+    nucleus_mask: np.ndarray,
+) -> np.ndarray:
+    """Draw the outer (cell) and inner (nucleus) outlines on a copy of `gray_rgb`."""
+    out = gray_rgb.copy()
+    for mask in (cell_mask, nucleus_mask):
+        contours, _ = cv2.findContours(
+            mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
         )
-    else:
-        avg = df["Mean Cytoplasm Fluorescence"].mean()
-        status = (
-            f"Processed {n_images} image(s) — detected {n_cells_detected} cell(s) total. "
-            f"Average Mean Cytoplasm Fluorescence across all cells: {avg:.2f}."
+        cv2.drawContours(
+            out, contours, -1, OUTLINE_COLOR_BGR_AS_RGB, OUTLINE_THICKNESS
         )
+    return out
 
-    return gallery_items, df, csv_path, status
 
+def process_image(image_path: str | None, n_cells: int, dilation_radius: int):
+    """Return a list of one annotated image per detected cell."""
+    if image_path is None:
+        return []
 
-def build_demo() -> gr.Blocks:
-    description = """
-# Cell Fluorescence Quantification
+    image_pil = Image.open(image_path).convert("RGB")
+    image_rgb = _ensure_rgb(np.array(image_pil))
 
-Upload fluorescence microscopy images (RGB) where:
-- **Blue** channel labels nuclei (e.g. DAPI)
-- **Red** channel labels the cytoplasmic marker to measure
+    # Background for outputs: the red channel rendered as a grayscale RGB.
+    red = image_rgb[..., 0]
+    gray_rgb = np.stack([red, red, red], axis=-1)
 
-For each image, the app automatically detects representative cells, draws
-two concentric outlines (outer = whole cell, inner = nucleus), and reports
-per-cell measurements following this protocol:
+    cells = analyze_image(
+        image_rgb,
+        n_cells=int(n_cells),
+        dilation_radius=int(dilation_radius),
+    )
 
-```
-Cytoplasm Area   = Cell Area  - Nucleus Area
-Cytoplasm IntDen = Cell IntDen - Nucleus IntDen
-Mean Cytoplasm   = Cytoplasm IntDen / Cytoplasm Area
-```
+    return [
+        _draw_cell_outline(gray_rgb, c.cell_mask, c.nucleus_mask) for c in cells
+    ]
 
-Intensities are measured in the **red** channel.
-"""
 
-    with gr.Blocks(title="Cell Fluorescence Quantification") as demo:
+def build_demo() -> gr.Blocks:
+    description = (
+        "Upload a fluorescence image (RGB: blue = nuclei, red = cytoplasm). "
+        "The app detects representative cells and returns the red channel as "
+        "grayscale with the cell + nucleus boundaries drawn in yellow — one "
+        "output image per cell."
+    )
+
+    with gr.Blocks(title="Cell Boundary Detection") as demo:
+        gr.Markdown("# Cell Boundary Detection")
         gr.Markdown(description)
 
         with gr.Row():
             with gr.Column(scale=1):
-                files_in = gr.File(
-                    label="Upload image(s) — JPG / PNG / TIFF",
-                    file_count="multiple",
-                    file_types=["image"],
+                image_in = gr.Image(
+                    label="Input image",
                     type="filepath",
+                    value=DEFAULT_EXAMPLE if os.path.exists(DEFAULT_EXAMPLE) else None,
                 )
                 n_cells_slider = gr.Slider(
                     minimum=1,
-                    maximum=15,
+                    maximum=10,
                     value=DEFAULT_N_CELLS,
                     step=1,
-                    label="Cells per image",
+                    label="Number of cells",
                 )
                 dilation_slider = gr.Slider(
                     minimum=4,
@@ -164,65 +106,54 @@ Intensities are measured in the **red** channel.
                     value=DEFAULT_DILATION_RADIUS,
                     step=1,
                     label="Cytoplasm ring thickness (pixels)",
-                    info=(
-                        "Each nucleus is dilated outward by this many pixels "
-                        "to define the cell boundary."
-                    ),
                 )
-                run_btn = gr.Button("Analyze", variant="primary")
-                status_box = gr.Markdown("")
+                run_btn = gr.Button("Detect cells", variant="primary")
 
             with gr.Column(scale=2):
                 gallery = gr.Gallery(
-                    label="Annotated images",
+                    label="Detected cells (one per image)",
                     columns=2,
-                    height=520,
+                    height=620,
                     show_label=True,
+                    object_fit="contain",
                 )
 
-        gr.Markdown("### Per-cell measurements")
-        table = gr.Dataframe(
-            headers=COLUMN_ORDER,
-            datatype=["str", "str", "number", "number", "number",
-                      "number", "number", "number", "number"],
-            wrap=True,
-            interactive=False,
-        )
-        csv_out = gr.File(label="Download results (CSV)")
-
         run_btn.click(
-            fn=process_files,
-            inputs=[files_in, n_cells_slider, dilation_slider],
-            outputs=[gallery, table, csv_out, status_box],
+            fn=process_image,
+            inputs=[image_in, n_cells_slider, dilation_slider],
+            outputs=[gallery],
         )
 
-        # Also re-run automatically when sliders change (only if files already uploaded)
-        for control in (n_cells_slider, dilation_slider):
-            control.release(
-                fn=process_files,
-                inputs=[files_in, n_cells_slider, dilation_slider],
-                outputs=[gallery, table, csv_out, status_box],
-            )
-
-        # Example images (lazy: only loaded if present in repo)
-        example_dir = os.path.join(os.path.dirname(__file__), "examples")
-        if os.path.isdir(example_dir):
+        # Example images (other defaults from prior dataset).
+        example_files = []
+        if os.path.isdir(EXAMPLES_DIR):
             example_files = sorted(
-                os.path.join(example_dir, f)
-                for f in os.listdir(example_dir)
+                os.path.join(EXAMPLES_DIR, f)
+                for f in os.listdir(EXAMPLES_DIR)
                 if f.lower().endswith((".jpg", ".jpeg", ".png", ".tif", ".tiff"))
             )
-            if example_files:
-                gr.Examples(
-                    examples=[[[p], DEFAULT_N_CELLS, DEFAULT_DILATION_RADIUS]
-                              for p in example_files],
-                    inputs=[files_in, n_cells_slider, dilation_slider],
-                    label="Example images",
-                )
+        if example_files:
+            gr.Examples(
+                examples=[[p, DEFAULT_N_CELLS, DEFAULT_DILATION_RADIUS]
+                          for p in example_files],
+                inputs=[image_in, n_cells_slider, dilation_slider],
+                outputs=[gallery],
+                fn=process_image,
+                cache_examples=False,
+                label="Example images",
+            )
+
+        # Preload outputs for the default image on app start.
+        if os.path.exists(DEFAULT_EXAMPLE):
+            demo.load(
+                fn=process_image,
+                inputs=[image_in, n_cells_slider, dilation_slider],
+                outputs=[gallery],
+            )
 
     return demo
 
 
 if __name__ == "__main__":
     demo = build_demo()
-    demo.launch()
+    demo.launch()