tk-rt-viewer 2.3.1__tar.gz → 2.3.2__tar.gz

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/.github/workflows/ci.yml

@@ -12,9 +12,9 @@ jobs:
       # The suite is headless by design: no Tk display is available on CI.
       MPLBACKEND: Agg
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.12"
           cache: pip

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.3.2]
+
+### Fixed
+
+- `reg_io.save_registration` wrote matrix values longer than the 16
+  characters the DS value representation allows (a rotation cosine prints as
+  18-19), so strict readers rejected the file. Values are now formatted to
+  fit.
+- A `set_secondary_image_data` call that raised (no primary image) left its
+  image behind as `secondary_source_image`.
+- `mypy src/tk_rt_viewer` failed with Matplotlib 3.11 (two errors in
+  `rendering/view_axes.py` and `rendering/isodose.py`). Annotations only.
+
+### Changed
+
+- `SliceViewerState.get_resampled_image` returns an image already on the
+  primary grid as-is when no transform is given. Switching between cached
+  4DCT phases no longer resamples the volume again.
+- `rtstruct_io.load_rt_struct` reads the RT-STRUCT file once instead of
+  twice, and skips a malformed `ROIContourSequence` item with a warning.
+- Internal cleanup: `geometry.mask_bounds` replaces two copies of the mask
+  bounding-box code; duplicated series reading, scheduling and box-patch
+  code were merged.
+
 ## [2.3.1]
 
 A newly drawn 3-D box no longer spans the whole image along the axis that

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tk-rt-viewer
-Version: 2.3.1
+Version: 2.3.2
 Summary: SimpleITK-based DICOM-RT MPR viewer widget for Tkinter (CT, RT-DOSE, RT-STRUCT, DVH)
 Project-URL: Homepage, https://github.com/oki1002/DICOM_RT_Viewer
 Project-URL: Repository, https://github.com/oki1002/DICOM_RT_Viewer

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/__init__.py

@@ -104,7 +104,7 @@ __all__ = [
     "StructureSet",
     "to_gy_pairs",
 ]
-__version__ = "2.3.1"
+__version__ = "2.3.2"
 
 
 def __getattr__(name: str) -> Any:

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/event_controllers/bbox3d_handler.py

@@ -13,6 +13,8 @@ axis the user cannot see while drawing. Along an image narrower than
 :attr:`Bbox3dEventHandler.NARROW_EXTENT_MM` it is half the image instead.
 """
 
+import SimpleITK as sitk
+
 from ..geometry import AXIS_TO_XYZ_DIM, Box3D, fit_box_length
 from .rect_drag import Rect, RectDragHandler
 
@@ -39,21 +41,17 @@ class Bbox3dEventHandler(RectDragHandler):
         self.state.set_bounding_box_3d(None)
 
     def _commit(self, axis: str, rect: Rect, mode: str) -> None:
-        if mode == "create" and self.state.primary_image is not None:
-            self.state.set_bounding_box_3d(self._new_box(axis, rect))
+        image = self.state.primary_image
+        if mode == "create" and image is not None:
+            self.state.set_bounding_box_3d(self._new_box(image, axis, rect))
         else:
             self.state.set_bbox_3d_from_view(axis, rect)
 
-    def _new_box(self, axis: str, rect: Rect) -> Box3D:
+    def _new_box(self, image: sitk.Image, axis: str, rect: Rect) -> Box3D:
         """Return a box drawn as *rect* on *axis*, centred on the displayed slice."""
         dim = AXIS_TO_XYZ_DIM[axis]
         center = self.state.index_to_physical(axis, self.state.indices[axis])
-        depth = fit_box_length(
-            self.state.primary_image,
-            dim,
-            self.NEW_BOX_DEPTH_MM,
-            self.NARROW_EXTENT_MM,
-        )
+        depth = fit_box_length(image, dim, self.NEW_BOX_DEPTH_MM, self.NARROW_EXTENT_MM)
         base = Box3D(lower=(0.0, 0.0, 0.0), upper=(0.0, 0.0, 0.0))
         return base.with_range(
             dim, center - depth / 2.0, center + depth / 2.0

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/event_controllers/brush_handler.py

@@ -88,7 +88,7 @@ class BrushEventHandler:
         self.is_active = False
         self._cursor_ready = False
         self._abandon_stroke()
-        self._remove_brush_cursor()
+        self.remove_cursor()
         self.viewer.refresh_canvas()
 
     def _abandon_stroke(self) -> None:
@@ -153,7 +153,7 @@ class BrushEventHandler:
         """Continue the stroke or update the brush cursor position."""
         if not self.is_active or not self._hover.current_axis:
             if self.brush_circle:
-                self._remove_brush_cursor()
+                self.remove_cursor()
             return
 
         current = self._hover.current_axis
@@ -225,19 +225,19 @@ class BrushEventHandler:
     def _update_brush_cursor(self, event) -> None:
         """Create or reposition the circular brush cursor at the event location."""
         if self.viewer.toolbar_mode:
-            self._remove_brush_cursor()
+            self.remove_cursor()
             return
 
         axis = self._hover.current_axis
         if not (axis and event.xdata is not None and event.ydata is not None):
-            self._remove_brush_cursor()
+            self.remove_cursor()
             return
 
         if (
             not self.brush_circle
             or self.brush_circle.axes != self.viewer.axes_map[axis]
         ):
-            self._remove_brush_cursor()
+            self.remove_cursor()
             roi_number = self.state.selected_roi_number
             color = (
                 self.state.structure_set.get_color(roi_number)
@@ -259,10 +259,6 @@ class BrushEventHandler:
         self.viewer.request_redraw(axis)
 
     def remove_cursor(self) -> None:
-        """Remove the brush cursor circle from the canvas."""
-        self._remove_brush_cursor()
-
-    def _remove_brush_cursor(self) -> None:
         """Remove the brush cursor circle from the canvas."""
         if not self.brush_circle:
             return

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/event_controllers/crosshair_handler.py

@@ -131,6 +131,4 @@ class CrosshairEventHandler:
     def handle_release(self, event) -> None:
         """End the crosshair drag on left-button release."""
         if event.button == 1:
-            self._is_dragging = False
-            self._active_axis = None
-            self._drag_target = None
+            self.cancel()

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/event_controllers/viewer_events.py

@@ -48,8 +48,8 @@ ZOOM_STEP: float = 1.25
 #: immediate, long enough to coalesce a wheel flick.
 SCROLL_DEBOUNCE_MS: int = 30
 
-# Slice step for PageUp / PageDown (Up / Down move by 1)
-_PAGE_STEP: int = 10
+# Slice steps per navigation key (PageUp / PageDown move by 10)
+_KEY_STEPS: dict[str, int] = {"up": 1, "down": -1, "pageup": 10, "pagedown": -10}
 
 # Right mouse button drives the window/level drag
 _WL_BUTTON: int = 3
@@ -418,8 +418,7 @@ class ViewerEventHandler:
         axis = self._current_axis
         if not axis or self.state.primary_image is None:
             return
-        deltas = {"up": 1, "down": -1, "pageup": _PAGE_STEP, "pagedown": -_PAGE_STEP}
-        delta = deltas.get(event.key)
+        delta = _KEY_STEPS.get(event.key)
         if delta is None:
             return
         current = self.state.indices[axis]

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/geometry.py

@@ -216,6 +216,27 @@ def fit_box_length(
     return extent / 2.0 if extent < min_extent else length
 
 
+def mask_bounds(
+    mask: np.ndarray, pad_voxels: tuple[int, int, int] = (0, 0, 0)
+) -> tuple[slice, slice, slice] | None:
+    """Return the bounding box of a ``(z, y, x)`` mask grown by *pad_voxels*.
+
+    Clamped to the array; ``None`` when the mask is empty. Lets whole-volume
+    work (a distance transform, a DVH) run on the usually small region the
+    mask occupies.
+    """
+    occupied = [
+        np.flatnonzero(mask.any(axis=axes)) for axes in ((1, 2), (0, 2), (0, 1))
+    ]
+    if any(indices.size == 0 for indices in occupied):
+        return None
+    z, y, x = (
+        slice(max(0, int(indices[0]) - pad), min(extent, int(indices[-1]) + pad + 1))
+        for indices, pad, extent in zip(occupied, pad_voxels, mask.shape, strict=True)
+    )
+    return z, y, x
+
+
 def view_dims(axis: str) -> tuple[int, int]:
     """Return the physical dimensions plotted on *axis*' x and y axes.
 

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/io.py

@@ -62,11 +62,11 @@ import pydicom
 import SimpleITK as sitk
 from pydicom.errors import InvalidDicomError
 
+from .reg_io import SPATIAL_REGISTRATION_SOP_CLASS_UID
 from .window_level import compute_auto_window_level
 
 logger = logging.getLogger(__name__)
 
-_SPATIAL_REGISTRATION_UID = "1.2.840.10008.5.1.4.1.1.66.1"
 _CT_IMAGE_STORAGE_UID = "1.2.840.10008.5.1.4.1.1.2"
 _PHASE_LABEL_PATTERN = re.compile(r"\d+%")
 
@@ -248,7 +248,10 @@ def _scan_dicom_tree(dcm_root_dir: str | pathlib.Path) -> _ScanResult:
         if series_uid is not None and modality:
             scan.modality_by_series[str(series_uid)] = modality
 
-        if modality == "REG" and ds.get("SOPClassUID", "") == _SPATIAL_REGISTRATION_UID:
+        if (
+            modality == "REG"
+            and ds.get("SOPClassUID", "") == SPATIAL_REGISTRATION_SOP_CLASS_UID
+        ):
             _collect_reg_matrices(ds, file, scan.reg_matrices, reg_series_refs)
 
     # A REG object may name only one instance of the moving series; resolve
@@ -661,18 +664,17 @@ def select_phase_series(
 # ---------------------------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------------------------
-def _read_series(
+def _read_files(
     reader: sitk.ImageSeriesReader,
-    dcm_dir: pathlib.Path,
+    file_names: Sequence[str],
     series_id: str,
-) -> tuple[sitk.Image, tuple[str, ...]]:
-    """Load *series_id* from *dcm_dir* and return ``(image, file_names)``."""
-    file_names = reader.GetGDCMSeriesFileNames(str(dcm_dir), series_id)
+) -> sitk.Image:
+    """Read *file_names* as one series, keeping per-slice metadata on *reader*."""
     reader.SetFileNames(file_names)
     reader.MetaDataDictionaryArrayUpdateOn()
     image = reader.Execute()
     logger.info(f"Series '{series_id}' loaded with {len(file_names)} files.")
-    return image, file_names
+    return image
 
 
 def _axis_aligned_grid(
@@ -887,7 +889,7 @@ def _read_reg_files(
         except Exception as exc:
             logger.warning(f"Skipping unreadable REG file '{file}': {exc}")
             continue
-        if ds.get("SOPClassUID", "") == _SPATIAL_REGISTRATION_UID:
+        if ds.get("SOPClassUID", "") == SPATIAL_REGISTRATION_SOP_CLASS_UID:
             _collect_reg_matrices(ds, pathlib.Path(file), by_sop, by_series)
     return by_sop, by_series
 
@@ -944,7 +946,8 @@ def _load_all_series_impl(
             if modality.upper() in NON_IMAGE_MODALITIES:
                 logger.info(f"Skipping {modality} series '{sid}' (not an image).")
                 continue
-            raw_image, file_names = _read_series(reader, dcm_dir, sid)
+            file_names = reader.GetGDCMSeriesFileNames(str(dcm_dir), sid)
+            raw_image = _read_files(reader, file_names, sid)
             description, info = _build_series_info(
                 reader, raw_image, _find_reg_matrix(scan, file_names, sid), sid
             )
@@ -1133,12 +1136,8 @@ def _load_scanned_series(
             f"'{entry.series_dir}'."
         )
 
-    reader.SetFileNames(file_names)
-    reader.MetaDataDictionaryArrayUpdateOn()
-    raw_image = reader.Execute()
     series_id = entry.series_uid or str(entry.series_dir)
-    logger.info(f"Series '{series_id}' loaded with {len(file_names)} files.")
-
+    raw_image = _read_files(reader, file_names, series_id)
     reg_matrix = _match_reg_matrix(
         reader, len(file_names), entry.series_uid, reg_matrices
     )

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/reg_io.py

@@ -23,6 +23,7 @@ import numpy as np
 import SimpleITK as sitk
 from pydicom.dataset import Dataset, FileDataset, FileMetaDataset
 from pydicom.uid import UID, ExplicitVRLittleEndian, generate_uid
+from pydicom.valuerep import DSfloat
 
 logger = logging.getLogger(__name__)
 
@@ -260,8 +261,10 @@ def _registration_item(
     """Build one item of the Registration Sequence."""
     matrix_item = Dataset()
     matrix_item.FrameOfReferenceTransformationMatrixType = "RIGID"
+    # DS values are limited to 16 characters; a plain float such as a rotation
+    # cosine prints 18-19, which strict readers reject
     matrix_item.FrameOfReferenceTransformationMatrix = [
-        float(value) for value in matrix.reshape(16)
+        DSfloat(float(value), auto_format=True) for value in matrix.reshape(16)
     ]
 
     matrix_registration = Dataset()

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/registration/params.py

@@ -140,19 +140,17 @@ def params_from_resample_transform(
     center_array = np.array(center)
 
     # Re-express T(p) = R p + offset about the requested centre, i.e. solve
-    # R (p - c) + c + t = R p + offset for t.
-    recentred = sitk.Euler3DTransform()
-    recentred.SetCenter(center)
-    recentred.SetMatrix(matrix.ravel().tolist())
+    # R (p - c) + c + t = R p + offset for t. The angles depend on R alone,
+    # so they are read from the motion transform as it is
     translation = offset + matrix @ center_array - center_array
 
     return RigidParams(
         vert=float(translation[1]),
         lat=float(translation[0]),
         long=float(translation[2]),
-        roll=math.degrees(recentred.GetAngleZ()),
-        pitch=math.degrees(recentred.GetAngleX()),
-        yaw=math.degrees(recentred.GetAngleY()),
+        roll=math.degrees(motion.GetAngleZ()),
+        pitch=math.degrees(motion.GetAngleX()),
+        yaw=math.degrees(motion.GetAngleY()),
     )
 
 

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/rendering/dvh.py

@@ -11,6 +11,8 @@ import numpy as np
 import SimpleITK as sitk
 from matplotlib.axes import Axes
 
+from ..geometry import mask_bounds
+
 if TYPE_CHECKING:
     from ..state.viewer_state import SliceViewerState
 
@@ -39,14 +41,9 @@ class DvhPanel:
         Cropping to the mask's bounding box first avoids scanning the whole
         volume for a typically small ROI.
         """
-        occupied = [
-            np.flatnonzero(mask_arr.any(axis=axes)) for axes in ((1, 2), (0, 2), (0, 1))
-        ]
-        if any(indices.size == 0 for indices in occupied):
+        box = mask_bounds(mask_arr)
+        if box is None:
             return np.empty(0, dtype=dose_arr.dtype)
-        box = tuple(
-            slice(int(indices[0]), int(indices[-1]) + 1) for indices in occupied
-        )
         mask_box = mask_arr[box]
         return np.asarray(dose_arr[box][mask_box != 0])
 

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/rendering/isodose.py

@@ -270,7 +270,7 @@ class IsoDoseOverlay:
                 zorder=2,
             )
             # Per-instance override (documented Matplotlib pattern)
-            fill.format_cursor_data = _format_fill_cursor_data  # type: ignore[method-assign,assignment]
+            fill.format_cursor_data = _format_fill_cursor_data  # type: ignore[method-assign,assignment,unused-ignore]
             self._fill[axis] = fill
             self._on_artists_changed(axis)
             return

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/rendering/layout.py

@@ -1,6 +1,7 @@
 """layout.py — Builds the Matplotlib Axes for each layout mode."""
 
 from collections.abc import Callable
+from typing import cast
 
 import matplotlib.gridspec as gridspec
 from matplotlib.axes import Axes
@@ -50,6 +51,7 @@ class LayoutManager:
             For ``"single"``, ``axs`` is ``{"axial": Axes}``. ``dvh_ax`` is
             ``None`` except for ``"mpr"``.
         """
+        axs: dict[str, Axes]
         if mode == "single":
             axs = {"axial": self._add_view(111)}
             dvh_ax = None
@@ -76,12 +78,20 @@ class LayoutManager:
             )
 
         for ax in axs.values():
-            ax.set_facecolor("black")
-            ax.tick_params(colors="white")
-            ax.set_axis_off()
+            self.style_view(ax)
 
         return axs, dvh_ax
 
+    @staticmethod
+    def style_view(ax: Axes) -> None:
+        """Apply the image-view styling (also after ``Axes.clear()``)."""
+        ax.set_facecolor("black")
+        ax.tick_params(colors="white")
+        ax.set_axis_off()
+
     def _add_view(self, spec) -> ImageViewAxes:
         """Add an image view in the grid cell *spec*."""
-        return self._fig.add_subplot(spec, axes_class=ImageViewAxes)
+        # add_subplot is typed as returning Axes, whatever axes_class is
+        return cast(
+            ImageViewAxes, self._fig.add_subplot(spec, axes_class=ImageViewAxes)
+        )

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/rendering/view_axes.py

@@ -109,7 +109,9 @@ class ImageViewAxes(Axes):
         resized = (
             previous is not None and previous[:2] == limits and previous[2] != ratio
         )
-        old_fit = self._fit_spans(previous[2]) if resized else None
+        old_fit = (
+            self._fit_spans(previous[2]) if resized and previous is not None else None
+        )
         new_fit = self._fit_spans(ratio)
         if old_fit is not None and new_fit is not None:
             zoom = old_fit[0] / span_x
@@ -140,7 +142,7 @@ class ImageViewAxes(Axes):
         width, height = self.bbox.width, self.bbox.height
         if width <= 0 or height <= 0:
             return None
-        return height / width
+        return float(height / width)
 
     def _fit_spans(self, ratio: float | None) -> tuple[float, float] | None:
         """Return the spans showing the whole slice in a box of *ratio*."""

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/roi_operations.py

@@ -14,13 +14,14 @@ result keeps the input's origin / spacing / direction.
 import logging
 from dataclasses import dataclass
 from enum import Enum, auto
+from itertools import pairwise
 
 import numpy as np
 import SimpleITK as sitk
 from scipy.ndimage import distance_transform_edt, gaussian_filter
 from scipy.ndimage import shift as ndshift
 
-from .geometry import resample_binary_mask
+from .geometry import mask_bounds, resample_binary_mask
 
 logger = logging.getLogger(__name__)
 
@@ -209,7 +210,7 @@ def interpolate_contour(mask_image: sitk.Image) -> sitk.Image:
 
     result = binary.copy()
     n_filled = 0
-    for prev_z, next_z in zip(nonempty, nonempty[1:], strict=False):
+    for prev_z, next_z in pairwise(nonempty):
         gap = next_z - prev_z
         if gap <= 1:
             continue
@@ -258,27 +259,6 @@ def _margin_sampling(
     return (scaled[2], scaled[1], scaled[0])
 
 
-def _margin_bounds(
-    mask: np.ndarray, pad_voxels: tuple[int, int, int]
-) -> tuple[slice, slice, slice] | None:
-    """Return the mask's bounding box grown by *pad_voxels*, or ``None`` if empty.
-
-    The distance transform only needs to run inside the region the margin
-    can reach, which is usually a small fraction of the grid.
-    """
-    occupied = [
-        np.flatnonzero(mask.any(axis=axes)) for axes in ((1, 2), (0, 2), (0, 1))
-    ]
-    if any(indices.size == 0 for indices in occupied):
-        return None
-    bounds = []
-    for indices, pad, extent in zip(occupied, pad_voxels, mask.shape, strict=True):
-        lo = max(0, int(indices[0]) - pad)
-        hi = min(extent, int(indices[-1]) + pad + 1)
-        bounds.append(slice(lo, hi))
-    return (bounds[0], bounds[1], bounds[2])
-
-
 def apply_margin(mask_image: sitk.Image, config: MarginConfig) -> sitk.Image:
     """Apply a true Euclidean margin to a binary mask.
 
@@ -310,14 +290,15 @@ def apply_margin(mask_image: sitk.Image, config: MarginConfig) -> sitk.Image:
     mask = sitk.GetArrayViewFromImage(mask_image).astype(bool)  # (z, y, x)
     result = np.zeros_like(mask)
 
-    # Only a dilation can reach outside the mask's bounding box
+    # The distance transform only runs where the margin can reach; only a
+    # dilation reaches outside the mask's bounding box
     reach_mm = [radius + abs(off) for radius, off in zip(radii, offset, strict=True)]
     pad_voxels = (
         int(np.ceil(reach_mm[2] / spacing[2])) + 2 if expand else 2,
         int(np.ceil(reach_mm[1] / spacing[1])) + 2 if expand else 2,
         int(np.ceil(reach_mm[0] / spacing[0])) + 2 if expand else 2,
     )
-    bounds = _margin_bounds(mask, pad_voxels)
+    bounds = mask_bounds(mask, pad_voxels)
     if bounds is None:
         logger.warning("Margin skipped: the mask is empty.")
         return mask_image

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/rtstruct_io.py

@@ -34,7 +34,6 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import TYPE_CHECKING, Any, TypedDict
 
 import numpy as np
-import pydicom
 import SimpleITK as sitk
 from rt_utils import RTStructBuilder
 
@@ -213,7 +212,9 @@ def load_rt_struct(
             dicom_series_path=str(ct_dir),
             rt_struct_path=str(rtstruct_path),
         )
-        ds = pydicom.dcmread(str(rtstruct_path))
+        # rtstruct.ds is the file already parsed by rt-utils; reading it again
+        # would double the I/O for a large structure set
+        ds = rtstruct.ds
         # ROIContourSequence is conditional: a structure set without contours
         # may omit it, which must yield {} rather than AttributeError
         roi_name_map: dict[int, str] = {
@@ -228,9 +229,14 @@ def load_rt_struct(
 
     roi_tasks: list[tuple[int, str, str]] = []
     for roi_contour in roi_contours:
-        roi_number = int(roi_contour.ReferencedROINumber)
+        # One malformed item is skipped, like an ROI whose mask cannot be built
+        try:
+            roi_number = int(roi_contour.ReferencedROINumber)
+            color_hex = _extract_roi_color(roi_contour)
+        except (AttributeError, TypeError, ValueError) as exc:
+            logger.warning(f"Skipping a malformed ROIContourSequence item: {exc}")
+            continue
         roi_name = roi_name_map.get(roi_number, f"ROI_{roi_number}")
-        color_hex = _extract_roi_color(roi_contour)
         roi_tasks.append((roi_number, roi_name, color_hex))
 
     if not roi_tasks:
@@ -254,7 +260,7 @@ def load_rt_struct(
             f"{sorted(duplicate_names)}; resolving each by ROINumber instead "
             "of name to avoid every same-named ROI receiving the same mask."
         )
-        for roi in rtstruct.ds.StructureSetROISequence:
+        for roi in ds.StructureSetROISequence:
             if roi.ROIName in duplicate_names:
                 unique_name = f"__tk_rt_viewer_load_tmp_{roi.ROINumber}__"
                 lookup_name_by_number[int(roi.ROINumber)] = unique_name

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/state/phase_manager.py

@@ -83,10 +83,7 @@ class PhaseManager:
 
     def clear(self) -> None:
         """Drop all phases, the resampled cache, and the current-phase marker."""
-        self._phases = {}
-        self._rebuild_view()
-        self._resampled.clear()
-        self._current_phase = None
+        self.set_all({})
 
     def _rebuild_view(self) -> None:
         """Refresh the read-only view after :attr:`_phases` has been replaced."""

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/state/secondary_manager.py

@@ -73,12 +73,22 @@ class SecondaryManager:
 
         Returns:
             The resampled image, or ``None`` when *image* is ``None``.
+
+        Raises:
+            Whatever the resample callable raises (e.g. ``RuntimeError``
+            without a primary image); the stored source is then unchanged.
         """
+        fill_value = float(fill_value)
+        # Resampled before anything is stored, so a failure leaves no source
+        # behind that the displayed image does not come from
+        resampled = (
+            None if image is None else self._resample(image, transform, fill_value)
+        )
         self._source = image
         self._transform = transform
-        self._fill_value = float(fill_value)
-        self._resampled = None if image is None else self.resample_with(transform)
-        return self._resampled
+        self._fill_value = fill_value
+        self._resampled = resampled
+        return resampled
 
     def set_transform(
         self, transform: sitk.Transform | None, resampled: sitk.Image | None = None

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/state/viewer_state.py

@@ -97,6 +97,16 @@ WINDOW_LEVEL_TARGETS: tuple[str, ...] = ("primary", "secondary")
 MIN_BRUSH_SIZE_MM: float = 0.1
 
 
+def _same_grid(image: sitk.Image, reference: sitk.Image) -> bool:
+    """Return whether *image* has exactly *reference*'s voxel grid."""
+    return bool(
+        image.GetSize() == reference.GetSize()
+        and image.GetOrigin() == reference.GetOrigin()
+        and image.GetSpacing() == reference.GetSpacing()
+        and image.GetDirection() == reference.GetDirection()
+    )
+
+
 @dataclass(eq=False)
 class SliceViewerState:
     """State container for the 3-plane DICOM viewer.
@@ -561,6 +571,10 @@ class SliceViewerState:
     ) -> sitk.Image:
         """Resample *image* onto the primary image grid (linear interpolation).
 
+        An *image* already on the primary grid is returned as-is when no
+        *transform* is given: an identity resample would only copy it. That
+        is the case for every 4DCT phase leaving the LRU cache.
+
         Args:
             image: The source image.
             transform: Maps primary-grid points into *image* (a registration
@@ -576,6 +590,8 @@ class SliceViewerState:
                 "Cannot resample: no primary image is loaded, so there is no "
                 "reference grid to resample onto."
             )
+        if transform is None and _same_grid(image, self.primary_image):
+            return image
         resample = sitk.ResampleImageFilter()
         resample.SetReferenceImage(self.primary_image)
         resample.SetInterpolator(sitk.sitkLinear)

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/viewer.py

@@ -233,7 +233,7 @@ class DicomViewer(ttk.Frame):
             self.viewer_state, on_artists_changed=self._compositor.invalidate
         )
         self._contour_redraws = ContourRedrawCoalescer(
-            schedule=self._schedule_from_worker,
+            schedule=self.schedule,
             cancel=self._safe_after_cancel,
             redraw=self._update_all_contours,
             active_rois=lambda: self.viewer_state.active_contours,
@@ -331,8 +331,11 @@ class DicomViewer(ttk.Frame):
     def schedule(self, delay_ms: int, callback: Callable[[], None]) -> str | None:
         """Run *callback* after *delay_ms*, returning a cancellation handle.
 
-        Returns ``None`` when no Tk event loop is available, so a caller can
-        fall back to acting immediately instead of losing the work.
+        Returns ``None`` when no Tk event loop is available (or the widget is
+        gone), so a caller can fall back to acting immediately instead of
+        losing the work. Also called from the contour-build workers: ``after``
+        is thread-safe with a threaded Tcl (CPython's default; see the
+        README's "Threading model").
         """
         try:
             return self.after(delay_ms, callback)
@@ -526,9 +529,7 @@ class DicomViewer(ttk.Frame):
         """
         for ax in self.axs.values():
             ax.clear()
-            ax.set_facecolor("black")
-            ax.tick_params(colors="white")
-            ax.set_axis_off()
+            LayoutManager.style_view(ax)
         self.image_layer.reset()
         self.isodose.reset()
         self.contours.reset()
@@ -628,35 +629,9 @@ class DicomViewer(ttk.Frame):
             return
         patch = self.bbox_patches[axis]
         if patch is None:
-            patch = Rectangle(
-                (0, 0),
-                0,
-                0,
-                linewidth=1.0,
-                edgecolor="red",
-                facecolor="none",
-                visible=False,
-            )
-            ax.add_patch(patch)
-            self.bbox_patches[axis] = patch
-            self._compositor.invalidate(axis)
-
-        if bbox is None or not self.viewer_state.bbox_visible:
-            if patch.get_visible():
-                patch.set_visible(False)
-                self._compositor.invalidate(axis)
-            patch.set_xy((0, 0))
-            patch.set_width(0)
-            patch.set_height(0)
-        else:
-            x, y, w, h = bbox
-            patch.set_xy((x, y))
-            patch.set_width(w)
-            patch.set_height(h)
-            if not patch.get_visible():
-                patch.set_visible(True)
-                self._compositor.invalidate(axis)
-        self.drawing_manager.add_request(axis)
+            patch = self.bbox_patches[axis] = self._add_box_patch(axis, ax)
+        rect = bbox if self.viewer_state.bbox_visible else None
+        self._place_box_patch(axis, patch, rect)
 
     def _on_bounding_box_3d_changed(self, box: Box3D | None) -> None:
         """Redraw every view's projection of the volumetric bounding box."""
@@ -681,35 +656,48 @@ class DicomViewer(ttk.Frame):
 
         patch = self.bbox_3d_patches[axis]
         if patch is None:
-            patch = Rectangle(
-                (0, 0),
-                0,
-                0,
-                linewidth=1.0,
-                edgecolor="red",
-                facecolor="none",
-                visible=False,
-            )
-            ax.add_patch(patch)
-            self.bbox_3d_patches[axis] = patch
-            self._compositor.invalidate(axis)
-
+            patch = self.bbox_3d_patches[axis] = self._add_box_patch(axis, ax)
         if box is None or not self.viewer_state.bbox_3d_visible:
-            if patch.get_visible():
-                patch.set_visible(False)
-                self._compositor.invalidate(axis)
-            patch.set_bounds(0, 0, 0, 0)
-        else:
-            patch.set_bounds(*box.project(axis))
-            slice_coord = self.viewer_state.index_to_physical(
-                axis, self.viewer_state.indices[axis]
-            )
-            patch.set_linestyle(
-                "solid" if box.contains_coordinate(axis, slice_coord) else "dashed"
-            )
-            if not patch.get_visible():
-                patch.set_visible(True)
-                self._compositor.invalidate(axis)
+            self._place_box_patch(axis, patch, None)
+            return
+        slice_coord = self.viewer_state.index_to_physical(
+            axis, self.viewer_state.indices[axis]
+        )
+        patch.set_linestyle(
+            "solid" if box.contains_coordinate(axis, slice_coord) else "dashed"
+        )
+        self._place_box_patch(axis, patch, box.project(axis))
+
+    def _add_box_patch(self, axis: str, ax: Axes) -> Rectangle:
+        """Add a hidden box outline to *ax* and invalidate its artist list."""
+        patch = Rectangle(
+            (0, 0),
+            0,
+            0,
+            linewidth=1.0,
+            edgecolor="red",
+            facecolor="none",
+            visible=False,
+        )
+        ax.add_patch(patch)
+        self._compositor.invalidate(axis)
+        return patch
+
+    def _place_box_patch(
+        self,
+        axis: str,
+        patch: Rectangle,
+        rect: tuple[float, float, float, float] | None,
+    ) -> None:
+        """Move *patch* onto *rect* ``(x, y, width, height)``, or hide it for ``None``.
+
+        The artist list is invalidated only when the visibility changes.
+        """
+        visible = rect is not None
+        patch.set_bounds(*(rect if rect is not None else (0, 0, 0, 0)))
+        if patch.get_visible() != visible:
+            patch.set_visible(visible)
+            self._compositor.invalidate(axis)
         self.drawing_manager.add_request(axis)
 
     def _on_all_contours_changed(self, structure_set) -> None:
@@ -730,21 +718,6 @@ class DicomViewer(ttk.Frame):
         """
         self._contour_redraws.notify_built(roi_number)
 
-    def _schedule_from_worker(
-        self, delay_ms: int, callback: Callable[[], None]
-    ) -> str | None:
-        """Schedule *callback* on the Tk main loop from a worker thread.
-
-        ``after`` is thread-safe with a threaded Tcl (CPython's default; see
-        the README's "Threading model").
-        """
-        try:
-            return self.after(delay_ms, callback)
-        except (RuntimeError, tk.TclError):
-            # The main loop has exited or the widget is gone: nothing to redraw
-            logger.debug("Contour cache built after teardown; redraw skipped.")
-            return None
-
     def _on_rt_dose_changed(self, image) -> None:
         """Update the dose overlay and DVH panel when the RT-DOSE changes."""
         self._update_blend_slider_visibility()

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/tests/test_brush_handler.py

@@ -239,7 +239,7 @@ class TestResetAfterAxesCleared:
             ax.clear()  # Mirrors DicomViewer._reset_artists()
 
             try:
-                handler._remove_brush_cursor()
+                handler.remove_cursor()
             except NotImplementedError:
                 pass
             else:
@@ -270,7 +270,7 @@ class TestResetAfterAxesCleared:
             assert handler.brush_circle is None
 
             # Must not raise: no stale artist reference remains.
-            handler._remove_brush_cursor()
+            handler.remove_cursor()
             handler.handle_motion(_Event(xdata=1.0, ydata=1.0))
             handler.remove_cursor()
         finally:

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/tests/test_reg_io.py

@@ -116,6 +116,29 @@ class TestSaveRegistration:
             moving.SeriesInstanceUID,
         ]
 
+    def test_matrix_values_fit_the_ds_length_limit(self, tmp_path) -> None:
+        """A rotation's cosines print as 18-19 characters; DS allows 16."""
+        matrix = transform_to_matrix(
+            motion_transform(
+                RigidParams(lat=1.23456789, roll=7.3, pitch=-2.9, yaw=11.1),
+                center=(0.0, 0.0, 0.0),
+            )
+        )
+        path = tmp_path / "reg.dcm"
+        save_registration(path, matrix, make_reference(), make_reference("1.2.9"))
+
+        ds = pydicom.dcmread(path)
+        values = (
+            ds.RegistrationSequence[1]
+            .MatrixRegistrationSequence[0]
+            .MatrixSequence[0]
+            .FrameOfReferenceTransformationMatrix
+        )
+        assert all(len(str(value)) <= 16 for value in values)
+        assert np.array(values, dtype=float).reshape(4, 4) == pytest.approx(
+            matrix, abs=1e-12
+        )
+
     def test_rejects_a_reflection(self, tmp_path) -> None:
         matrix = np.eye(4)
         matrix[0, 0] = -1.0  # orthonormal, but det == -1

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/tests/test_rtstruct_io.py

@@ -350,9 +350,9 @@ class TestLoadRtStructDuplicateNames:
     ``rt_utils.RTStruct.get_roi_mask_by_name`` matches the *first*
     ``StructureSetROISequence`` entry with a given name, which is a real risk
     for TPS exports (duplicate ROI names are not invalid DICOM). These tests
-    stub out ``RTStructBuilder.create_from`` and ``pydicom.dcmread`` with a
-    minimal fake object exposing only what ``load_rt_struct`` reads, so no
-    on-disk DICOM series is needed.
+    stub out ``RTStructBuilder.create_from`` with a minimal fake object
+    exposing only what ``load_rt_struct`` reads, so no on-disk DICOM series
+    is needed.
     """
 
     class _FakeRoi:
@@ -403,7 +403,6 @@ class TestLoadRtStructDuplicateNames:
         monkeypatch.setattr(
             rtstruct_io.RTStructBuilder, "create_from", lambda **kw: rtstruct
         )
-        monkeypatch.setattr(rtstruct_io.pydicom, "dcmread", lambda *a, **kw: ds)
 
         result = rtstruct_io.load_rt_struct(ct_dir="/ct", rtstruct_path="/rs.dcm")
 
@@ -441,7 +440,6 @@ class TestLoadRtStructDuplicateNames:
         monkeypatch.setattr(
             rtstruct_io.RTStructBuilder, "create_from", lambda **kw: rtstruct
         )
-        monkeypatch.setattr(rtstruct_io.pydicom, "dcmread", lambda *a, **kw: ds)
 
         rtstruct_io.load_rt_struct(ct_dir="/ct", rtstruct_path="/rs.dcm")
 
@@ -474,13 +472,21 @@ class TestLoadRtStructMissingSequences:
             "create_from",
             lambda **kw: self._FakeRTStruct(ds),
         )
-        monkeypatch.setattr(rtstruct_io.pydicom, "dcmread", lambda *a, **kw: ds)
 
     def test_missing_roi_contour_sequence_returns_empty(self, monkeypatch) -> None:
         self._patch(monkeypatch, self._EmptyDs())
         result = rtstruct_io.load_rt_struct(ct_dir="/ct", rtstruct_path="/rs.dcm")
         assert result == {}
 
+    def test_a_malformed_contour_item_is_skipped(self, monkeypatch) -> None:
+        class _Ds:
+            StructureSetROISequence: list = []
+            ROIContourSequence = [object()]  # no ReferencedROINumber
+
+        self._patch(monkeypatch, _Ds())
+        result = rtstruct_io.load_rt_struct(ct_dir="/ct", rtstruct_path="/rs.dcm")
+        assert result == {}
+
     def test_an_unreadable_file_still_raises_rtstruct_load_error(
         self, monkeypatch
     ) -> None:

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.2}/tests/test_viewer_state.py

@@ -720,6 +720,13 @@ class TestResampleRequiresAPrimaryImage:
         with pytest.raises(RuntimeError, match="no primary image"):
             state.set_secondary_image_data(self._small_image())
 
+    def test_a_failed_secondary_leaves_no_source_behind(self) -> None:
+        state = SliceViewerState()
+        with pytest.raises(RuntimeError):
+            state.set_secondary_image_data(self._small_image())
+        assert state.secondary_source_image is None
+        assert state.secondary_image is None
+
     def test_clearing_the_secondary_without_a_primary_is_allowed(self) -> None:
         state = SliceViewerState()
         state.set_secondary_image_data(None)  # must not raise
@@ -756,3 +763,31 @@ class TestDeletingTheSelectedRoi:
         state.delete_contour(other)
 
         assert state.selected_roi_number == keep
+
+
+class TestResampleOntoTheSameGrid:
+    """An image already on the primary grid is not resampled again.
+
+    A 4DCT phase is resampled once into the LRU cache and then handed to
+    ``set_secondary_image_data``, which used to resample it a second time
+    on every phase switch.
+    """
+
+    def test_identity_on_the_primary_grid_returns_the_image(self) -> None:
+        state = make_state_with_image()
+        image = sitk.Image(state.primary_image)
+        assert state.get_resampled_image(image) is image
+
+    def test_a_transform_still_resamples(self) -> None:
+        state = make_state_with_image()
+        image = sitk.Image(state.primary_image)
+        moved = state.get_resampled_image(
+            image, transform=sitk.TranslationTransform(3, (1.0, 0.0, 0.0))
+        )
+        assert moved is not image
+
+    def test_another_grid_still_resamples(self) -> None:
+        state = make_state_with_image()
+        image = sitk.Image(state.primary_image)
+        image.SetOrigin(tuple(v + 0.5 for v in image.GetOrigin()))
+        assert state.get_resampled_image(image) is not image