add demo file

README.md

@@ -25,6 +25,8 @@ configs:
   data_files: bacterial/Croissant/runs.csv
 - config_name: yeast
   data_files: yeast/Croissant/runs.csv
+- config_name: motorbench
+  data_files: motorbench/Croissant/runs.csv
 ---
 
 # Dataset Card for POPSICLE
@@ -58,7 +60,7 @@ protocol) so models can be trained and compared under one roof.
 | **Phantom**   | Localization  | Lysate / synthetic        |       7 |    485 | ✅ released |
 | **Yeast**     | Segmentation  | *S. pombe*                |      16 |      4 | ✅ released |
 | **Bacterial** | Segmentation  | Prokaryote (8 genera)     |      68 |     12 | ✅ released |
-| MotorBench    | Localization  | *V. cholerae*             |   1,288 |    844 | 🚧 pending  |
+| **MotorBench**| Localization  | *V. cholerae* (test) + multi-genus prokaryotes (train) | 1,559 |    843 | ✅ released |
 
 - **Curated by:** Authors of the POPSICLE benchmark paper (NeurIPS 2026, under review).
 - **Shared by:** Biohub Dynamic Structural Biology / CryoET Data Portal community.
@@ -128,7 +130,7 @@ popsicle/
       objects.csv          # name, url
   bacterial/    # ✅ released — segmentation across 8 bacterial genera
   yeast/        # ✅ released — segmentation in *S. pombe*
-  motorbench/   # 🚧 pending
+  motorbench/   # ✅ released — flagellar-motor localization
 ```
 
 `copick:baseUrl` is set to `s3://cryoet-data-portal-public/` so the CSV
@@ -169,18 +171,40 @@ excluded so the benchmark scores against the canonical reference labels.
 
 ```python
 import copick
+import numpy as np
+import matplotlib.pyplot as plt
 
 root = copick.from_croissant(
     "https://huggingface.co/datasets/uermel/popsicle/resolve/main/phantom/Croissant/metadata.json",
     static_fs_args={"anon": True},   # public portal bucket
 )
 
-print(root.splits)                   # {'train': [...], 'val': [...], 'test': [...]}
+# Loop over every split and every run
+for split, run_names in root.splits.items():
+    print(f"{split}: {len(run_names)} runs")
+    for run in root.get_runs_in_split(split):
+        for pick_set in run.picks:
+            print(f"  {run.name}  {pick_set.pickable_object_name}: {len(pick_set.points)} pts")
 
-train_runs = root.get_runs_in_split("train")
-run = train_runs[0]
+# Visualize: midplane slice of one tomogram with picks overlaid as scatter
+run = root.get_runs_in_split("train")[0]
+vs = run.voxel_spacings[0]               # 10 Å for Phantom
+tomo = vs.tomograms[0]                   # any tomo_type at this voxel spacing
+arr = tomo.numpy()                       # (Z, Y, X) — streams from portal S3
+
+z_mid = arr.shape[0] // 2
+fig, ax = plt.subplots(figsize=(8, 8))
+ax.imshow(arr[z_mid], cmap="gray")
 for pick_set in run.picks:
-    print(pick_set.pickable_object_name, len(pick_set.points))
+    # CopickPoint locations are in physical units (Å); convert to voxel indices.
+    pts = np.array(
+        [(p.location.x, p.location.y, p.location.z) for p in pick_set.points]
+    ) / vs.voxel_size
+    near = pts[np.abs(pts[:, 2] - z_mid) < 5]   # within ±5 voxels of the slice
+    ax.scatter(near[:, 0], near[:, 1], s=24, label=pick_set.pickable_object_name)
+ax.legend(loc="upper right", fontsize=8)
+ax.set_title(f"{run.name}  z={z_mid}")
+plt.show()
 ```
 
 ### Bacterial — multi-class compartment segmentation
@@ -228,17 +252,43 @@ leak into the benchmark.
 
 ```python
 import copick
+import numpy as np
+import matplotlib.pyplot as plt
 
 root = copick.from_croissant(
     "https://huggingface.co/datasets/uermel/popsicle/resolve/main/bacterial/Croissant/metadata.json",
     static_fs_args={"anon": True},   # public portal bucket
 )
 
-print(root.splits)                   # {'train': [68 names], 'test': [12 names]}
+# Loop over every split and every run
+for split, run_names in root.splits.items():
+    print(f"{split}: {len(run_names)} runs")
+    for run in root.get_runs_in_split(split):
+        seg_names = sorted({s.name for s in run.segmentations})
+        print(f"  {run.name}: {seg_names}")
 
+# Visualize: midplane slice of one tomogram with segmentation masks overlaid
 run = root.get_runs_in_split("train")[0]
-for seg in run.segmentations:
-    print(seg.name, seg.voxel_size)
+vs = run.voxel_spacings[0]
+tomo = vs.tomograms[0]
+arr = tomo.numpy()                       # (Z, Y, X) — streams from portal S3
+z_mid = arr.shape[0] // 2
+
+fig, ax = plt.subplots(figsize=(8, 8))
+ax.imshow(arr[z_mid], cmap="gray")
+cmap = plt.get_cmap("tab10")
+for i, seg in enumerate(run.segmentations):
+    mask = seg.numpy()[z_mid]            # (Y, X) — same shape as the tomo slice
+    ax.imshow(
+        np.ma.masked_where(mask == 0, mask),
+        cmap=cmap, vmin=0, vmax=10, alpha=0.4,
+        interpolation="none",
+    )
+    # one-line legend hack: scatter a single point off-image with the class color
+    ax.scatter([], [], color=cmap(i), label=seg.name)
+ax.legend(loc="upper right", fontsize=8)
+ax.set_title(f"{run.name}  z={z_mid}")
+plt.show()
 ```
 
 ### Yeast — multi-class organelle segmentation
@@ -291,17 +341,118 @@ the better-sampled bacterial benchmark (paper §4, §6, Table 2).
 
 ```python
 import copick
+import numpy as np
+import matplotlib.pyplot as plt
 
 root = copick.from_croissant(
     "https://huggingface.co/datasets/uermel/popsicle/resolve/main/yeast/Croissant/metadata.json",
     static_fs_args={"anon": True},   # public portal bucket
 )
 
-print(root.splits)                   # {'train': [16 names], 'test': [4 names]}
+# Loop over every split and every run
+for split, run_names in root.splits.items():
+    print(f"{split}: {len(run_names)} runs")
+    for run in root.get_runs_in_split(split):
+        seg_names = sorted({s.name for s in run.segmentations})
+        print(f"  {run.name}: {seg_names}")
 
+# Visualize: midplane slice of one tomogram with organelle segmentations overlaid
 run = root.get_runs_in_split("train")[0]
-for seg in run.segmentations:
-    print(seg.name, seg.voxel_size)
+vs = run.voxel_spacings[0]
+tomo = vs.tomograms[0]
+arr = tomo.numpy()                       # (Z, Y, X) — streams from portal S3
+z_mid = arr.shape[0] // 2
+
+fig, ax = plt.subplots(figsize=(8, 8))
+ax.imshow(arr[z_mid], cmap="gray")
+cmap = plt.get_cmap("tab10")
+for i, seg in enumerate(run.segmentations):
+    mask = seg.numpy()[z_mid]
+    ax.imshow(
+        np.ma.masked_where(mask == 0, mask),
+        cmap=cmap, vmin=0, vmax=10, alpha=0.4,
+        interpolation="none",
+    )
+    ax.scatter([], [], color=cmap(i), label=seg.name)
+ax.legend(loc="upper right", fontsize=8)
+ax.set_title(f"{run.name}  z={z_mid}")
+plt.show()
+```
+
+### MotorBench — single-class flagellar motor localization
+
+Sparse 3D point localization of bacterial flagellar motors in whole-cell
+cryoET tomograms. The benchmark is derived from the BYU 2025 Kaggle
+challenge ([CZCDP-10332](https://cryoetdataportal.czscience.com/depositions/10332)
+train, [CZCDP-10347](https://cryoetdataportal.czscience.com/depositions/10347)
+test). The training side is **annotation-only** on the portal — its
+1,559 motor picks are scattered across **92 host datasets** spanning
+many bacterial and archaeal genera, contributed by the BYU competition
+authors plus the first-place (Brenden Artley) and MIC-DKFZ (Isensee
+et al.) follow-up releases. The held-out test side is a complete
+deposition: 5 *Vibrio cholerae* datasets (DS-10485…10489) authored by
+Owens et al. 2025.
+
+| Class             | Portal `object_name`             |
+|-------------------|----------------------------------|
+| `flagellar-motor` | `bacterial-type-flagellum-motor` |
+
+#### Splits
+
+| Split   | CDP source(s)                       | # tomograms | # motor picks | Notes                                     |
+|---------|-------------------------------------|------------:|--------------:|-------------------------------------------|
+| `train` | CZCDP-10332 → 92 host datasets      |       1,559 |         1,559 | One motor pick per training run            |
+| `test`  | CZCDP-10347 (DS-10485…10489)        |         843 |           275 | Includes pickless negative samples        |
+
+The train slice was filtered down from the 3,528 host-dataset runs to
+only those that carry a CZCDP-10332 motor annotation — runs without
+a motor pick belong to unrelated experiments and are not part of the
+benchmark. The test slice keeps all 843 *V. cholerae* runs (motor and
+no-motor) because negative samples are an explicit part of the held-out
+evaluation per Owens et al. 2025.
+
+Picks are scoped to deposition_id so the train and test slices stay
+disjoint even where the same host datasets appear in both depositions'
+neighborhoods — this is implemented via the
+`picks_portal_meta={"deposition_id": ...}` filter on each export pass.
+
+#### Loading with copick
+
+```python
+import copick
+import numpy as np
+import matplotlib.pyplot as plt
+
+root = copick.from_croissant(
+    "https://huggingface.co/datasets/uermel/popsicle/resolve/main/motorbench/Croissant/metadata.json",
+    static_fs_args={"anon": True},   # public portal bucket
+)
+
+# Loop over every split and every run; report runs that carry motor picks
+for split, run_names in root.splits.items():
+    runs_with = [r for r in root.get_runs_in_split(split) if r.picks]
+    print(f"{split}: {len(run_names)} runs ({len(runs_with)} with motor picks)")
+
+# Visualize: midplane slice of one *V. cholerae* test tomogram with motor
+# centers overlaid as crosses
+run = next(r for r in root.get_runs_in_split("test") if r.picks)
+vs = run.voxel_spacings[0]
+tomo = vs.tomograms[0]
+arr = tomo.numpy()                       # (Z, Y, X) — streams from portal S3
+z_mid = arr.shape[0] // 2
+
+fig, ax = plt.subplots(figsize=(8, 8))
+ax.imshow(arr[z_mid], cmap="gray")
+for pick_set in run.picks:
+    pts = np.array(
+        [(p.location.x, p.location.y, p.location.z) for p in pick_set.points]
+    ) / vs.voxel_size
+    near = pts[np.abs(pts[:, 2] - z_mid) < 5]
+    ax.scatter(near[:, 0], near[:, 1], marker="x", s=80, c="red",
+               label=pick_set.pickable_object_name)
+ax.legend(loc="upper right", fontsize=8)
+ax.set_title(f"{run.name}  z={z_mid}")
+plt.show()
 ```
 
 ## Dataset Creation
@@ -370,13 +521,16 @@ the underlying tomograms are re-acquired by this project.
   inclusion, intermembrane-space, membrane) on 80 cellular tomograms
   from 8 bacterial genera, deposited as
   [CZCDP-10350](https://cryoetdataportal.czscience.com/depositions/10350).
-- **Yeast** *(pending)*: organelle segmentations originally produced by
+- **Yeast**: organelle segmentations originally produced by
   de Teresa-Trueba et al. 2023; curated and standardized by Biohub DSB
   for inclusion in POPSICLE.
-- **MotorBench** *(pending)*: bacterial flagellar motor centers picked
-  by the BYU Kaggle competition contributors (training corpus expanded
-  by the first-place team and MIC-DKFZ); the held-out test set was
-  authored by Owens et al. 2025.
+- **MotorBench**: bacterial flagellar motor centers picked
+  by the BYU Kaggle competition contributors (training corpus
+  CZCDP-10332, expanded by the first-place team and MIC-DKFZ); the
+  held-out test set (CZCDP-10347, V. cholerae) was authored by Owens
+  et al. 2025. Picks are filtered by deposition_id so the train and
+  test slices stay disjoint even though the train deposition reuses
+  tomograms from many host datasets.
 
 #### Who are the annotators?
 
@@ -385,9 +539,9 @@ the underlying tomograms are re-acquired by this project.
   to exclude community Kaggle submissions hosted on the same datasets).
 - **Bacterial**: POPSICLE author team (CZCDP-10350 contributors —
   Peck, Ermel, Schwartz, Owens, Carragher, Kimanius, and others).
-- **Yeast** *(pending)*: de Teresa-Trueba et al. 2023, with curatorial
+- **Yeast**: de Teresa-Trueba et al. 2023, with curatorial
   refinement by Biohub DSB.
-- **MotorBench** *(pending)*: BYU competition + first-place team
+- **MotorBench**: BYU competition + first-place team
   (Brenden Artley) + MIC-DKFZ (Fabian Isensee et al.) for the training
   corpus; Owens et al. 2025 (V. cholerae) for the held-out test set.
 
@@ -500,6 +654,29 @@ copick toolkit:
   macromolecule within a tomogram.
 - **Segmentation** — a voxel-wise label volume assigning each voxel to
   one of a fixed set of classes (membrane, organelle, cytoplasm, …).
+- **Run** *(CryoET Data Portal)* — all data acquired and derived from
+  imaging a single location in a sample: the original tilt series,
+  motion-corrected frames, one or more reconstructed tomograms (often at
+  multiple voxel spacings), and any annotations attached to those
+  tomograms. A run belongs to exactly one dataset and is identified by
+  a unique numeric Run ID. Copick exposes this as `run.name` (a string
+  cast of the Run ID for portal-backed projects).
+- **Dataset** *(CryoET Data Portal, "DS-XXXXX")* — a collection of runs
+  that share a common sample and acquisition context (organism, strain,
+  preparation, microscope session). Datasets carry their own metadata
+  (sample type, growth conditions, instrument, contributing lab) and
+  belong to exactly one deposition. The CDP "DS-10440" notation refers
+  to a Dataset row.
+- **Deposition** *(CryoET Data Portal, "CZCDP-XXXXX")* — a higher-level
+  grouping under which one or more datasets and/or annotations are
+  contributed to the portal as a single submission, typically tied to
+  a publication or a community release (e.g. CZCDP-10350 for the
+  POPSICLE Bacterial deposition). A deposition can be **full** (it
+  carries new datasets + their tomograms + annotations) or
+  **annotation-only** (it carries new annotations attached to runs that
+  already exist in datasets contributed earlier under different
+  depositions — used by POPSICLE for the Bacterial annotations and by
+  the BYU MotorBench train deposition).
 - **Missing wedge** — the cone of unmeasured Fourier-space data caused
   by the limited tilt range during cryoET acquisition; produces
   anisotropic resolution and characteristic elongation artifacts.
@@ -512,7 +689,6 @@ copick toolkit:
 
 - copick documentation: https://github.com/copick/copick
 - CryoET Data Portal: https://cryoetdataportal.czscience.com
-- mlcroissant spec: https://docs.mlcommons.org/croissant/docs/croissant-spec.html
 
 ## Dataset Card Authors
 

demos.ipynb

@@ -0,0 +1,274 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# POPSICLE \u2014 copick demos\n",
+    "\n",
+    "Minimal load-and-visualize examples for each released POPSICLE\n",
+    "sub-benchmark. Every demo:\n",
+    "\n",
+    "1. Opens the Croissant manifest from this Hugging Face repo.\n",
+    "2. Loops over each split and prints per-run annotation summaries.\n",
+    "3. Streams one tomogram from the CryoET Data Portal and overlays\n",
+    "   that run's picks (Phantom) or segmentation masks (Bacterial,\n",
+    "   Yeast) on a midplane slice.\n",
+    "\n",
+    "All data is read on demand from `s3://cryoet-data-portal-public/`\n",
+    "\u2014 nothing large lands on disk. The `metadata.json` itself is fetched\n",
+    "from this dataset repo on Hugging Face.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "Install the runtime dependencies. `copick` provides the\n",
+    "`from_croissant` reader and the `run.picks`, `run.segmentations`,\n",
+    "and `tomo.numpy()` helpers used below; `s3fs` lets `copick`\n",
+    "stream from the portal's public bucket anonymously.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install --quiet copick s3fs matplotlib\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Phantom \u2014 multi-class macromolecular localization\n",
+    "\n",
+    "Six particle classes (apo-ferritin, beta-amylase, beta-galactosidase,\n",
+    "ribosome, thyroglobulin, virus-like-particle) on 492 lysate\n",
+    "tomograms split into `train` / `val` / `test`. Picks are restricted\n",
+    "to the original ground-truth author (Ariana Peck).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copick\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "PHANTOM_URL = (\n",
+    "    \"https://huggingface.co/datasets/uermel/popsicle/resolve/main/\"\n",
+    "    \"phantom/Croissant/metadata.json\"\n",
+    ")\n",
+    "\n",
+    "root = copick.from_croissant(PHANTOM_URL, static_fs_args={\"anon\": True})\n",
+    "\n",
+    "for split, run_names in root.splits.items():\n",
+    "    print(f\"{split}: {len(run_names)} runs\")\n",
+    "    for run in root.get_runs_in_split(split)[:3]:  # head sample\n",
+    "        for pick_set in run.picks:\n",
+    "            print(\n",
+    "                f\"  {run.name}  {pick_set.pickable_object_name}: \"\n",
+    "                f\"{len(pick_set.points)} pts\"\n",
+    "            )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize: midplane slice of one Phantom tomogram with picks overlaid.\n",
+    "run = root.get_runs_in_split(\"train\")[0]\n",
+    "vs = run.voxel_spacings[0]               # 10 \u00c5 for Phantom\n",
+    "tomo = vs.tomograms[0]                   # any tomo_type at this voxel spacing\n",
+    "arr = tomo.numpy()                       # (Z, Y, X) \u2014 streams from portal S3\n",
+    "z_mid = arr.shape[0] // 2\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "ax.imshow(arr[z_mid], cmap=\"gray\")\n",
+    "for pick_set in run.picks:\n",
+    "    # CopickPoint locations are in physical units (\u00c5); convert to voxel indices.\n",
+    "    pts = np.array(\n",
+    "        [(p.location.x, p.location.y, p.location.z) for p in pick_set.points]\n",
+    "    ) / vs.voxel_size\n",
+    "    near = pts[np.abs(pts[:, 2] - z_mid) < 5]   # within \u00b15 voxels of the slice\n",
+    "    ax.scatter(near[:, 0], near[:, 1], s=24, label=pick_set.pickable_object_name)\n",
+    "ax.legend(loc=\"upper right\", fontsize=8)\n",
+    "ax.set_title(f\"{run.name}  z={z_mid}\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bacterial \u2014 multi-class compartment segmentation\n",
+    "\n",
+    "Five compartment classes (cytosole, flagellum, inclusion,\n",
+    "intermembrane-space, membrane) on 80 cellular tomograms across 8\n",
+    "bacterial genera, split 68/12 train/test. Annotations sourced from\n",
+    "deposition CZCDP-10350 only.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copick\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "BACTERIAL_URL = (\n",
+    "    \"https://huggingface.co/datasets/uermel/popsicle/resolve/main/\"\n",
+    "    \"bacterial/Croissant/metadata.json\"\n",
+    ")\n",
+    "\n",
+    "root = copick.from_croissant(BACTERIAL_URL, static_fs_args={\"anon\": True})\n",
+    "\n",
+    "for split, run_names in root.splits.items():\n",
+    "    print(f\"{split}: {len(run_names)} runs\")\n",
+    "    for run in root.get_runs_in_split(split)[:3]:\n",
+    "        seg_names = sorted({s.name for s in run.segmentations})\n",
+    "        print(f\"  {run.name}: {seg_names}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize: midplane slice of one bacterial tomogram with seg overlays.\n",
+    "run = root.get_runs_in_split(\"train\")[0]\n",
+    "vs = run.voxel_spacings[0]\n",
+    "tomo = vs.tomograms[0]\n",
+    "arr = tomo.numpy()\n",
+    "z_mid = arr.shape[0] // 2\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "ax.imshow(arr[z_mid], cmap=\"gray\")\n",
+    "cmap = plt.get_cmap(\"tab10\")\n",
+    "for i, seg in enumerate(run.segmentations):\n",
+    "    mask = seg.numpy()[z_mid]            # (Y, X) \u2014 same shape as the tomo slice\n",
+    "    ax.imshow(\n",
+    "        np.ma.masked_where(mask == 0, mask),\n",
+    "        cmap=cmap, vmin=0, vmax=10, alpha=0.4, interpolation=\"none\",\n",
+    "    )\n",
+    "    ax.scatter([], [], color=cmap(i), label=seg.name)\n",
+    "ax.legend(loc=\"upper right\", fontsize=8)\n",
+    "ax.set_title(f\"{run.name}  z={z_mid}\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Yeast \u2014 multi-class organelle segmentation\n",
+    "\n",
+    "Six organelle classes (cytoplasm, nucleus, nuclear-envelope,\n",
+    "vesicle, endomembrane, mitochondrion) on 20 *S. pombe* tomograms\n",
+    "split 16/4 train/test. Low-data, class-imbalanced eukaryotic\n",
+    "counterpart to the bacterial benchmark.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copick\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "YEAST_URL = (\n",
+    "    \"https://huggingface.co/datasets/uermel/popsicle/resolve/main/\"\n",
+    "    \"yeast/Croissant/metadata.json\"\n",
+    ")\n",
+    "\n",
+    "root = copick.from_croissant(YEAST_URL, static_fs_args={\"anon\": True})\n",
+    "\n",
+    "for split, run_names in root.splits.items():\n",
+    "    print(f\"{split}: {len(run_names)} runs\")\n",
+    "    for run in root.get_runs_in_split(split)[:3]:\n",
+    "        seg_names = sorted({s.name for s in run.segmentations})\n",
+    "        print(f\"  {run.name}: {seg_names}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize: midplane slice of one yeast tomogram with organelle masks overlaid.\n",
+    "run = root.get_runs_in_split(\"train\")[0]\n",
+    "vs = run.voxel_spacings[0]\n",
+    "tomo = vs.tomograms[0]\n",
+    "arr = tomo.numpy()\n",
+    "z_mid = arr.shape[0] // 2\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "ax.imshow(arr[z_mid], cmap=\"gray\")\n",
+    "cmap = plt.get_cmap(\"tab10\")\n",
+    "for i, seg in enumerate(run.segmentations):\n",
+    "    mask = seg.numpy()[z_mid]\n",
+    "    ax.imshow(\n",
+    "        np.ma.masked_where(mask == 0, mask),\n",
+    "        cmap=cmap, vmin=0, vmax=10, alpha=0.4, interpolation=\"none\",\n",
+    "    )\n",
+    "    ax.scatter([], [], color=cmap(i), label=seg.name)\n",
+    "ax.legend(loc=\"upper right\", fontsize=8)\n",
+    "ax.set_title(f\"{run.name}  z={z_mid}\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## MotorBench \ud83d\udea7 *(pending release)*\n",
+    "\n",
+    "The MotorBench Croissant manifest is generated by\n",
+    "`scripts/build_motorbench_croissant.py` once the underlying\n",
+    "annotation walks finish. Once published it can be loaded with the\n",
+    "same pattern \u2014 single class `flagellar-motor`, two splits\n",
+    "(`train`, `test`) keyed on deposition_id (CZCDP-10332 vs\n",
+    "CZCDP-10347):\n",
+    "\n",
+    "```python\n",
+    "MOTORBENCH_URL = (\n",
+    "    \"https://huggingface.co/datasets/uermel/popsicle/resolve/main/\"\n",
+    "    \"motorbench/Croissant/metadata.json\"\n",
+    ")\n",
+    "root = copick.from_croissant(MOTORBENCH_URL, static_fs_args={\"anon\": True})\n",
+    "```\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}