itasc 0.2.0.dev0__py3-none-any.whl

itasc/napari/correction/_correction_ui_nucleus.py

@@ -0,0 +1,393 @@
+"""Qt construction for :class:`NucleusCorrectionWidget`.
+
+The widget is large enough that its one-time control assembly — buttons,
+parameter sliders, the embedded :class:`CorrectionWidget`, the reveal sections,
+the toolbar and the signal wiring — is kept here so the widget module is about
+behaviour rather than scaffolding. :func:`build_nucleus_correction_ui` populates
+the passed widget in place (setting the same ``w.<name>`` attributes the rest of
+the class reads), mirroring how the shared header / toolbar builders in
+:mod:`itasc.napari.correction._correction_ui` already work.
+"""
+
+from __future__ import annotations
+
+from qtpy.QtCore import QTimer
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QHBoxLayout,
+    QLabel,
+    QVBoxLayout,
+    QWidget,
+)
+
+from itasc.napari._widget_helpers import (
+    btn as _btn,
+    dslider as _dslider,
+    heading as _heading,
+    make_status as _make_status,
+    tool_btn as _tool_btn,
+)
+from itasc.napari.correction._correction_ui import (
+    build_correction_header,
+    build_correction_toolbar,
+    build_shortcuts_widget,
+    flatten_embedded_section,
+)
+from itasc.napari.ui_style import danger_button
+from itasc.napari.widgets import CollapsibleSection
+from itasc.napari.correction.correction_widget import CorrectionWidget
+
+
+def build_nucleus_correction_ui(w) -> None:
+    """Build and wire all of ``w``'s correction controls (run once from init)."""
+    root = QVBoxLayout(w)
+    root.setContentsMargins(0, 0, 0, 0)
+    root.setSpacing(0)
+
+    _init_candidate_refresh_timer(w)
+
+    inner = QWidget(w)
+    group_lay = QVBoxLayout(inner)
+    group_lay.setContentsMargins(0, 0, 0, 0)
+    group_lay.setSpacing(6)
+
+    _build_action_buttons(w)
+    _build_status_labels(w)
+    _build_correction_subwidget(w)
+    _build_extend_retrack_section(w)
+    _build_shortcuts_section(w)
+    _build_toolbar(w)
+    _build_view_toggle_buttons(w)
+    _assemble_reveal_area(w, group_lay)
+
+    # The full-width top bar carries the title, the activate / shortcuts /
+    # params toggles, the checkable view toggles, and a single one-line
+    # status (the save/action status only) right-aligned. The track /
+    # validated summary lives in the tracking-overview panel instead.
+    w.header, w.header_lbl = build_correction_header(
+        w,
+        shortcuts_btn=w.shortcuts_btn,
+        params_btn=w.params_btn,
+        active_btn=w.active_btn,
+        finalize_btn=getattr(w, "_finalize_header_btn", None),
+        view_toggle_btns=(
+            w.track_path_btn,
+            w.spotlight_btn,
+            w.filled_view_btn,
+        ),
+        status_lbl=w.status_lbl,
+    )
+    # ``section`` is the full-width reveal area (params + shortcuts) shown
+    # below the top bar; both it and the header are reparented between the
+    # plugin dock (inactive) and the workspace dock (active).
+    w.section = CollapsibleSection("Correction", inner, expanded=False)
+    w.section._toggle.setVisible(False)
+    w.section._toggle.setEnabled(False)
+
+    w.correction_active_btn = w.active_btn
+    w.correction_shortcuts_btn = w.shortcuts_btn
+    w.correction_status_lbl = w.status_lbl
+    w.correction_mode_section = w.section
+    w._correction_active_content_visible = False
+    _connect_signals(w)
+    # Start collapsed: the inactive plugin-dock entry point shows only the
+    # on/off button (title + toggles appear once correction is active).
+    w._sync_correction_panel_visibility()
+
+
+def _init_candidate_refresh_timer(w) -> None:
+    # Searching + rendering the candidate gallery is expensive, so debounce
+    # it: every refresh request (re)starts this timer and the actual rebuild
+    # only fires once the frame has been still for the interval — fast
+    # scrubbing no longer recomputes candidates for every frame it sweeps.
+    w._candidate_refresh_timer = QTimer(w)
+    w._candidate_refresh_timer.setSingleShot(True)
+    w._candidate_refresh_timer.setInterval(200)
+    w._candidate_refresh_timer.timeout.connect(w._refresh_candidate_gallery_now)
+
+
+def _build_action_buttons(w) -> None:
+    w.active_btn = _tool_btn(
+        "⏻",
+        "Activate correction mode and show correction layers and controls.",
+        checkable=True,
+    )
+    w.active_btn.setToolTip(
+        "Activate correction mode and show correction layers and controls."
+    )
+    w.params_btn = _tool_btn(
+        "⚙", "Show correction parameters.", checkable=True
+    )
+    w.shortcuts_btn = _tool_btn(
+        "📖", "Show correction shortcuts.", checkable=True
+    )
+
+    w.save_tracked_btn = _tool_btn(
+        "💾", "Save corrected tracked nucleus labels to disk (S)."
+    )
+    w.extend_back_btn = _tool_btn(
+        "◀", "Extend selected track one frame backward (A)."
+    )
+    w.extend_fwd_btn = _tool_btn(
+        "▶", "Extend selected track one frame forward (D)."
+    )
+    w.retrack_back_btn = _tool_btn(
+        "↶", "Retrack all labels backward from current frame (Q)."
+    )
+    w.retrack_fwd_btn = _tool_btn(
+        "↷", "Retrack all labels forward from current frame (E)."
+    )
+    w.swap_smaller_btn = _tool_btn(
+        "⮂", "Swap selected cell with the next smaller candidate fragment (Z)."
+    )
+    w.swap_larger_btn = _tool_btn(
+        "⮀", "Swap selected cell with the next larger candidate fragment (C)."
+    )
+    w.reassign_ids_btn = _tool_btn(
+        "#",
+        "Reassign cell IDs to contiguous range 1-N (validated tracks first, "
+        "then by earliest start frame, then by longest track).",
+    )
+    w.validate_track_btn = _tool_btn(
+        "✓", "Lock selected cell geometry in every frame where it appears (V)."
+    )
+    w.anchor_here_btn = _tool_btn(
+        "⚓", "Anchor selected cell identity at the current frame (B)."
+    )
+    w.annotate_db_btn = _tool_btn(
+        "✎", "Apply saved validations and anchors to the Ultrack database."
+    )
+    w.remove_unvalidated_btn = _tool_btn(
+        "🗑",
+        "Remove nucleus label pixels not marked validated for their frame.",
+    )
+    danger_button(w.remove_unvalidated_btn)
+
+    w.commit_btn = _btn(
+        "Commit",
+        "Reassign cell IDs, remove unvalidated labels, and save tracked labels.",
+    )
+
+
+def _build_status_labels(w) -> None:
+    w.status_lbl = _make_status()
+    # Drop the smaller status font so the status line reads at the same
+    # size as the rest of the controls column. Keep it to a single line so
+    # it never wraps and pushes the top-bar title pill onto two rows.
+    w.status_lbl.setStyleSheet("")
+    w.status_lbl.setWordWrap(False)
+
+    # The track / validated summary now lives in the tracking-overview title
+    # (see LineageCanvasController). This label is kept as a hidden sink so
+    # the existing counter-refresh plumbing keeps working without surfacing
+    # a second status line in the top bar; it is parented (never shown) so
+    # toggling its visibility can't spawn a stray top-level window.
+    w.validation_counter_lbl = QLabel("", w)
+    w.validation_counter_lbl.setVisible(False)
+
+
+def _build_correction_subwidget(w) -> None:
+    w.correction_widget = CorrectionWidget(
+        w.viewer,
+        show_activate_btn=False,
+        show_shortcuts=False,
+        inspector_first=True,
+        show_cleanup=False,
+        # The lineage canvas is the navigation surface now — drop the
+        # redundant "Inspect cell" group from the correction column.
+        show_inspector=False,
+    )
+    w.correction_widget.set_edit_callback(w._edit_callback)
+    w.correction_widget.set_protected_mask_callback(
+        w._manual_correction_protected_mask
+    )
+    w.correction_widget.set_intensity_frame_callback(
+        w._correction_intensity_frame
+    )
+    # Use an additive listener, not set_selection_callback: the workflow
+    # widget owns that single slot and would otherwise clobber the comet's
+    # rebuild-on-selection (so it would only build on first checkbox tick).
+    w.correction_widget.add_selection_listener(
+        w._on_track_selection_changed
+    )
+    w.correction_widget.set_spotlight_mask_provider(
+        w._track_path_spotlight_mask
+    )
+    w.correction_widget._status.setVisible(False)
+
+
+def _build_extend_retrack_section(w) -> None:
+    # Wide-and-short reveal area: each remaining parameter gets its own
+    # column so the sliders spread horizontally across the full-width panel
+    # rather than stacking. Greedy overwrite and the outline view are now
+    # always-on defaults, so neither is surfaced as a control here.
+    extend_retrack_inner = QWidget(w)
+    extend_retrack_lay = QVBoxLayout(extend_retrack_inner)
+    extend_retrack_lay.setContentsMargins(0, 0, 0, 0)
+    extend_retrack_lay.setSpacing(6)
+
+    columns = QHBoxLayout()
+    columns.setContentsMargins(0, 0, 0, 0)
+    columns.setSpacing(16)
+
+    def _column(*items) -> QWidget:
+        col = QWidget()
+        lay = QVBoxLayout(col)
+        lay.setContentsMargins(0, 0, 0, 0)
+        lay.setSpacing(4)
+        for item in items:
+            if isinstance(item, QWidget):
+                lay.addWidget(item)
+            else:
+                lay.addLayout(item)
+        lay.addStretch(1)
+        return col
+
+    # Greedy overwrite is now the always-on default: keep the (hidden)
+    # checkbox checked so the extend/retrack paint paths that read its state
+    # still behave greedily, but drop it from the UI.
+    w.extend_greedy_overwrite_check = QCheckBox("Greedy overwrite")
+    w.extend_greedy_overwrite_check.setChecked(True)
+
+    w.retrack_max_dist_spin = _dslider(0, 500, 20.0, 1.0, 1)
+    # Scoring weights for the retrack frame matcher. Kept under the
+    # ``extend_*`` attribute names for settings back-compat; extend no longer
+    # uses them.
+    w.extend_area_weight_spin = _dslider(0, 10, 1.0, 0.1, 2)
+    w.extend_iou_weight_spin = _dslider(0, 10, 1.0, 0.1, 2)
+    w.extend_distance_weight_spin = _dslider(0, 10, 0.05, 0.01, 3)
+
+    # Each retrack weight + the cell-radius control gets its own column
+    # (stretch=1) so they fan out across the wide reveal area. The cell-radius
+    # slider (middle-click cell creation) is reused straight from the embedded
+    # correction widget, dropped under a plain "Cell Radius" heading so it
+    # matches the other sliders rather than carrying its own inline label.
+    for heading_text, widget in (
+        ("Max distance", w.retrack_max_dist_spin),
+        ("Area weight", w.extend_area_weight_spin),
+        ("IoU weight", w.extend_iou_weight_spin),
+        ("Distance weight", w.extend_distance_weight_spin),
+        ("Cell Radius", w.correction_widget._cell_radius_spin),
+    ):
+        columns.addWidget(_column(_heading(heading_text), widget), stretch=1)
+    extend_retrack_lay.addLayout(columns)
+
+    w.extend_retrack_params_section = CollapsibleSection(
+        "Extend / Retrack Parameters",
+        extend_retrack_inner,
+        expanded=False,
+    )
+    flatten_embedded_section(w.extend_retrack_params_section)
+    w.extend_retrack_params_section.setVisible(False)
+    w.extend_params_section = w.extend_retrack_params_section
+    w.retrack_params_section = w.extend_retrack_params_section
+
+
+def _build_shortcuts_section(w) -> None:
+    # The disclaimer / attribution label rides at the bottom of the wide
+    # shortcuts panel now (reparented out of the embedded correction widget).
+    w.shortcuts_section = CollapsibleSection(
+        "Correction Shortcuts",
+        build_shortcuts_widget(w.correction_widget._attrib_lbl),
+        expanded=False,
+    )
+    flatten_embedded_section(w.shortcuts_section)
+    w.shortcuts_section.setVisible(False)
+    w.correction_widget.setVisible(False)
+
+
+def _build_toolbar(w) -> None:
+    # Extend / swap are driven by clicking into the candidate gallery now,
+    # so they're dropped from the toolbar (the A/D/Z/C shortcuts still work).
+    groups = [
+        (w.save_tracked_btn,),
+        (w.retrack_back_btn, w.retrack_fwd_btn),
+        (w.validate_track_btn, w.anchor_here_btn),
+        (w.annotate_db_btn,),
+        (w.reassign_ids_btn, w.remove_unvalidated_btn),
+    ]
+    # The host workflow widget's Finalize button rides at the tail of the
+    # toolbar (its own ruled group) — finalizing is the natural last step
+    # once the tracks are corrected.
+    if getattr(w, "_finalize_btn", None) is not None:
+        groups.append((w._finalize_btn,))
+    w.toolbar = build_correction_toolbar(w, groups)
+    w.toolbar.setVisible(False)
+
+
+def _build_view_toggle_buttons(w) -> None:
+    # View toggles ride in the top bar as checkable icon tool-buttons; the
+    # old "Lineage canvas" toggle is gone — the accordion is the always-on
+    # main surface. Tooltips carry the longer descriptions the old check
+    # captions spelled out.
+    w.track_path_btn = _tool_btn(
+        "👁",
+        "Track path: paint the selected track's whole trajectory as a fading "
+        "comet (viridis, oldest→newest) with a frame number in each mask.",
+        checkable=True,
+    )
+    w.spotlight_btn = _tool_btn(
+        "🔦",
+        "Spotlight: dim everything outside the selected cell. Off = mark the "
+        "selection with a plain yellow border instead (the rest of the frame "
+        "stays at full brightness).",
+        checkable=True,
+    )
+    # Spotlight is the default selection indicator, so the toggle starts on.
+    w.spotlight_btn.setChecked(True)
+    w.filled_view_btn = _tool_btn(
+        "🎨",
+        "Filled labels (by ID): hide the cell + nucleus images and draw the "
+        "labels and tracks opaque and filled (not outlines), coloured by ID. "
+        "Off = the default outline view in one neutral colour.",
+        checkable=True,
+    )
+    # The candidate gallery is shown/hidden by its own ✕ button + slim
+    # show-tab (see CollapsiblePane), not a top-bar toggle.
+    for button in (w.track_path_btn, w.spotlight_btn, w.filled_view_btn):
+        button.setVisible(False)
+    w.validation_counter_lbl.setVisible(False)
+
+
+def _assemble_reveal_area(w, group_lay: QVBoxLayout) -> None:
+    # The section body is the full-width reveal area below the top bar: the
+    # params and shortcuts panels, openable independently. The toolbar, the
+    # view toggles and the status now live elsewhere (the toolbar in the body
+    # splitter's thin left column, the toggles + status in the top bar). The
+    # embedded correction widget is a logic holder only — its visible bits
+    # (outline + spawn controls, attribution label) were reparented into the
+    # params / shortcuts panels — so it is kept hidden here to stay owned.
+    group_lay.addWidget(w.extend_retrack_params_section)
+    group_lay.addWidget(w.shortcuts_section)
+    w.correction_widget.setVisible(False)
+    group_lay.addWidget(w.correction_widget)
+
+
+def _connect_signals(w) -> None:
+    w.save_tracked_btn.clicked.connect(w._on_save_tracked)
+    w.reassign_ids_btn.clicked.connect(w._on_reassign_ids)
+    w.validate_track_btn.clicked.connect(w._on_validate_track)
+    w.anchor_here_btn.clicked.connect(w._on_anchor_here)
+    w.annotate_db_btn.clicked.connect(w._on_annotate_database)
+    w.extend_back_btn.clicked.connect(w._on_extend_backward)
+    w.extend_fwd_btn.clicked.connect(w._on_extend_forward)
+    w.retrack_back_btn.clicked.connect(w._on_retrack_backward)
+    w.retrack_fwd_btn.clicked.connect(w._on_retrack_forward)
+    w.swap_smaller_btn.clicked.connect(
+        lambda: w._on_swap_step(direction="smaller")
+    )
+    w.swap_larger_btn.clicked.connect(
+        lambda: w._on_swap_step(direction="larger")
+    )
+    w.remove_unvalidated_btn.clicked.connect(w._on_remove_unvalidated_labels)
+    w.commit_btn.clicked.connect(w._on_commit)
+    w.track_path_btn.toggled.connect(w._on_toggle_track_path)
+    w.spotlight_btn.toggled.connect(w._on_toggle_spotlight)
+    w.filled_view_btn.toggled.connect(w._on_toggle_filled_view)
+    w.params_btn.toggled.connect(w._on_correction_params_button_toggled)
+    w.shortcuts_btn.toggled.connect(w._on_correction_shortcuts_button_toggled)
+    w.active_btn.toggled.connect(w._on_correction_active_button_toggled)
+    w.correction_widget._activate_btn.toggled.connect(
+        w._on_correction_mode_toggled
+    )
+    w._install_correction_shortcuts()

itasc/napari/correction/_correction_utils.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class RetrackDirectionResult:
+    stack: np.ndarray
+    n_retracked: int
+    n_skipped: int
+    first_target_frame: int
+
+
+def frame_view_2d(arr: np.ndarray, t: int) -> np.ndarray | None:
+    """Return frame *t* as a 2D view when the stack shape is unambiguous."""
+    if arr.ndim < 3 or t < 0 or t >= arr.shape[0]:
+        return None
+    view = arr[t]
+    while view.ndim > 2:
+        if view.shape[0] != 1:
+            return None
+        view = view[0]
+    return view
+
+
+def reassign_ids_ordered(
+    stack: np.ndarray, order: list[int]
+) -> tuple[np.ndarray, int, dict[int, int]]:
+    """Relabel non-zero IDs to contiguous IDs from 1, following *order*.
+
+    Old IDs listed in *order* are assigned new IDs first (best → 1, next → 2,
+    …); any present IDs not in *order* follow in ascending order. Passing an
+    empty *order* reproduces plain numeric compaction.
+    """
+    unique_ids = np.unique(stack)
+    unique_ids = unique_ids[unique_ids != 0]
+    if unique_ids.size == 0:
+        return stack, 0, {}
+    present = {int(x) for x in unique_ids}
+    seen: set[int] = set()
+    ordered_ids: list[int] = []
+    for old_id in order:
+        old_id = int(old_id)
+        if old_id in present and old_id not in seen:
+            ordered_ids.append(old_id)
+            seen.add(old_id)
+    ordered_ids.extend(sorted(present - seen))
+    lut = np.zeros(int(unique_ids.max()) + 1, dtype=np.uint32)
+    old_to_new: dict[int, int] = {}
+    for new_id, old_id in enumerate(ordered_ids, start=1):
+        lut[old_id] = new_id
+        old_to_new[old_id] = new_id
+    return lut[stack], len(ordered_ids), old_to_new
+
+
+def track_order_by_frame_and_size(
+    stack: np.ndarray, priority_ids: Iterable[int] = ()
+) -> list[int]:
+    """Order present track IDs for ID reassignment.
+
+    Tracks listed in *priority_ids* (e.g. validated tracks) form the first
+    group and the remaining present tracks the second; the two groups stay
+    separate so validated tracks always receive the lower IDs. Within each
+    group, IDs are sorted by starting frame (earliest first), then by track
+    length in frames (longest first), with the numeric ID as a final tiebreaker
+    for determinism.
+    """
+    stack = np.asarray(stack)
+    frames = stack if stack.ndim >= 3 else stack[None, ...]
+    start_frame: dict[int, int] = {}
+    length: dict[int, int] = {}
+    for t, frame in enumerate(frames):
+        for cid in np.unique(frame):
+            cid = int(cid)
+            if cid == 0:
+                continue
+            start_frame.setdefault(cid, t)
+            length[cid] = length.get(cid, 0) + 1
+
+    def sort_key(cid: int) -> tuple[int, int, int]:
+        return (start_frame[cid], -length[cid], cid)
+
+    present = set(start_frame)
+    priority = {int(cid) for cid in priority_ids} & present
+    return sorted(priority, key=sort_key) + sorted(present - priority, key=sort_key)
+
+
+def reassign_ids_stack(stack: np.ndarray) -> tuple[np.ndarray, int, dict[int, int]]:
+    """Compact non-zero label IDs in a stack to contiguous IDs from 1."""
+    return reassign_ids_ordered(stack, [])
+
+
+def reorder_stack_by_quality(
+    stack: np.ndarray,
+    scores: Mapping[int, float],
+    pos_dir: str | Path | None = None,
+) -> tuple[np.ndarray, dict[int, int]]:
+    """Relabel a tracked stack so track IDs follow quality order, best → 1.
+
+    *scores* maps track_id -> quality score (see
+    :func:`itasc.tracking_ultrack.track_quality.track_quality_scores`). When
+    *pos_dir* is given, existing validations/anchors are remapped onto the new
+    IDs so prior work stays attached. Returns ``(relabeled_stack, old_to_new)``;
+    a no-op (empty mapping, original array) when there is nothing to reorder.
+    """
+    from itasc.tracking_ultrack.track_quality import quality_order
+
+    stack = np.asarray(stack)
+    order = quality_order(scores) if scores else []
+    if not order:
+        return stack, {}
+    relabeled, _n, old_to_new = reassign_ids_ordered(
+        stack.astype(np.uint32, copy=False), order
+    )
+    if old_to_new and pos_dir is not None:
+        from itasc.tracking_ultrack.validation_state import remap_validated_tracks
+
+        remap_validated_tracks(Path(pos_dir), old_to_new)
+    return relabeled, old_to_new
+
+
+def remove_unvalidated_labels(
+    data: np.ndarray,
+    validated_tracks: dict[int, set[int]],
+) -> tuple[int, int]:
+    """Remove labels not validated for their frame from a 2D or time-first stack."""
+    frame_count = int(data.shape[0]) if data.ndim >= 3 else 1
+    changed_pixels = changed_frames = 0
+    for t in range(frame_count):
+        frame = data[t] if data.ndim >= 3 else data
+        if frame.ndim != 2:
+            raise ValueError("Tracked layer must be a time-first stack.")
+        validated_ids = {
+            cid for cid, frames in validated_tracks.items() if t in frames
+        }
+        remove_mask = frame != 0
+        if validated_ids:
+            remove_mask &= ~np.isin(frame, list(validated_ids))
+        n_remove = int(np.count_nonzero(remove_mask))
+        if not n_remove:
+            continue
+        frame[remove_mask] = 0
+        changed_pixels += n_remove
+        changed_frames += 1
+    return changed_frames, changed_pixels
+
+
+def retrack_stack_direction(
+    stack: np.ndarray,
+    *,
+    start_frame: int,
+    direction: Literal["forward", "backward"],
+    fully_validated_frames: set[int],
+    validated_cells_at_frame: Callable[[int], set[int]],
+    retrack_frame: Callable[..., np.ndarray],
+    max_dist_px: float,
+    reserved_ids: set[int],
+    area_weight: float = 1.0,
+    iou_weight: float = 1.0,
+    distance_weight: float = 0.05,
+) -> RetrackDirectionResult:
+    """Retrack a time-first stack in one direction, skipping validated frames."""
+    if stack.ndim != 3 or stack.shape[0] < 2:
+        raise ValueError("Tracked layer must be a 3D time-first stack.")
+
+    out = stack.copy()
+    n_retracked = n_skipped = 0
+    if direction == "forward":
+        frame_range = range(start_frame + 1, out.shape[0])
+        previous_frame = lambda t: out[t - 1]
+    elif direction == "backward":
+        frame_range = range(start_frame - 1, -1, -1)
+        previous_frame = lambda t: out[t + 1]
+    else:
+        raise ValueError(f"Unknown retrack direction: {direction!r}")
+
+    first_target_frame = next(iter(frame_range), start_frame)
+    for t in frame_range:
+        if t in fully_validated_frames:
+            n_skipped += 1
+            continue
+        out[t] = retrack_frame(
+            previous_frame(t),
+            out[t],
+            validated_cells_at_frame(t),
+            max_dist_px=max_dist_px,
+            reserved_ids=reserved_ids,
+            area_weight=area_weight,
+            iou_weight=iou_weight,
+            distance_weight=distance_weight,
+        )
+        n_retracked += 1
+
+    return RetrackDirectionResult(
+        stack=out,
+        n_retracked=n_retracked,
+        n_skipped=n_skipped,
+        first_target_frame=first_target_frame,
+    )

itasc/napari/correction/_correction_validation.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from itasc.napari.correction._correction_utils import frame_view_2d
+from itasc.tracking_ultrack.corrections import Correction
+
+
+@dataclass(frozen=True)
+class SelectedCorrectionTarget:
+    cell_id: int
+    frame: int
+    y: float
+    x: float
+
+
+def selected_correction_target(
+    data: np.ndarray,
+    *,
+    cell_id: int,
+    frame: int,
+) -> SelectedCorrectionTarget | None:
+    """Return the selected cell centroid at *frame* when present."""
+    frame_view = _label_frame(data, frame)
+    if frame_view is None or not np.any(frame_view == cell_id):
+        return None
+    y, x = _label_centroid(frame_view, cell_id)
+    return SelectedCorrectionTarget(
+        cell_id=int(cell_id),
+        frame=int(frame),
+        y=y,
+        x=x,
+    )
+
+
+def correction_for_label_frame(
+    data: np.ndarray,
+    *,
+    cell_id: int,
+    frame: int,
+) -> Correction | None:
+    """Build a validated correction for *cell_id* at *frame* when present."""
+    target = selected_correction_target(data, cell_id=cell_id, frame=frame)
+    if target is None:
+        return None
+    return Correction(
+        cell_id=target.cell_id,
+        t=target.frame,
+        kind="validated",
+        y=target.y,
+        x=target.x,
+    )
+
+
+def corrections_for_label_frames(
+    data: np.ndarray,
+    *,
+    cell_id: int,
+    frames: list[int] | tuple[int, ...],
+) -> list[Correction]:
+    """Build validated corrections for frames where *cell_id* is present."""
+    corrections: list[Correction] = []
+    for frame in frames:
+        correction = correction_for_label_frame(
+            data,
+            cell_id=cell_id,
+            frame=int(frame),
+        )
+        if correction is not None:
+            corrections.append(correction)
+    return corrections
+
+
+def _label_frame(data: np.ndarray, frame: int) -> np.ndarray | None:
+    arr = np.asarray(data)
+    return frame_view_2d(arr, frame) if arr.ndim >= 3 else arr
+
+
+def _label_centroid(frame: np.ndarray, cell_id: int) -> tuple[float, float]:
+    yy, xx = np.nonzero(frame == cell_id)
+    return float(np.mean(yy)), float(np.mean(xx))