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

{tk_rt_viewer-2.3.0 → 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.0 → tk_rt_viewer-2.3.2}/CHANGELOG.md

@@ -4,6 +4,53 @@ 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
+cannot be seen while drawing.
+
+### Added
+
+- **`geometry.fit_box_length(image, dim, length, min_extent)`**: returns
+  *length*, or half of the image's extent along *dim* when that extent is
+  shorter than *min_extent*.
+
+### Changed
+
+- A 3-D box newly drawn on a view is now
+  **`Bbox3dEventHandler.NEW_BOX_DEPTH_MM`** (50 mm) deep along that view's
+  normal, centred on the displayed slice. It used to keep the depth of the box
+  it replaced, or span the whole image when none was left (e.g. after a
+  clearing click), which hid how deep the box was while drawing.
+- Where the image along that normal is shorter than
+  **`Bbox3dEventHandler.NARROW_EXTENT_MM`** (60 mm), e.g. a short
+  craniocaudal scan range, the new box is half the image deep instead, so it
+  does not fill the image end to end.
+
 ## [2.3.0]
 
 Zoom per view, a reversible wheel, and views that fill the figure.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tk-rt-viewer
-Version: 2.3.0
+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
@@ -544,7 +544,7 @@ visible the 3-D box takes the mouse.
 ```python
 from tk_rt_viewer import Box3D
 
-# Turn the tool on; the user draws on any view. Drawing on a second view
+# Turn the tool on; the user draws on any view. Resizing on a second view
 # trims the depth of the box drawn on the first.
 state.set_bbox_3d_visible(True)
 
@@ -560,7 +560,10 @@ state.set_bounding_box_3d(None)
 ```
 
 Clicking outside the box clears it, as with the per-view box; a drag that
-follows redraws it in that plane while keeping the depth set on another view.
+follows draws a new box in that plane, 50 mm deep along the view's normal and
+centred on the displayed slice (`Bbox3dEventHandler.NEW_BOX_DEPTH_MM`), or half
+the image deep where the image is narrower than 60 mm along that normal
+(`NARROW_EXTENT_MM`). Resize or move it on another view to change its depth.
 
 Each view draws the box solid while the displayed slice cuts through it and
 dashed while it does not, so its depth is visible without leaving the slice.

{tk_rt_viewer-2.3.0 → tk_rt_viewer-2.3.2}/README.md

@@ -507,7 +507,7 @@ visible the 3-D box takes the mouse.
 ```python
 from tk_rt_viewer import Box3D
 
-# Turn the tool on; the user draws on any view. Drawing on a second view
+# Turn the tool on; the user draws on any view. Resizing on a second view
 # trims the depth of the box drawn on the first.
 state.set_bbox_3d_visible(True)
 
@@ -523,7 +523,10 @@ state.set_bounding_box_3d(None)
 ```
 
 Clicking outside the box clears it, as with the per-view box; a drag that
-follows redraws it in that plane while keeping the depth set on another view.
+follows draws a new box in that plane, 50 mm deep along the view's normal and
+centred on the displayed slice (`Bbox3dEventHandler.NEW_BOX_DEPTH_MM`), or half
+the image deep where the image is narrower than 60 mm along that normal
+(`NARROW_EXTENT_MM`). Resize or move it on another view to change its depth.
 
 Each view draws the box solid while the displayed slice cuts through it and
 dashed while it does not, so its depth is visible without leaving the slice.

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

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

tk_rt_viewer-2.3.2/src/tk_rt_viewer/event_controllers/bbox3d_handler.py

@@ -0,0 +1,58 @@
+"""bbox3d_handler.py — Volumetric (3-D) bounding box drag handler.
+
+The box is a single :class:`~tk_rt_viewer.geometry.Box3D` in
+:class:`~tk_rt_viewer.state.viewer_state.SliceViewerState`; every view shows
+its projection and the viewer renders it through the
+``"bounding_box_3d_changed"`` listener.
+
+A gesture on any view edits that one box and only the two dimensions the view
+displays; the perpendicular dimension is set from a view that shows it. A new
+box drawn on a view is :attr:`Bbox3dEventHandler.NEW_BOX_DEPTH_MM` deep,
+centred on the displayed slice, so it never spans the whole image along the
+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
+
+
+class Bbox3dEventHandler(RectDragHandler):
+    """Create / move / resize the 3-D bounding box from any view."""
+
+    #: Depth (mm) of a newly drawn box along the normal of the view it is
+    #: drawn on, centred on the displayed slice. Hosts may override it.
+    NEW_BOX_DEPTH_MM: float = 50.0
+
+    #: Image extent (mm) along that normal below which the new box is half the
+    #: extent instead, so it does not fill a narrow scan range.
+    NARROW_EXTENT_MM: float = 60.0
+
+    def _is_enabled(self) -> bool:
+        return self.state.bbox_3d_visible and self.state.primary_image is not None
+
+    def _current_rect(self, axis: str) -> Rect | None:
+        box = self.state.bounding_box_3d
+        return None if box is None else box.project(axis)
+
+    def _clear(self, axis: str) -> None:
+        self.state.set_bounding_box_3d(None)
+
+    def _commit(self, axis: str, rect: Rect, mode: str) -> None:
+        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, 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(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
+        ).with_view_rect(axis, rect)

{tk_rt_viewer-2.3.0 → 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.0 → 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.0 → 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.0 → tk_rt_viewer-2.3.2}/src/tk_rt_viewer/geometry.py

@@ -197,6 +197,46 @@ def as_point(values) -> tuple[float, float, float]:
     return (float(values[0]), float(values[1]), float(values[2]))
 
 
+def fit_box_length(
+    image: sitk.Image, dim: int, length: float, min_extent: float
+) -> float:
+    """Return *length*, or half of *image*'s extent along *dim* if it is narrow.
+
+    A default-sized box would cover a narrow image (e.g. a short craniocaudal
+    scan range) end to end, so when the extent along physical dimension *dim*
+    (0=x, 1=y, 2=z) is shorter than *min_extent* the box takes half of it.
+
+    Args:
+        image: The image the box is drawn on.
+        dim: Physical dimension (0=x, 1=y, 2=z).
+        length: Preferred box length in mm.
+        min_extent: Extent (mm) below which half the extent is used instead.
+    """
+    extent = Box3D.from_image_extent(image).size[dim]
+    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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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