Deploy CellQuant

README.md

@@ -90,7 +90,10 @@ images with the v2 recipe; the peak-distance rule is post-processing only.
    single pass). `CELLQUANT_TTA=1` or `4` changes this for local runs.
 3. Click **Analyse**. You get a counts table, colour overlays and a zip with
    `counts.csv`, `objects.csv` (every nucleus and punctum with centroid, area, probabilities)
-   and `results.json`.
+   and `results.json`. The table and `counts.csv` have one row per image and eight count columns:
+   the four nucleus labels followed by their total, **All nuclei**, then the two punctum labels
+   followed by their total, **All puncta** (the same totals as in the validation table of
+   section 2; `results.json` carries them under `totals`). Each overlay caption gives the two totals.
 4. A written summary follows the counts in both sections when the Space has a `GEMINI_API_KEY`
    secret (optionally `GEMINI_MODEL`, default `gemini-4-argon`); without the key a one-line notice
    takes its place. Gemini only restates the counts in prose and comments on image quality or on

app.py

@@ -38,7 +38,7 @@ from cellquant.gemini_summary import enabled as gemini_enabled
 from cellquant.gemini_summary import summarize as gemini_summarize
 from cellquant.gemini_summary import summarize_comparison as gemini_summarize_comparison
 from cellquant.infer import Predictor
-from cellquant.labels import ALL_LABELS, LABEL_COLORS
+from cellquant.labels import COUNT_COLUMNS, LABEL_COLORS, TOTAL_NUCLEI, TOTAL_PUNCTA, count_row
 from cellquant.model import load_checkpoint
 from cellquant.postprocess import PostConfig, analyze, render_overlay, result_to_json
 from cellquant.validation import COMPARISON_HEADERS, COMPARISON_NOTE, DIFF_HEADERS, ValidationSet, compare, write_bundle
@@ -144,9 +144,12 @@ def _analyze_gpu(files, antibody_thr, cellnos_thr, min_cell_area, nostril_rule,
         overlays[name] = ov
         out_png = os.path.join(tmpdir, os.path.splitext(name)[0] + "_overlay.png")
         Image.fromarray(ov).save(out_png)
-        gallery.append((out_png, f"{name}: {res.counts['Cell, Antibody +'] + res.counts['Cell, Antibody -'] + res.counts['Cell, Nostril, Antibody +'] + res.counts['Cell, Nostril, Antibody -']} nuclei"))
-        rows.append([name] + [res.counts[lab] for lab in ALL_LABELS])
-        per_image_json[name] = {"image_size_hw": list(img.shape[:2]), **result_to_json(res)}
+        row = count_row(res.counts)
+        n_nuclei, n_puncta = row[COUNT_COLUMNS.index(TOTAL_NUCLEI)], row[COUNT_COLUMNS.index(TOTAL_PUNCTA)]
+        gallery.append((out_png, f"{name}: {n_nuclei} nuclei, {n_puncta} puncta"))
+        rows.append([name] + row)
+        per_image_json[name] = {"image_size_hw": list(img.shape[:2]), **result_to_json(res),
+                                "totals": {TOTAL_NUCLEI: n_nuclei, TOTAL_PUNCTA: n_puncta}}
         for c in res.cells:
             csv_objects.append([name, "nucleus", c["id"], c["label"], round(c["area_px"], 1), round(c["centroid_xy"][0], 1), round(c["centroid_xy"][1], 1), round(c["p_antibody"], 3), round(c["p_nostril"], 3), c["n_puncta_inside"]])
         for n_ in res.nostrils:
@@ -155,7 +158,7 @@ def _analyze_gpu(files, antibody_thr, cellnos_thr, min_cell_area, nostril_rule,
     counts_csv = os.path.join(tmpdir, "counts.csv")
     with open(counts_csv, "w", newline="") as fh:
         w = csv.writer(fh)
-        w.writerow(["image"] + list(ALL_LABELS))
+        w.writerow(["image"] + list(COUNT_COLUMNS))
         w.writerows(rows)
     objects_csv = os.path.join(tmpdir, "objects.csv")
     with open(objects_csv, "w", newline="") as fh:
@@ -187,7 +190,7 @@ def analyze_files(files, antibody_thr, cellnos_thr, min_cell_area, nostril_rule,
     _safe_progress(progress, 0.95, desc="writing the summary")
     text = None
     if gemini_enabled():
-        text = gemini_summarize([{"image": r[0], "counts": dict(zip(ALL_LABELS, r[1:]))} for r in rows],
+        text = gemini_summarize([{"image": r[0], "counts": dict(zip(COUNT_COLUMNS, r[1:]))} for r in rows],
                                 overlay=Image.open(gallery[0][0]))
     return rows, gallery, zip_path, summary + "\n\n" + _gemini_section(text)
 
@@ -295,7 +298,7 @@ def build_demo() -> gr.Blocks:
                 if examples:
                     gr.Examples(examples=[[[e]] for e in examples], inputs=[files], label="Example (512 px crop of a training image)")
             with gr.Column(scale=2):
-                table = gr.Dataframe(headers=["image"] + list(ALL_LABELS), label="Counts", interactive=False, wrap=True)
+                table = gr.Dataframe(headers=["image"] + list(COUNT_COLUMNS), label="Counts", interactive=False, wrap=True)
                 gallery = gr.Gallery(label="Overlays", columns=2, height="auto")
                 zip_out = gr.File(label="Download results (CSV + JSON + overlays)")
                 summary = gr.Markdown()

cellquant/__init__.py

@@ -3,4 +3,4 @@
 Trained on CVAT polygon annotations of 1024x1024 RGB images (blue = DAPI nuclei,
 green = antibody stain such as Iba1 or Tmem119, red = puncta).
 """
-__version__ = "1.2.3"
+__version__ = "1.2.4"

cellquant/gemini_summary.py

@@ -34,7 +34,8 @@ def _prompt(rows: list[dict]) -> str:
         "exclusive, so total nuclei = sum of the four). 'Cell, Antibody +' = nucleus with green antibody signal and no "
         "punctum; 'Cell, Antibody -' = nucleus without antibody signal and no punctum; 'Cell, Nostril, Antibody +/-' = "
         "nucleus containing a red punctum, with/without antibody signal. 'Nostril in Nucleus' = punctum inside a nucleus; "
-        "'Nostril External of Nucleus' = punctum outside nuclei.\n"
+        "'Nostril External of Nucleus' = punctum outside nuclei. 'All nuclei' and 'All puncta' are the totals of "
+        "the four nucleus categories and of the two punctum categories.\n"
         "Write a concise summary (max 150 words) for the lab notebook: restate the counts exactly as given "
         "(do not round, estimate or invent numbers), give the fraction of nuclei that are antibody positive "
         "and the fraction that contain a punctum, and mention anything in the overlay thumbnail that looks "

cellquant/labels.py

@@ -14,6 +14,12 @@ NOSTRIL_LABELS = (
 )
 ALL_LABELS = CELL_LABELS + NOSTRIL_LABELS
 
+# Columns of the per-image counts table and counts.csv (app section 1): each group of labels
+# is followed by its total, as in the validation table of section 2.
+TOTAL_NUCLEI = "All nuclei"
+TOTAL_PUNCTA = "All puncta"
+COUNT_COLUMNS = CELL_LABELS + (TOTAL_NUCLEI,) + NOSTRIL_LABELS + (TOTAL_PUNCTA,)
+
 # Display colours (RGB) used for overlays, one per label.
 LABEL_COLORS = {
     "Cell, Antibody +": (0, 255, 0),
@@ -25,6 +31,14 @@ LABEL_COLORS = {
 }
 
 
+def count_row(counts: dict) -> list[int]:
+    """Per-image counts in COUNT_COLUMNS order: the four nucleus labels, their sum, the two
+    punctum labels, their sum. Labels missing from ``counts`` count as 0."""
+    nuclei = [int(counts.get(lab, 0)) for lab in CELL_LABELS]
+    puncta = [int(counts.get(lab, 0)) for lab in NOSTRIL_LABELS]
+    return nuclei + [sum(nuclei)] + puncta + [sum(puncta)]
+
+
 def is_cell_label(label: str) -> bool:
     return label.startswith("Cell")
 

tests/test_app.py

@@ -19,17 +19,32 @@ def test_analyze_files_end_to_end(tmp_path, monkeypatch):
     p2 = tmp_path / "b.tif"
     tifffile.imwrite(str(p2), img)
     rows, gallery, zip_path, summary = app.analyze_files([str(p1), str(p2)], 0.5, 0.5, 50, "head", "contains")
-    assert len(rows) == 2 and rows[0][0] == "a.png" and len(rows[0]) == 7
+    from cellquant.labels import COUNT_COLUMNS
+    assert len(rows) == 2 and rows[0][0] == "a.png" and len(rows[0]) == 1 + len(COUNT_COLUMNS) == 9
+    for r in rows:   # "All nuclei" after the four nucleus labels, "All puncta" after the two punctum labels
+        assert r[5] == sum(r[1:5]) and r[8] == sum(r[6:8])
     assert len(gallery) == 2 and os.path.exists(gallery[0][0])
+    assert gallery[0][1] == f"a.png: {rows[0][5]} nuclei, {rows[0][8]} puncta"
     assert os.path.exists(zip_path) and summary.startswith("Analysed 2 images in ") and "on the CPU" in summary
     assert "Gemini summary is off" in summary          # no key: the write-up is replaced by a one-line notice
     assert app._gpu_seconds(3) == 15 + 3 * {1: 4, 4: 6, 8: 10}[app.TTA] and app._gpu_seconds(0) == 15 + {1: 4, 4: 6, 8: 10}[app.TTA]
     with pytest.raises(Exception):
         app.analyze_files([], 0.5, 0.5, 50, "head", "contains")
+    import csv
+    import io
+    import json
     import zipfile
     with zipfile.ZipFile(zip_path) as zf:
         names = zf.namelist()
+        counts_csv = list(csv.reader(io.StringIO(zf.read("counts.csv").decode())))
+        results = json.loads(zf.read("results.json"))
     assert "counts.csv" in names and "objects.csv" in names and "results.json" in names
+    assert counts_csv[0] == ["image"] + list(COUNT_COLUMNS)
+    assert counts_csv[0][5] == "All nuclei" and counts_csv[0][8] == "All puncta"
+    assert [[r[0]] + [int(v) for v in r[1:]] for r in counts_csv[1:]] == rows
+    assert results["cellquant_version"] == app.__version__
+    assert results["images"]["a.png"]["totals"] == {"All nuclei": rows[0][5], "All puncta": rows[0][8]}
+    assert results["images"]["a.png"]["totals"]["All nuclei"] == sum(results["images"]["a.png"]["counts"][lab] for lab in COUNT_COLUMNS[:4])
 
 
 def test_build_demo_constructs():

tests/test_labels.py

@@ -1,4 +1,5 @@
-from cellquant.labels import ALL_LABELS, CELL_LABELS, NOSTRIL_LABELS, cell_attributes, cell_label, nostril_in_nucleus, nostril_label
+from cellquant.labels import (ALL_LABELS, CELL_LABELS, COUNT_COLUMNS, NOSTRIL_LABELS, TOTAL_NUCLEI, TOTAL_PUNCTA, cell_attributes,
+                              cell_label, count_row, nostril_in_nucleus, nostril_label)
 
 
 def test_cell_label_roundtrip():
@@ -14,3 +15,28 @@ def test_nostril_label_roundtrip():
 
 def test_label_sets_disjoint():
     assert len(ALL_LABELS) == 6 and set(CELL_LABELS).isdisjoint(NOSTRIL_LABELS)
+
+
+def test_count_columns_order():
+    # each group of labels is followed by its total, nuclei first
+    assert COUNT_COLUMNS == CELL_LABELS + (TOTAL_NUCLEI,) + NOSTRIL_LABELS + (TOTAL_PUNCTA,)
+    assert len(COUNT_COLUMNS) == 8 and COUNT_COLUMNS.index(TOTAL_NUCLEI) == 4 and COUNT_COLUMNS.index(TOTAL_PUNCTA) == 7
+    assert [c for c in COUNT_COLUMNS if c not in (TOTAL_NUCLEI, TOTAL_PUNCTA)] == list(ALL_LABELS)
+
+
+def test_count_row_sums_each_group():
+    counts = {"Cell, Antibody +": 3, "Cell, Antibody -": 5, "Cell, Nostril, Antibody +": 7, "Cell, Nostril, Antibody -": 11,
+              "Nostril in Nucleus": 13, "Nostril External of Nucleus": 17}
+    row = count_row(counts)
+    assert row == [3, 5, 7, 11, 26, 13, 17, 30]
+    assert len(row) == len(COUNT_COLUMNS)
+    assert row[COUNT_COLUMNS.index(TOTAL_NUCLEI)] == sum(counts[lab] for lab in CELL_LABELS)
+    assert row[COUNT_COLUMNS.index(TOTAL_PUNCTA)] == sum(counts[lab] for lab in NOSTRIL_LABELS)
+    assert all(isinstance(v, int) for v in row)
+
+
+def test_count_row_missing_labels_count_as_zero():
+    assert count_row({}) == [0] * 8
+    row = count_row({"Cell, Antibody -": 2, "Nostril External of Nucleus": 4, "unknown label": 99})
+    assert row == [0, 2, 0, 0, 2, 0, 4, 4]
+    assert count_row({"Cell, Antibody +": 1.0}) == [1, 0, 0, 0, 1, 0, 0, 0]   # numpy / float counts become ints