Upload app.py

app.py

@@ -805,6 +805,28 @@ def run_viability(stored_masks, stored_image_np):
         return None, 0, 0, 0.0, f"Error: {str(e)}", {}
 
 
+# Hemocytometer: cells/mL = cells per large square x 10,000 x dilution factor.
+# Counting one large square, so the two presets below fold the 10,000 chamber
+# constant and the dilution together into a single multiplier.
+CONC_PRESETS = (
+    ("1:1 dilution (2x, trypan blue)", 20_000),
+    ("1:10 dilution (10x, trypan blue)", 100_000),
+)
+
+
+def format_concentration(live_cells, multiplier):
+    """Human-readable concentration, showing the arithmetic for the lab record."""
+    try:
+        live = int(live_cells or 0)
+    except (TypeError, ValueError):
+        return ""
+    conc = live * multiplier
+    return (f"Live cells: {live:,}\n"
+            f"x {multiplier:,}\n"
+            f"= {conc:,} cells/mL\n"
+            f"= {conc / 1e6:.2f} x 10^6 cells/mL")
+
+
 def pack_array(arr):
     """
     Serialise an array for gr.State.
@@ -828,41 +850,80 @@ def unpack_array(data):
         return np.array(Image.open(buf))
 
 
-def save_tab_result(cell_count, confluency, viab_percent):
+def save_tab_result(cell_count, confluency, viab_percent, live_cells, dead_cells):
     """Package per-tab results into a dict for Tab 5 summary."""
+    def _f(v):
+        try:
+            return float(v) if v is not None else None
+        except (TypeError, ValueError):
+            return None
     return {
-        "cell_count": float(cell_count) if cell_count is not None else None,
-        "confluency": float(confluency) if confluency is not None else None,
-        "viab_percent": float(viab_percent) if viab_percent is not None else None,
+        "cell_count": _f(cell_count),
+        "confluency": _f(confluency),
+        "viab_percent": _f(viab_percent),
+        "live": _f(live_cells),
+        "dead": _f(dead_cells),
     }
 
 
 def compute_summary(r1, r2, r3, r4):
-    """Average cell count, confluency, and viability across tabs that have data."""
+    """Per-tab counts, their averages, and concentrations from those averages.
+
+    Standard hemocytometer practice is to count the four corner squares, average
+    them, then multiply by the chamber constant and the dilution factor -- so the
+    averaging happens BEFORE the multiplication, not after.
+    """
     all_results = [r1, r2, r3, r4]
     valid = [(i + 1, r) for i, r in enumerate(all_results)
              if r is not None and r.get("cell_count") is not None]
 
     if not valid:
-        return (
-            0.0, 0.0, 0.0,
-            "No data yet — run segmentation in at least one tab, then click Refresh Summary."
+        msg = ("No data yet — run segmentation in at least one tab, "
+               "then click Refresh Summary.")
+        return 0.0, 0.0, 0.0, msg, "", ""
+
+    n = len(valid)
+
+    def _avg(key):
+        vals = [r.get(key) for _, r in valid if r.get(key) is not None]
+        return (sum(vals) / len(vals)) if vals else 0.0
+
+    avg_count = _avg("cell_count")
+    avg_conf  = _avg("confluency")
+    avg_viab  = _avg("viab_percent")
+    avg_live  = _avg("live")
+    avg_dead  = _avg("dead")
+
+    header = f"{'Tab':<6}{'Total':>8}{'Live':>8}{'Dead':>8}{'Viab %':>9}{'Confl %':>9}"
+    lines = [header, "-" * len(header)]
+    for tab_num, r in valid:
+        lines.append(
+            f"{tab_num:<6}"
+            f"{(r.get('cell_count') or 0):>8.0f}"
+            f"{(r.get('live') or 0):>8.0f}"
+            f"{(r.get('dead') or 0):>8.0f}"
+            f"{(r.get('viab_percent') or 0):>9.1f}"
+            f"{(r.get('confluency') or 0):>9.1f}"
         )
-
-    avg_count  = sum(r["cell_count"]   for _, r in valid) / len(valid)
-    avg_conf   = sum(r["confluency"]   for _, r in valid) / len(valid)
-    avg_viab   = sum(r["viab_percent"] for _, r in valid) / len(valid)
-
-    lines = [f"Tab {tab_num}: {r['cell_count']:.0f} cells | "
-             f"{r['confluency']:.1f}% confluency | "
-             f"{r['viab_percent']:.1f}% viability"
-             for tab_num, r in valid]
-    lines.append(f"\nAverages ({len(valid)} tab{'s' if len(valid) > 1 else ''}):")
-    lines.append(f"  Cell count:  {avg_count:.1f}")
-    lines.append(f"  Confluency:  {avg_conf:.1f}%")
-    lines.append(f"  Viability:   {avg_viab:.1f}%")
-
-    return avg_count, avg_conf, avg_viab, "\n".join(lines)
+    lines.append("-" * len(header))
+    lines.append(f"{'Mean':<6}{avg_count:>8.1f}{avg_live:>8.1f}{avg_dead:>8.1f}"
+                 f"{avg_viab:>9.1f}{avg_conf:>9.1f}")
+    lines.append("")
+    lines.append(f"Averaged over {n} tab{'s' if n > 1 else ''}"
+                 + ("" if n == 4 else f"  ⚠ hemocytometer convention uses all 4 squares"))
+
+    def _block(multiplier):
+        return (f"Mean of {n} tab{'s' if n > 1 else ''}, x {multiplier:,}\n"
+                f"\n"
+                f"Live:  {avg_live:.1f} -> {avg_live * multiplier:,.0f} cells/mL\n"
+                f"       ({avg_live * multiplier / 1e6:.2f} x 10^6)\n"
+                f"Dead:  {avg_dead:.1f} -> {avg_dead * multiplier:,.0f} cells/mL\n"
+                f"       ({avg_dead * multiplier / 1e6:.2f} x 10^6)\n"
+                f"Total: {avg_count:.1f} -> {avg_count * multiplier:,.0f} cells/mL\n"
+                f"       ({avg_count * multiplier / 1e6:.2f} x 10^6)")
+
+    return (avg_count, avg_conf, avg_viab, "\n".join(lines),
+            _block(CONC_PRESETS[0][1]), _block(CONC_PRESETS[1][1]))
 
 
 # ---------------------------------------------------------------------------
@@ -1444,7 +1505,16 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
             viab_overlay     = gr.Image(type="pil", label="Viability (Green=Live · Red=Dead)")
             viab_percent_out = gr.Number(label="Viability (%)", precision=1)
-            viab_info        = gr.Textbox(label="Analysis Results", lines=4)
+            with gr.Row():
+                viab_info = gr.Textbox(label="Analysis Results", lines=5)
+                conc_1_1 = gr.Textbox(
+                    label=f"Concentration — {CONC_PRESETS[0][0]}",
+                    lines=5, interactive=False,
+                )
+                conc_1_10 = gr.Textbox(
+                    label=f"Concentration — {CONC_PRESETS[1][0]}",
+                    lines=5, interactive=False,
+                )
 
             gr.Markdown("### Label Correction & Export")
             gr.Markdown(
@@ -1617,6 +1687,30 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             outputs=[crop_display, crop_points_state, zoom_state, crop_status,
                      cancel_zoom_btn])
 
+
+        # ---- Viability ------------------------------------------------------
+        def on_run_viability(stored_masks, stored_image):
+            overlay, alive, dead, viab_pct, info, label_map = run_viability(
+                stored_masks, stored_image)
+            return (overlay, alive, dead, viab_pct, info, label_map,
+                    format_concentration(alive, CONC_PRESETS[0][1]),
+                    format_concentration(alive, CONC_PRESETS[1][1]))
+
+        viab_outputs = [viab_overlay, live_count_out, dead_count_out,
+                        viab_percent_out, viab_info, label_map_state,
+                        conc_1_1, conc_1_10]
+
+        viab_run_btn.click(
+            fn=on_run_viability,
+            inputs=[masks_state, image_state],
+            outputs=viab_outputs
+        ).then(
+            fn=save_tab_result,
+            inputs=[cell_count_out, confluency_out, viab_percent_out,
+                    live_count_out, dead_count_out],
+            outputs=[result_state]
+        )
+
         segment_btn.click(
             fn=run_segmentation,
             inputs=[img_input, model_dropdown, min_size_slider, max_size_slider,
@@ -1625,21 +1719,17 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             outputs=[cell_count_out, overlay_out, info_out, viability_section,
                      masks_state, image_state, confluency_out,
                      min_size_recommendation, raw_image_state, base_masks_state]
-        )
-
-        # ---- Run Viability button -------------------------------------------
-        def on_run_viability(stored_masks, stored_image):
-            overlay, alive, dead, viab_pct, info, label_map = run_viability(stored_masks, stored_image)
-            return overlay, alive, dead, viab_pct, info, label_map
-
-        viab_run_btn.click(
+        ).then(
+            # Viability is wanted on essentially every run, so do it without a
+            # second button press. The button stays for re-running after the
+            # exclusion sliders or the label corrections change.
             fn=on_run_viability,
             inputs=[masks_state, image_state],
-            outputs=[viab_overlay, live_count_out, dead_count_out,
-                     viab_percent_out, viab_info, label_map_state]
+            outputs=viab_outputs
         ).then(
             fn=save_tab_result,
-            inputs=[cell_count_out, confluency_out, viab_percent_out],
+            inputs=[cell_count_out, confluency_out, viab_percent_out,
+                    live_count_out, dead_count_out],
             outputs=[result_state]
         )
 
@@ -1749,12 +1839,24 @@ with gr.Blocks(
             avg_conf_out  = gr.Number(label="Avg Confluency (%)",  precision=1)
             avg_viab_out  = gr.Number(label="Avg Viability (%)",   precision=1)
 
-        summary_box = gr.Textbox(label="Per-Tab Breakdown", lines=10)
+        summary_box = gr.Textbox(label="Per-Tab Breakdown", lines=11)
+
+        gr.Markdown("### Cell Concentration (from the mean across tabs)")
+        with gr.Row():
+            summary_conc_2x = gr.Textbox(
+                label=f"Concentration — {CONC_PRESETS[0][0]}",
+                lines=8, interactive=False,
+            )
+            summary_conc_10x = gr.Textbox(
+                label=f"Concentration — {CONC_PRESETS[1][0]}",
+                lines=8, interactive=False,
+            )
 
         refresh_btn.click(
             fn=compute_summary,
             inputs=result_states,   # list of 4 gr.State components
-            outputs=[avg_count_out, avg_conf_out, avg_viab_out, summary_box]
+            outputs=[avg_count_out, avg_conf_out, avg_viab_out, summary_box,
+                     summary_conc_2x, summary_conc_10x]
         )