itasc 0.2.0.dev0__py3-none-any.whl

itasc/napari/correction/__init__.py

@@ -0,0 +1,8 @@
+"""Interactive label-correction subsystem for the ITASC napari plugin.
+
+Groups the correction widgets (:mod:`correction_widget`,
+:mod:`nucleus_correction_widget`, :mod:`cell_correction_widget`) and their
+``_correction_*`` helper modules. Importers use the fully-qualified
+``itasc.napari.correction.<module>`` path; this package intentionally
+re-exports nothing so the module boundaries stay explicit.
+"""

itasc/napari/correction/_correction_anchor.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from itasc.tracking_ultrack.corrections import Correction
+
+
+@dataclass(frozen=True)
+class AnchorRemovalResult:
+    remaining: list[Correction]
+    removed: bool
+
+
+def without_anchor_correction(
+    corrections: Iterable[Correction],
+    *,
+    cell_id: int,
+    frame: int,
+) -> AnchorRemovalResult:
+    """Return corrections with the matching anchor removed, if present."""
+    selected_cell_id = int(cell_id)
+    selected_frame = int(frame)
+    original = list(corrections)
+    remaining = [
+        correction
+        for correction in original
+        if not (
+            int(correction.cell_id) == selected_cell_id
+            and int(correction.t) == selected_frame
+            and correction.kind == "anchor"
+        )
+    ]
+    return AnchorRemovalResult(
+        remaining=remaining,
+        removed=len(remaining) != len(original),
+    )
+
+
+def anchor_correction(
+    *,
+    cell_id: int,
+    frame: int,
+    y: float,
+    x: float,
+) -> Correction:
+    """Build an anchor correction for the selected cell and frame."""
+    return Correction(
+        cell_id=int(cell_id),
+        t=int(frame),
+        kind="anchor",
+        y=float(y),
+        x=float(x),
+    )

itasc/napari/correction/_correction_candidate_panel.py

@@ -0,0 +1,259 @@
+"""Qt view for the extend / swap candidate galleries.
+
+Three :class:`CandidateColumn` blocks are stacked top-to-bottom — extend-backward
+· swap · extend-forward — each a titled block whose clickable thumbnails (built
+from a :class:`~itasc.napari.correction._correction_candidates.CandidateStrip`) flow
+left→right and wrap onto new rows. The whole strip scrolls as one. Clicking a
+thumbnail emits ``candidate_activated(which, key)`` so the controller can apply
+that extend/swap; the pixels themselves come from the pure builder, so this stays
+a thin view. ``rgb_to_qimage`` is the only import-safe symbol without a running
+QApplication.
+"""
+from __future__ import annotations
+
+from qtpy.QtCore import Qt, Signal
+from qtpy.QtGui import QPixmap
+from qtpy.QtWidgets import (
+    QFrame,
+    QLabel,
+    QScrollArea,
+    QSplitter,
+    QVBoxLayout,
+    QWidget,
+)
+
+from itasc.napari.correction._correction_candidates import CandidateStrip, CandidateTile
+from itasc.napari.correction._correction_track_accordion import rgb_to_qimage
+from itasc.napari._flow_layout import FlowLayout
+
+_TILE_PX = 64
+_TILE_PX_MIN = 20
+_TILE_PX_MAX = 256
+_ZOOM_STEP = 8       # px added/removed from the tile size per Ctrl+wheel notch
+
+# Draggable handle between the stacked regions. Mirrors the workspace splitter
+# that sizes the strip widths (see nucleus_correction_widget), but oriented
+# vertically: a mid-grey grip inset against the dark dock background. Qt adds
+# the border *on top of* the handle width for vertical handles (it insets it for
+# horizontal ones), so to land the same ~10 px total thickness as the workspace
+# grabbers we pair a 3 px border with a thin handle width (see _HANDLE_WIDTH).
+_HANDLE_STYLE = (
+    "QSplitter::handle:vertical {"
+    " background: #5a606b;"
+    " border-top: 3px solid #2e3440;"
+    " border-bottom: 3px solid #2e3440;"
+    " }"
+    "QSplitter::handle:vertical:hover { background: #7a828f; }"
+)
+_HANDLE_WIDTH = 2
+
+
+class _ClickableTile(QFrame):
+    """One candidate thumbnail + caption that reports its key when clicked."""
+
+    clicked = Signal(int)
+
+    def __init__(
+        self, tile: CandidateTile, *, tile_px: int, parent: QWidget | None = None
+    ) -> None:
+        super().__init__(parent)
+        self._key = int(tile.key)
+        self.setObjectName("candidateTile")
+        self.setCursor(Qt.PointingHandCursor)
+        self.setToolTip(f"{tile.caption} — click to apply")
+        self.setStyleSheet(
+            "QFrame#candidateTile { border: 1px solid transparent; }"
+            "QFrame#candidateTile:hover { border: 1px solid #ffd246; }"
+        )
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(1, 1, 1, 1)
+        lay.setSpacing(0)
+
+        pixmap = QPixmap.fromImage(rgb_to_qimage(tile.rgb)).scaledToHeight(
+            tile_px, Qt.FastTransformation
+        )
+        image = QLabel()
+        image.setPixmap(pixmap)
+        image.setAlignment(Qt.AlignCenter)
+        lay.addWidget(image)
+
+    @property
+    def key(self) -> int:
+        return self._key
+
+    def mouseReleaseEvent(self, event) -> None:
+        super().mouseReleaseEvent(event)
+        if event.button() == Qt.LeftButton and self.rect().contains(event.pos()):
+            self.clicked.emit(self._key)
+
+
+class CandidateColumn(QWidget):
+    """A titled block whose candidate thumbnails flow left→right and wrap."""
+
+    candidate_clicked = Signal(int)  # key
+
+    def __init__(
+        self, title: str = "", parent: QWidget | None = None, *, tile_px: int = _TILE_PX
+    ) -> None:
+        super().__init__(parent)
+        self._tile_px = int(tile_px)
+        self._title_text = title
+        self._strip = CandidateStrip()
+
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(0, 0, 0, 0)
+        outer.setSpacing(2)
+
+        self._title = QLabel(title)
+        self._title.setContentsMargins(4, 2, 4, 2)
+        outer.addWidget(self._title)
+
+        self._body = QWidget()
+        self._body_lay = FlowLayout(self._body, margin=1, h_spacing=1, v_spacing=1)
+        outer.addWidget(self._body)
+        # Pin content to the top so a region dragged taller than its tiles
+        # leaves empty space at the bottom rather than floating them centred.
+        outer.addStretch(1)
+
+    def set_strip(self, strip: CandidateStrip, *, title: str | None = None) -> None:
+        """Replace the column's thumbnails (an empty strip shows a placeholder)."""
+        self._strip = strip
+        if title is not None:
+            self._title_text = title
+        self._rebuild()
+
+    def set_tile_size(self, tile_px: int) -> None:
+        """Change the thumbnail size and re-render the column's tiles."""
+        tile_px = max(_TILE_PX_MIN, min(int(tile_px), _TILE_PX_MAX))
+        if tile_px == self._tile_px:
+            return
+        self._tile_px = tile_px
+        self._rebuild()
+
+    def clear(self) -> None:
+        self.set_strip(CandidateStrip())
+
+    def tiles(self) -> list[_ClickableTile]:
+        """The live tile widgets, for tests and hit-testing."""
+        out: list[_ClickableTile] = []
+        for i in range(self._body_lay.count()):
+            widget = self._body_lay.itemAt(i).widget()
+            if isinstance(widget, _ClickableTile):
+                out.append(widget)
+        return out
+
+    def _clear_body(self) -> None:
+        for i in reversed(range(self._body_lay.count())):
+            item = self._body_lay.takeAt(i)
+            widget = item.widget() if item is not None else None
+            if widget is not None:
+                widget.deleteLater()
+
+    def _rebuild(self) -> None:
+        self._clear_body()
+        n = len(self._strip.tiles)
+        self._title.setText(
+            f"{self._title_text} ({n})" if self._title_text else str(n)
+        )
+        if n == 0:
+            placeholder = QLabel("—")
+            placeholder.setAlignment(Qt.AlignCenter)
+            placeholder.setStyleSheet("color: #707070;")
+            self._body_lay.addWidget(placeholder)
+            return
+        for tile in self._strip.tiles:
+            widget = _ClickableTile(tile, tile_px=self._tile_px, parent=self._body)
+            widget.clicked.connect(self.candidate_clicked)
+            self._body_lay.addWidget(widget)
+
+
+class CandidateGalleryPanel(QWidget):
+    """Three stacked candidate blocks: extend-backward · swap · extend-forward.
+
+    The blocks stack top-to-bottom inside a vertical :class:`QSplitter`, so a
+    draggable handle between each pair resizes the regions (the same grip style
+    as the workspace strip-width splitter). Each block scrolls independently
+    when its thumbnails overflow the height it has been given, and wraps them
+    onto new rows (see :class:`CandidateColumn`).
+    """
+
+    EXTEND_BACKWARD = "extend_backward"
+    SWAP = "swap"
+    EXTEND_FORWARD = "extend_forward"
+
+    # (which, key) — which column, and the candidate's routing key.
+    candidate_activated = Signal(str, int)
+
+    def __init__(self, parent: QWidget | None = None, *, tile_px: int = _TILE_PX) -> None:
+        super().__init__(parent)
+        self._tile_px = int(tile_px)
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(0, 0, 0, 0)
+        outer.setSpacing(0)
+
+        splitter = QSplitter(Qt.Vertical, self)
+        splitter.setChildrenCollapsible(False)
+        splitter.setHandleWidth(_HANDLE_WIDTH)
+        splitter.setStyleSheet(_HANDLE_STYLE)
+
+        self._columns: dict[str, CandidateColumn] = {}
+        for which, title in (
+            (self.EXTEND_BACKWARD, "◀ Extend"),
+            (self.SWAP, "Swap"),
+            (self.EXTEND_FORWARD, "Extend ▶"),
+        ):
+            column = CandidateColumn(title, tile_px=tile_px)
+            column.candidate_clicked.connect(
+                lambda key, _which=which: self.candidate_activated.emit(_which, int(key))
+            )
+            self._columns[which] = column
+
+            pane = _GalleryScroll(self)
+            pane.setWidgetResizable(True)
+            pane.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            pane.setWidget(column)
+            splitter.addWidget(pane)
+
+        # Start the three regions at equal height; the user drags from there.
+        splitter.setSizes([1, 1, 1])
+        self._splitter = splitter
+        outer.addWidget(splitter)
+
+    def column(self, which: str) -> CandidateColumn:
+        return self._columns[which]
+
+    def set_column(self, which: str, strip: CandidateStrip) -> None:
+        self._columns[which].set_strip(strip)
+
+    def set_tile_size(self, tile_px: int) -> None:
+        """Resize every column's thumbnails (Ctrl+wheel zoom, like the film strip)."""
+        tile_px = max(_TILE_PX_MIN, min(int(tile_px), _TILE_PX_MAX))
+        if tile_px == self._tile_px:
+            return
+        self._tile_px = tile_px
+        for column in self._columns.values():
+            column.set_tile_size(tile_px)
+
+    def clear(self) -> None:
+        for column in self._columns.values():
+            column.clear()
+
+
+class _GalleryScroll(QScrollArea):
+    """Per-region scroll area whose Ctrl+wheel zooms the gallery thumbnails."""
+
+    def __init__(self, panel: CandidateGalleryPanel) -> None:
+        super().__init__(panel)
+        self._panel = panel
+
+    def wheelEvent(self, event) -> None:
+        if event.modifiers() & Qt.ControlModifier:
+            step = _ZOOM_STEP if event.angleDelta().y() > 0 else -_ZOOM_STEP
+            self._panel.set_tile_size(self._panel._tile_px + step)
+            event.accept()
+            return
+        super().wheelEvent(event)
+
+
+__all__ = ["CandidateColumn", "CandidateGalleryPanel"]

itasc/napari/correction/_correction_candidates.py

@@ -0,0 +1,169 @@
+"""Build thumbnail strips for extend / swap *candidates* at a single frame.
+
+The correction workspace shows three side-by-side galleries — extend-backward,
+swap, extend-forward — each a column of clickable thumbnails of the alternative
+segmentations on offer. Where :func:`build_track_film_strip` crops one track
+*across frames*, this crops a set of *candidate masks on one frame*: each
+candidate is a full-frame boolean mask (from ``list_swap_candidates`` or
+``list_extend_candidates``), rendered through the shared
+:func:`~itasc.napari.correction._correction_track_path.render_crop_tile` so a candidate
+thumbnail reads identically to a film-strip tile.
+
+Pure module: no Qt, no napari, so it is unit-testable on its own. The view half
+(a clickable column) and the controller that maps a click back to an apply live
+elsewhere.
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from itasc.napari.correction._correction_track_path import render_crop_tile
+
+# Neutral outline when the caller does not pass the selected track's colour.
+_DEFAULT_OUTLINE = (0.75, 0.75, 0.75)
+
+
+@dataclass(frozen=True)
+class CandidateSpec:
+    """One candidate to render: a routing ``key`` and its full-frame mask.
+
+    ``key`` is whatever the controller needs to apply the candidate later (the
+    node id for swap, the candidate label for extend); ``caption`` overrides the
+    default ``"<area> px"`` label when the caller has something better to show.
+    """
+
+    key: int
+    mask: np.ndarray            # (H, W) bool, full frame
+    caption: str = ""
+
+
+@dataclass(frozen=True)
+class CandidateTile:
+    """One rendered candidate thumbnail plus the metadata the view shows."""
+
+    key: int
+    rgb: np.ndarray             # (size, size, 3) uint8
+    area: int
+    caption: str
+
+    @property
+    def height(self) -> int:
+        return self.rgb.shape[0]
+
+    @property
+    def width(self) -> int:
+        return self.rgb.shape[1]
+
+
+@dataclass(frozen=True)
+class CandidateStrip:
+    """The rendered candidate tiles for one gallery column, in input order."""
+
+    tiles: tuple[CandidateTile, ...] = field(default_factory=tuple)
+
+    def is_empty(self) -> bool:
+        return len(self.tiles) == 0
+
+    @property
+    def keys(self) -> tuple[int, ...]:
+        return tuple(tile.key for tile in self.tiles)
+
+
+def _mask_centroid_extent(mask: np.ndarray) -> tuple[int, int, int] | None:
+    """``(cy, cx, extent)`` of ``mask``; ``None`` for an empty mask."""
+    ys, xs = np.nonzero(mask)
+    if ys.size == 0:
+        return None
+    cy = int(round(float(ys.mean())))
+    cx = int(round(float(xs.mean())))
+    extent = max(int(ys.max() - ys.min()) + 1, int(xs.max() - xs.min()) + 1)
+    return cy, cx, extent
+
+
+def build_candidate_strip(
+    intensity_2d: np.ndarray,
+    specs: Sequence[CandidateSpec],
+    *,
+    margin: int = 6,
+    colormap=None,
+    outline_color: tuple[float, float, float] | None = None,
+    outline_width: int = 2,
+    spotlight_dim: float = 0.35,
+    spotlight_dilation: int = 2,
+) -> CandidateStrip:
+    """Render ``specs`` as uniform, mask-centered thumbnails over ``intensity_2d``.
+
+    Every tile is a fixed square window (sized to the largest candidate plus
+    ``margin``) centered on that candidate's centroid, so the cell stays put in
+    the middle of each thumbnail. Contrast is stretched once against the union of
+    all candidate pixels (so the gallery is comparable tile-to-tile) and the mask
+    is spotlighted with an inner-edge ``outline_color`` border (a neutral grey if
+    ``None``). Empty masks are skipped; an empty ``specs`` yields an empty strip.
+    """
+    intensity = np.asarray(intensity_2d)
+    if intensity.ndim != 2:
+        raise ValueError(f"intensity_2d must be 2D, got {intensity.ndim}D")
+    shape = intensity.shape
+
+    kept: list[tuple[CandidateSpec, np.ndarray, int, int]] = []
+    extents: list[int] = []
+    for spec in specs:
+        mask = np.asarray(spec.mask, dtype=bool)
+        if mask.shape != shape:
+            raise ValueError(
+                f"candidate mask shape {mask.shape} != intensity shape {shape}"
+            )
+        ce = _mask_centroid_extent(mask)
+        if ce is None:
+            continue
+        cy, cx, extent = ce
+        kept.append((spec, mask, cy, cx))
+        extents.append(extent)
+    if not kept:
+        return CandidateStrip(tiles=())
+
+    size = int(max(extents)) + 2 * margin
+
+    # Shared contrast over every candidate's pixels, so brighter/dimmer fragments
+    # are judged on the same scale rather than each self-normalising.
+    pooled = np.concatenate([intensity[mask] for _, mask, _, _ in kept]).astype(float)
+    if pooled.size:
+        lo = float(np.percentile(pooled, 2.0))
+        hi = float(np.percentile(pooled, 98.0))
+    else:  # pragma: no cover - kept implies non-empty masks
+        lo, hi = 0.0, 1.0
+
+    color = outline_color if outline_color is not None else _DEFAULT_OUTLINE
+
+    tiles: list[CandidateTile] = []
+    for spec, mask, cy, cx in kept:
+        rgb = render_crop_tile(
+            intensity,
+            mask,
+            cy,
+            cx,
+            size,
+            lo=lo,
+            hi=hi,
+            colormap=colormap,
+            outline_color=color,
+            outline_width=outline_width,
+            spotlight_dim=spotlight_dim,
+            spotlight_dilation=spotlight_dilation,
+        )
+        area = int(mask.sum())
+        tiles.append(
+            CandidateTile(
+                key=int(spec.key),
+                rgb=rgb,
+                area=area,
+                caption=spec.caption or f"{area} px",
+            )
+        )
+    return CandidateStrip(tiles=tuple(tiles))
+
+
+__all__ = ["CandidateSpec", "CandidateTile", "CandidateStrip", "build_candidate_strip"]

itasc/napari/correction/_correction_centroids.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import numpy as np
+
+
+# Uniform white used for the focused track's current-frame tip cross.
+FOCUS_CROSS_COLOR = (1.0, 1.0, 1.0, 1.0)
+
+# Single neutral colour shared by the labels outline and the all-tracks overview
+# in the default ("outline") view. A saturated green reads clearly against both
+# the white cell z-avg and the purple nucleus z-avg, where per-id colours were
+# just noise on the thin outlines. The filled (by-id) view uses the per-id
+# colormap instead — see ``correction_label_color_map`` / the tracks controller.
+NEUTRAL_OVERLAY_COLOR = (0.18, 0.95, 0.32, 1.0)
+
+
+def neutral_label_color_map() -> dict[int | None, tuple[float, float, float, float] | str]:
+    """Colour every non-zero label with the single :data:`NEUTRAL_OVERLAY_COLOR`.
+
+    The ``None`` key is napari's catch-all default colour, so every label maps to
+    the neutral colour without enumerating ids; ``0`` stays transparent.
+    """
+    return {None: NEUTRAL_OVERLAY_COLOR, 0: "transparent"}
+
+
+def apply_neutral_label_colormap(
+    labels_layer: Any,
+) -> dict[int | None, tuple[float, float, float, float] | str]:
+    """Set a labels layer to the single-colour neutral colormap; return the dict."""
+    color_map = neutral_label_color_map()
+    try:
+        from napari.utils.colormaps import DirectLabelColormap
+
+        labels_layer.colormap = DirectLabelColormap(color_dict=dict(color_map))
+    except Exception:
+        pass
+    return color_map
+
+
+def correction_label_color_map(
+    labels: np.ndarray,
+    *,
+    color_scale: float = 0.65,
+) -> dict[int | None, tuple[float, float, float, float] | str]:
+    """Return deterministic non-black colors for labels present in *labels*."""
+    labels_arr = np.asarray(labels)
+    label_ids = sorted(int(value) for value in np.unique(labels_arr) if int(value) != 0)
+    color_map: dict[int | None, tuple[float, float, float, float] | str] = {
+        None: "transparent",
+        0: "transparent",
+    }
+    for label_id in label_ids:
+        rgba = _label_color(label_id)
+        rgba[:3] *= float(color_scale)
+        color_map[label_id] = tuple(float(channel) for channel in rgba)
+    return color_map
+
+
+def refresh_label_colormap(
+    labels_layer: Any,
+    labels: np.ndarray,
+    *,
+    color_scale: float = 0.65,
+) -> dict[int | None, tuple[float, float, float, float] | str]:
+    """Refresh a labels layer colormap and return the color dictionary."""
+    color_map = correction_label_color_map(labels, color_scale=color_scale)
+    try:
+        from napari.utils.colormaps import DirectLabelColormap
+
+        labels_layer.colormap = DirectLabelColormap(color_dict=color_map)
+    except Exception:
+        pass
+    return color_map
+
+
+def ensure_label_colormap_entries(
+    labels_layer: Any,
+    label_ids: Iterable[int],
+    *,
+    color_scale: float = 0.65,
+) -> dict[int | None, tuple[float, float, float, float] | str]:
+    """Ensure a labels layer has deterministic colors for the supplied IDs."""
+    color_map = _existing_color_dict(labels_layer)
+    for label_id in label_ids:
+        label_id = int(label_id)
+        if label_id == 0:
+            continue
+        rgba = _label_color(label_id)
+        rgba[:3] *= float(color_scale)
+        color_map[label_id] = tuple(float(channel) for channel in rgba)
+    try:
+        from napari.utils.colormaps import DirectLabelColormap
+
+        labels_layer.colormap = DirectLabelColormap(color_dict=color_map)
+    except Exception:
+        pass
+    return color_map
+
+
+def _existing_color_dict(
+    labels_layer: Any,
+) -> dict[int | None, tuple[float, float, float, float] | str]:
+    color_map: dict[int | None, tuple[float, float, float, float] | str] = {
+        None: "transparent",
+        0: "transparent",
+    }
+    raw = getattr(getattr(labels_layer, "colormap", None), "color_dict", None)
+    if isinstance(raw, Mapping):
+        color_map.update(raw)
+    return color_map
+
+
+# Per-id label colours reuse napari's own default labels palette (the cyclic
+# colormap a Labels layer is coloured with out of the box) so the nuclei read
+# with the same well-spread, high-contrast hues napari uses everywhere else.
+# The tracks layer mirrors these exact colours by reading the labels layer's
+# colour dict back (see the tracks controller).
+_LABEL_CMAP = None
+
+
+def _label_color(label_id: int) -> np.ndarray:
+    """RGBA for *label_id* from napari's default cyclic labels colormap."""
+    global _LABEL_CMAP
+    if _LABEL_CMAP is None:
+        from napari.utils.colormaps import label_colormap
+
+        _LABEL_CMAP = label_colormap()
+    rgba = _LABEL_CMAP.map(np.asarray([int(label_id)]))[0]
+    return np.asarray(rgba, dtype=float)

itasc/napari/correction/_correction_commit.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from itasc.napari.correction._correction_utils import (
+    reassign_ids_stack,
+    remove_unvalidated_labels,
+)
+
+
+@dataclass(frozen=True)
+class RemoveUnvalidatedResult:
+    changed_frames: int
+    changed_pixels: int
+
+
+@dataclass(frozen=True)
+class CommitLabelsResult:
+    stack: np.ndarray
+    n_cells: int
+    old_to_new: dict[int, int]
+    validated_tracks: dict[int, set[int]]
+    changed_frames: int
+    changed_pixels: int
+
+
+def remove_unvalidated_from_data(
+    data: np.ndarray,
+    validated_tracks: dict[int, set[int]],
+) -> RemoveUnvalidatedResult:
+    """Remove unvalidated labels from *data* in-place."""
+    changed_frames, changed_pixels = remove_unvalidated_labels(
+        data,
+        validated_tracks,
+    )
+    return RemoveUnvalidatedResult(
+        changed_frames=changed_frames,
+        changed_pixels=changed_pixels,
+    )
+
+
+def prepare_committed_labels(
+    data: np.ndarray,
+    validated_tracks: dict[int, set[int]],
+) -> CommitLabelsResult:
+    """Return committed labels after ID compaction and validation filtering."""
+    remapped, n_cells, old_to_new = reassign_ids_stack(np.asarray(data))
+    remapped_validated = remap_validated_track_ids(validated_tracks, old_to_new)
+    removal = remove_unvalidated_from_data(remapped, remapped_validated)
+    return CommitLabelsResult(
+        stack=remapped,
+        n_cells=int(n_cells),
+        old_to_new=old_to_new,
+        validated_tracks=remapped_validated,
+        changed_frames=removal.changed_frames,
+        changed_pixels=removal.changed_pixels,
+    )
+
+
+def remap_validated_track_ids(
+    validated_tracks: dict[int, set[int]],
+    old_to_new: dict[int, int],
+) -> dict[int, set[int]]:
+    """Remap validated-track IDs using the same drop-missing policy as the DB store."""
+    return {
+        int(old_to_new[int(cell_id)]): set(frames)
+        for cell_id, frames in validated_tracks.items()
+        if int(cell_id) in old_to_new
+    }