itasc 0.2.0.dev0__py3-none-any.whl

itasc/napari/_track_render.py

@@ -0,0 +1,114 @@
+"""Shared napari track-rendering helpers.
+
+Pure numpy / napari colormap maths reused by both the contact-analysis
+visualization (``itasc-aggregate``) and the nucleus-correction track overview
+(``itasc-tracking``). It lives in ``itasc-core`` so neither piece has to
+depend on the other.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+_UNLABELED_COLOR = np.array([0.7, 0.7, 0.7, 1.0], dtype=float)
+
+
+def _track_label_color_styling(
+    track_ids: np.ndarray,
+    color_map: dict[int | None, tuple[float, float, float, float] | str],
+) -> tuple[Any, np.ndarray] | None:
+    """Colour each track exactly like its cell label.
+
+    A ``Tracks`` layer colours by mapping a property through a colormap. When a
+    custom colormap is supplied via ``colormaps_dict`` napari feeds it the *raw*
+    property values (no normalisation), so we build a per-vertex ``label_pos``
+    property in ``[0, 1]`` plus a step (``interpolation="zero"``) colormap whose
+    bins reproduce ``color_map`` for each track. Returns ``(colormap, label_pos)``
+    or ``None`` when there are no tracks / napari is unavailable.
+    """
+    ids = sorted({int(i) for i in np.asarray(track_ids).tolist()})
+    if not ids:
+        return None
+    try:
+        from napari.utils.colormaps import Colormap
+    except Exception:  # pragma: no cover - napari compatibility
+        return None
+
+    def _color(cell_id: int) -> tuple[float, float, float, float]:
+        raw = color_map.get(int(cell_id))
+        # ``color_map`` may come straight from a caller (tuple/list values) or be
+        # read back off a napari ``DirectLabelColormap``, which normalises every
+        # entry to an ``np.ndarray``. Accept any length-4 numeric sequence so the
+        # latter doesn't silently fall through to the grey unlabeled colour.
+        if isinstance(raw, (tuple, list, np.ndarray)) and len(raw) == 4:
+            return tuple(float(c) for c in raw)
+        return tuple(float(c) for c in _UNLABELED_COLOR)
+
+    colors = [_color(i) for i in ids]
+    if len(ids) == 1:
+        cmap = Colormap([colors[0], colors[0]], controls=[0.0, 1.0])
+        pos_by_id = {ids[0]: 0.0}
+    else:
+        vals = [k / (len(ids) - 1) for k in range(len(ids))]
+        pos_by_id = {ids[k]: vals[k] for k in range(len(ids))}
+        edges = (
+            [0.0]
+            + [(vals[k - 1] + vals[k]) / 2 for k in range(1, len(ids))]
+            + [1.0]
+        )
+        cmap = Colormap(colors, controls=edges, interpolation="zero")
+    label_pos = np.array(
+        [pos_by_id[int(i)] for i in np.asarray(track_ids).tolist()], dtype=float
+    )
+    return cmap, label_pos
+
+
+def _nucleus_centroids_by_track(
+    nucleus_labels: np.ndarray,
+) -> dict[int, list[tuple[int, float, float]]]:
+    labels = np.asarray(nucleus_labels)
+    if labels.ndim == 2:
+        labels = labels[np.newaxis, ...]
+    if labels.ndim > 3:
+        labels = np.squeeze(labels)
+    if labels.ndim != 3:
+        raise ValueError(
+            f"Expected time-first 2D/3D nucleus labels, got shape {nucleus_labels.shape}"
+        )
+
+    centroids: dict[int, list[tuple[int, float, float]]] = {}
+    for frame_idx in range(labels.shape[0]):
+        frame = labels[frame_idx]
+        flat = frame.ravel()
+        order = np.argsort(flat, kind="stable")
+        sorted_ids = flat[order]
+
+        change = np.empty(len(sorted_ids), dtype=bool)
+        change[0] = True
+        np.not_equal(sorted_ids[1:], sorted_ids[:-1], out=change[1:])
+        boundaries = np.flatnonzero(change)
+
+        rows_all, cols_all = np.divmod(order, frame.shape[1])
+
+        ends = np.empty_like(boundaries)
+        ends[:-1] = boundaries[1:]
+        ends[-1] = len(sorted_ids)
+
+        for bi in range(len(boundaries)):
+            cell_id = int(sorted_ids[boundaries[bi]])
+            if cell_id == 0:
+                continue
+            s, e = int(boundaries[bi]), int(ends[bi])
+            y = float(rows_all[s:e].mean())
+            x = float(cols_all[s:e].mean())
+            centroids.setdefault(cell_id, []).append((frame_idx, y, x))
+
+    return centroids
+
+
+__all__ = [
+    "_UNLABELED_COLOR",
+    "_nucleus_centroids_by_track",
+    "_track_label_color_styling",
+]

itasc/napari/_widget_helpers.py

@@ -0,0 +1,236 @@
+"""Small Qt widget factory helpers shared across napari workflow widgets."""
+from __future__ import annotations
+
+from qtpy.QtCore import QEvent, QObject, QSize, Qt
+from qtpy.QtWidgets import (
+    QDoubleSpinBox,
+    QHBoxLayout,
+    QLabel,
+    QProgressBar,
+    QPushButton,
+    QSizePolicy,
+    QStyle,
+    QStyleOption,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+from superqt import (
+    QLabeledDoubleSlider,
+    QLabeledSlider,
+)
+
+from itasc.napari.ui_style import action_button, parameter_heading, status_label
+
+
+def heading(text: str) -> QLabel:
+    lbl = QLabel(text)
+    return parameter_heading(lbl)
+
+
+def make_status() -> QLabel:
+    lbl = QLabel("")
+    lbl.setWordWrap(True)
+    lbl.setVisible(False)
+    status_label(lbl)
+    return lbl
+
+
+def make_progress() -> QProgressBar:
+    bar = QProgressBar()
+    bar.setRange(0, 100)
+    bar.setValue(0)
+    bar.setTextVisible(True)
+    bar.setVisible(False)
+    return bar
+
+
+def dspin(lo, hi, val, step=0.1, decimals=2, tooltip=""):
+    s = QDoubleSpinBox()
+    s.setRange(lo, hi); s.setValue(val); s.setSingleStep(step)
+    s.setDecimals(decimals); s.setToolTip(tooltip)
+    return s
+
+
+def btn(text, tooltip=""):
+    b = QPushButton(text)
+    b.setToolTip(tooltip)
+    action_button(b, expand=True)
+    return b
+
+
+def _patch_label_autosize(label) -> None:
+    """Override the superqt SliderLabel's internal size calculation so it
+    fits the widest value it can display, formatted with the configured
+    decimals.
+
+    superqt's stock ``_get_size`` widths labels from ``str(minimum())`` /
+    ``str(maximum())`` — which drops trailing zeros (``str(1.0) == "1.0"``)
+    and ignores decimals, so e.g. a (-10, 10) range with 1 decimal sizes
+    the label for ``"-10.0"`` but then ``str(-10.0) == "-10.0"``... fine
+    in that case, while a (0, 1) range with 2 decimals sizes for ``"1.0"``
+    (3 chars) and clips the displayed ``"1.00"``. Style padding/font
+    tweaks compound this. We replace ``_get_size`` on the instance so
+    that every subsequent ``_update_size`` (rangeChanged, showEvent…)
+    re-derives the size from the actual format width plus headroom for
+    chrome and a possible minus sign.
+    """
+    def _get_size():
+        dec = label.decimals() if hasattr(label, "decimals") else 0
+
+        def _fmt(v):
+            return f"{v:.{dec}f}" if dec else f"{int(v)}"
+        lo, hi = label.minimum(), label.maximum()
+        sample = max((_fmt(lo), _fmt(hi)), key=len)
+        # ensure room for a minus sign even if both ends are non-negative
+        # (the user may type one into the editable label).
+        if not sample.startswith("-"):
+            sample = "-" + sample
+        fm = label.fontMetrics()
+        prefix = label.prefix() or ""
+        suffix = label.suffix() or ""
+        w = fm.horizontalAdvance(prefix + sample + suffix) + 18
+        h = label.sizeHint().height()
+        opt = QStyleOption()
+        return label.style().sizeFromContents(
+            QStyle.ContentsType.CT_LineEdit, opt, QSize(w, h), label
+        )
+
+    label._get_size = _get_size
+    label._update_size()
+
+
+def _slider_step_button(text: str, object_name: str, tooltip: str) -> QToolButton:
+    button = QToolButton()
+    button.setText(text)
+    button.setObjectName(object_name)
+    button.setToolTip(tooltip)
+    button.setAutoRepeat(True)
+    button.setFixedSize(18, 18)
+    button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+    return button
+
+
+class _SliderStepButtonStateSyncer(QObject):
+    def __init__(self, sync_button_state) -> None:
+        super().__init__()
+        self._sync_button_state = sync_button_state
+
+    def eventFilter(self, watched, event) -> bool:
+        if event.type() == QEvent.Type.EnabledChange:
+            self._sync_button_state()
+        return False
+
+
+def _connect_slider_step_buttons(slider) -> tuple[QToolButton, QToolButton]:
+    decrement = _slider_step_button(
+        "-", "slider_decrement_button", "Decrease by one step"
+    )
+    increment = _slider_step_button(
+        "+", "slider_increment_button", "Increase by one step"
+    )
+
+    def _set_stepped_value(direction: int) -> None:
+        if not slider.isEnabled():
+            return
+        slider.setValue(slider.value() + direction * slider.singleStep())
+
+    def _sync_button_state(*_args) -> None:
+        enabled = slider.isEnabled()
+        decrement.setEnabled(enabled and slider.value() > slider.minimum())
+        increment.setEnabled(enabled and slider.value() < slider.maximum())
+
+    decrement.clicked.connect(lambda: _set_stepped_value(-1))
+    increment.clicked.connect(lambda: _set_stepped_value(1))
+    slider.valueChanged.connect(_sync_button_state)
+    slider.rangeChanged.connect(_sync_button_state)
+    state_syncer = _SliderStepButtonStateSyncer(_sync_button_state)
+    state_syncer.setParent(slider)
+    slider.installEventFilter(state_syncer)
+    slider._itasc_slider_step_button_state_syncer = state_syncer
+    _sync_button_state()
+    return decrement, increment
+
+
+def add_slider_step_buttons(
+    layout: QHBoxLayout, slider, track: QWidget | None = None
+) -> tuple[QToolButton, QToolButton]:
+    track = slider if track is None else track
+    decrement, increment = _connect_slider_step_buttons(slider)
+    layout.addWidget(decrement, alignment=Qt.AlignmentFlag.AlignVCenter)
+    layout.addWidget(track)
+    layout.addWidget(increment, alignment=Qt.AlignmentFlag.AlignVCenter)
+    return decrement, increment
+
+
+def _stack_slider_label_above(slider, *, step_buttons: bool = False) -> None:
+    """Repack a QLabeledSlider / QLabeledDoubleSlider so the editable value
+    label sits centered above the slider track instead of beside it."""
+    label = slider._label
+    track = slider._slider
+    label.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+    label.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Fixed)
+    _patch_label_autosize(label)
+
+    old_layout = slider.layout()
+    if old_layout is not None:
+        old_layout.removeWidget(label)
+        old_layout.removeWidget(track)
+        QWidget().setLayout(old_layout)
+    label.setParent(slider)
+    track.setParent(slider)
+    vbox = QVBoxLayout()
+    vbox.setContentsMargins(0, 0, 0, 0)
+    vbox.setSpacing(0)
+    vbox.addWidget(label, alignment=Qt.AlignmentFlag.AlignHCenter)
+    if step_buttons:
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(2)
+        add_slider_step_buttons(row, slider, track)
+        vbox.addLayout(row)
+    else:
+        vbox.addWidget(track)
+    slider.setLayout(vbox)
+
+
+def dslider(lo, hi, val, step=0.1, decimals=2, tooltip="", *, step_buttons=True):
+    """A horizontal QLabeledDoubleSlider — same call signature as `dspin`.
+
+    The editable value label sits above the slider track for a compact,
+    wide-track look."""
+    s = QLabeledDoubleSlider(Qt.Orientation.Horizontal)
+    s.setRange(lo, hi)
+    s.setValue(val)
+    s.setSingleStep(step)
+    s.setDecimals(decimals)
+    s.setToolTip(tooltip)
+    s.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+    s.setProperty("itasc_stack_section_label", True)
+    _stack_slider_label_above(s, step_buttons=step_buttons)
+    return s
+
+
+def islider(lo, hi, val, step=1, tooltip="", *, step_buttons=True):
+    """A horizontal QLabeledSlider — same call signature as `ispin`.
+
+    The editable value label sits above the slider track."""
+    s = QLabeledSlider(Qt.Orientation.Horizontal)
+    s.setRange(lo, hi)
+    s.setValue(val)
+    s.setSingleStep(step)
+    s.setToolTip(tooltip)
+    s.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+    s.setProperty("itasc_stack_section_label", True)
+    _stack_slider_label_above(s, step_buttons=step_buttons)
+    return s
+
+
+def tool_btn(glyph: str, tooltip: str = "", *, checkable: bool = False) -> QToolButton:
+    """Compact icon-only QToolButton carrying a unicode glyph and a tooltip."""
+    b = QToolButton()
+    b.setText(glyph)
+    b.setToolTip(tooltip)
+    b.setCheckable(checkable)
+    b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+    return b

itasc/napari/aggregate_widget.py

@@ -0,0 +1,339 @@
+"""Aggregate capstone: pool every processed position into project-level tables.
+
+The main app's project-level bookend to the per-position sections. Reads the same
+catalog records the ``ExperimentsPanel`` builds, and drives the headless engine
+(``author_config`` then ``pipeline.run``). Pool-only: it aggregates positions
+whose ``contact_analysis.h5`` already exists and never builds missing ones, so ``run`` is
+load-and-pool with no per-position recompute. Plotting is a downstream concern.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import tifffile
+from napari.qt.threading import thread_worker
+from napari.utils.notifications import show_error, show_info
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QHBoxLayout,
+    QLabel,
+    QListWidget,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from itasc.contact_analysis import author_config, run
+from itasc.contact_analysis.quantifier import available_quantifiers
+from itasc.contact_analysis.records import supported_quantities
+from itasc.contact_analysis.shape_tables import catalogue_root
+
+
+def _lateral_pixels(path) -> int | None:
+    """The ``Y * X`` pixel count of a label image's lateral field, or ``None``.
+
+    Reads only the TIFF header (not the pixel data), so it is cheap to call on every
+    records refresh. Returns ``None`` when *path* is missing, unreadable, or not at
+    least 2-D. The field-of-view autofill multiplies this by ``pixel_size_um²``.
+    """
+    if not path:
+        return None
+    p = Path(path)
+    if not p.is_file():
+        return None
+    try:
+        with tifffile.TiffFile(p) as tif:
+            shape = tif.series[0].shape
+    except Exception:
+        return None
+    if len(shape) < 2:
+        return None
+    return int(shape[-2]) * int(shape[-1])
+
+
+def pooled_quantifiers():
+    """The registered quantifiers that pool into a project table, in display order.
+
+    Only quantifiers declaring ``table_keys`` produce an aggregated CSV; producers
+    (e.g. ``contacts``) are excluded. :func:`available_quantifiers` already returns
+    them sorted by ``display_name``, which is the order the checkbox list shows.
+    """
+    return [cls for cls in available_quantifiers() if cls.table_keys]
+
+
+def partition_ready(records):
+    """Split catalog *records* into ``(ready, not_ready)`` by ``contact_analysis.h5``.
+
+    A record is *ready* when its ``contact_analysis_path`` exists on disk.
+    """
+    ready, not_ready = [], []
+    for rec in records:
+        path = rec.get("contact_analysis_path")
+        if path is not None and Path(path).exists():
+            ready.append(rec)
+        else:
+            not_ready.append(rec)
+    return ready, not_ready
+
+
+def _position_name(record) -> str:
+    path = record.get("position_path")
+    return Path(path).name if path else "(unknown)"
+
+
+def pool_positions(ready_records, skipped_names, quantities=(), params=None):
+    """Author the project artifacts for *ready_records* and run the engine.
+
+    Writes ``catalog.csv`` + ``config.toml`` into the ready positions' common
+    ancestor (:func:`catalogue_root`), then ``run``s the pipeline over them.
+    *quantities* is the checked subset of pooled quantities to write (empty = every
+    available table); it is authored into the config and restricts which tables the
+    pool-only run emits. *params* are the shared build knobs (pixel size, frame
+    length, FOV area) authored into the config's ``[params]`` so the pooled cheap
+    quantities compute in physical units. Returns a result dict for the UI: the
+    ``name -> path`` table map, the ``skipped`` position names, and the
+    ``project_dir`` the tables landed under.
+    """
+    project_dir = catalogue_root(ready_records)
+    config_path = author_config(
+        project_dir, ready_records, quantities=tuple(quantities), params=params or None
+    )
+    # Pool-only: read each position's existing contact_analysis.h5 and pool it (plus the
+    # in-memory cheap quantities). build=False skips the producer's unconditional
+    # rebuild, so ready positions are loaded, never recomputed.
+    tables = run(config_path, build=False)
+    return {
+        "tables": tables,
+        "skipped": list(skipped_names),
+        "project_dir": project_dir,
+    }
+
+
+class AggregateWidget(QWidget):
+    """Project-level capstone: pool every ready position into tidy tables.
+
+    Fed catalog records via :meth:`set_records` (the same records the app's
+    ``ExperimentsPanel`` builds). Pool-only: Run aggregates positions whose
+    ``contact_analysis.h5`` exists and reports the ones it skipped by name.
+    """
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._records: list[dict] = []
+        self._worker = None
+        self._has_run = False
+        self._fov_user_edited = False
+
+        layout = QVBoxLayout(self)
+        self.subtitle = QLabel(
+            "Pools every processed position into project-level tables."
+        )
+        self.subtitle.setWordWrap(True)
+        self.readout = QLabel("No data folders yet.")
+        self.readout.setWordWrap(True)
+        self.quantities_label = QLabel("Quantities to pool:")
+        # One checkbox per pooled quantity, all on by default. A box is greyed out
+        # (disabled + unchecked) when no ready position carries the inputs/params it
+        # needs, so the list also reads as "what this stage computes", and an
+        # enabled box never promises a table the run would skip. See
+        # :func:`~itasc.contact_analysis.records.supported_quantities`.
+        self._checks: dict[str, QCheckBox] = {}
+        for cls in pooled_quantifiers():
+            box = QCheckBox(cls.display_name)
+            box.setChecked(True)
+            box.setToolTip(cls.quantity_id)
+            self._checks[cls.quantity_id] = box
+        # Cell density's field-of-view area is a build param with no PositionInputs
+        # field, so it gets its own input beside the density checkbox. Autofilled
+        # from image size x pixel size (see :meth:`_maybe_autofill_fov`); the user
+        # can override, after which autofill leaves it alone.
+        self.fov_field = QDoubleSpinBox()
+        # Entered in µm² (a microscope field is a handful of ×10⁴ µm², which reads
+        # cleanly, where the mm² value would be a long decimal). Converted to the
+        # backend's mm² param in :meth:`_current_params`. 2 decimals is 0.01 µm²
+        # resolution — ample, and no risk of rounding a real area down to zero.
+        self.fov_field.setDecimals(2)
+        self.fov_field.setRange(0.0, 1e12)
+        self.fov_field.setSuffix(" µm²")
+        self.fov_field.setToolTip(
+            "Field-of-view area for Cell density. Autofilled from image size times "
+            "pixel size; edit to override."
+        )
+        self.fov_field.valueChanged.connect(self._on_fov_changed)
+        self.run_btn = QPushButton("Pool ready positions")
+        self.run_btn.clicked.connect(self._on_run)
+        self.progress = QProgressBar()
+        self.progress.setVisible(False)
+        self.results = QListWidget()
+        self.status = QLabel("")
+        self.status.setWordWrap(True)
+        for widget in (self.subtitle, self.readout, self.quantities_label):
+            layout.addWidget(widget)
+        for qid, box in self._checks.items():
+            if qid == "cell_density":
+                row = QHBoxLayout()
+                row.addWidget(box)
+                row.addWidget(QLabel("FOV area (µm²):"))
+                row.addWidget(self.fov_field)
+                row.addStretch()
+                layout.addLayout(row)
+            else:
+                layout.addWidget(box)
+        for widget in (self.run_btn, self.progress, self.results, self.status):
+            layout.addWidget(widget)
+        self._refresh_readout()
+
+    # ------------------------------------------------------------------ inputs
+    def set_records(self, records) -> None:
+        """Replace the catalog records the readiness readout reflects."""
+        self._records = list(records or [])
+        self._maybe_autofill_fov()
+        self._refresh_readout()
+
+    def _current_params(self) -> dict:
+        """The shared build knobs for greying + the run: calibration off the records
+        (pixel size, frame length are global, so the first record is representative)
+        plus the field-of-view area from :attr:`fov_field` (omitted when zero)."""
+        params: dict[str, float] = {}
+        if self._records:
+            first = self._records[0]
+            for key in ("pixel_size_um", "time_interval_s"):
+                value = first.get(key)
+                if value in (None, ""):
+                    continue
+                try:
+                    params[key] = float(value)
+                except (TypeError, ValueError):
+                    pass
+        fov_um2 = self.fov_field.value()
+        if fov_um2 > 0:
+            # The field is µm²; the backend's Cell density param is mm² (density is
+            # reported in cells/mm²).
+            params["fov_area_mm2"] = fov_um2 / 1e6
+        return params
+
+    def _maybe_autofill_fov(self) -> None:
+        """Prefill the FOV field (µm²) from ``image lateral pixels x pixel_size_um²``,
+        reading a ready position's cell-label image. No-ops once the user has edited
+        the field, when no pixel size is set, or when no image is readable."""
+        if self._fov_user_edited:
+            return
+        pixel_size = self._current_params().get("pixel_size_um")
+        if not pixel_size:
+            return
+        ready, _ = partition_ready(self._records)
+        for record in ready:
+            n_pixels = _lateral_pixels(record.get("cell_tracked_labels_path"))
+            if n_pixels:
+                fov_um2 = n_pixels * pixel_size * pixel_size
+                self.fov_field.blockSignals(True)
+                self.fov_field.setValue(fov_um2)
+                self.fov_field.blockSignals(False)
+                return
+
+    def _on_fov_changed(self, _value) -> None:
+        """A user edit to the FOV field: remember it (so autofill backs off) and
+        re-grey, since a non-zero area lifts Cell density into support."""
+        self._fov_user_edited = True
+        self._refresh_quantities(partition_ready(self._records)[0])
+
+    def section_status(self) -> str:
+        """Status for the enclosing section dot: not_started / in_progress / done."""
+        ready, _ = partition_ready(self._records)
+        if not ready:
+            return "not_started"
+        return "done" if self._has_run else "in_progress"
+
+    # --------------------------------------------------------------- rendering
+    def _refresh_readout(self) -> None:
+        ready, not_ready = partition_ready(self._records)
+        total = len(self._records)
+        if total == 0:
+            self.readout.setText("No data folders yet.")
+        else:
+            message = f"{len(ready)} of {total} positions analyzed"
+            if not_ready:
+                names = ", ".join(_position_name(r) for r in not_ready)
+                message += f" — not yet ready: {names}"
+            self.readout.setText(message)
+        self._refresh_quantities(ready)
+        self.run_btn.setEnabled(bool(ready) and self._worker is None)
+
+    def _refresh_quantities(self, ready) -> None:
+        """Enable a quantity's checkbox iff a ready position can produce its table.
+
+        Greys out (disables + unchecks) any quantity whose required inputs/params
+        are absent from every ready position; re-enables and re-checks one that
+        becomes supported again. A deliberate uncheck of a *supported* quantity is
+        preserved: only the supported/unsupported transition touches the check.
+        """
+        supported = supported_quantities(ready, params=self._current_params() or None)
+        for qid, box in self._checks.items():
+            was_enabled = box.isEnabled()
+            now = qid in supported
+            box.setEnabled(now)
+            box.setToolTip(
+                qid
+                if now
+                else f"{qid}: required inputs or parameters not available for any ready position"
+            )
+            if not now:
+                box.setChecked(False)
+            elif not was_enabled:
+                box.setChecked(True)
+
+    def _selected_quantities(self) -> tuple[str, ...]:
+        """The checked quantities to author into the config.
+
+        Collapses to ``()`` (= write every available table) when the user has left
+        every *supported* quantity checked, so a default run writes a clean config;
+        any deliberate uncheck yields the explicit checked subset instead.
+        """
+        checked = {qid for qid, box in self._checks.items() if box.isChecked()}
+        supported = {qid for qid, box in self._checks.items() if box.isEnabled()}
+        return () if checked == supported else tuple(sorted(checked))
+
+    # --------------------------------------------------------------------- run
+    def _on_run(self) -> None:
+        ready, not_ready = partition_ready(self._records)
+        if not ready:
+            show_info("No analyzed positions to pool.")
+            return
+        skipped = [_position_name(r) for r in not_ready]
+        quantities = self._selected_quantities()
+        params = self._current_params()
+        self.results.clear()
+        self.status.setText("Pooling…")
+        self.progress.setVisible(True)
+        self.progress.setRange(0, 0)
+        self.run_btn.setEnabled(False)
+
+        @thread_worker(
+            connect={"returned": self._on_done, "errored": self._on_error}
+        )
+        def _work():
+            return pool_positions(ready, skipped, quantities, params)
+
+        self._worker = _work()
+
+    def _on_done(self, result: dict) -> None:
+        self._worker = None
+        self._has_run = True
+        self.progress.setVisible(False)
+        for name, path in sorted(result["tables"].items()):
+            self.results.addItem(f"{name}: {path}")
+        message = f"Pooled into {result['project_dir']}."
+        if result["skipped"]:
+            message += f" Skipped (not analyzed): {', '.join(result['skipped'])}."
+        self.status.setText(message)
+        show_info(message)
+        self._refresh_readout()
+
+    def _on_error(self, exc: Exception) -> None:
+        self._worker = None
+        self.progress.setVisible(False)
+        self.status.setText(f"Aggregate failed: {exc}")
+        show_error(f"Aggregate failed: {exc}")
+        self._refresh_readout()