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

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.3}/.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.3}/CHANGELOG.md

@@ -4,6 +4,42 @@ 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.3]
+
+### Added
+
+- `rtstruct_io.mask2rtstruct` and `rtstruct_io.save_structure_set` take a
+  keyword-only `add_roi_kwargs` mapping, forwarded to rt-utils'
+  `RTStruct.add_roi` for every ROI. Callers can now set
+  `approximate_contours`, `use_pin_hole`, `roi_generation_algorithm`,
+  `description`, etc. `mask`, `color` and `name` still come from the
+  structures and raise `ValueError` if given here. The default (`None`)
+  keeps the previous behaviour.
+
+## [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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tk-rt-viewer
-Version: 2.3.1
+Version: 2.3.3
 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
@@ -374,6 +374,11 @@ written = save_structure_set(
 )
 ```
 
+Pass `add_roi_kwargs` to forward options to rt-utils' `RTStruct.add_roi`
+for every ROI, e.g. `add_roi_kwargs={"approximate_contours": False}` to
+keep every contour vertex instead of the simplified outline. `mask2rtstruct`
+accepts the same keyword.
+
 `rt_utils.RTStruct.save` silently appends `.dcm` to a path that does not
 already end with it, with no way to opt out; `mask2rtstruct` resolves
 against that internally so its `exists()` check, its log messages, and its

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.3}/README.md

@@ -337,6 +337,11 @@ written = save_structure_set(
 )
 ```
 
+Pass `add_roi_kwargs` to forward options to rt-utils' `RTStruct.add_roi`
+for every ROI, e.g. `add_roi_kwargs={"approximate_contours": False}` to
+keep every contour vertex instead of the simplified outline. `mask2rtstruct`
+accepts the same keyword.
+
 `rt_utils.RTStruct.save` silently appends `.dcm` to a path that does not
 already end with it, with no way to opt out; `mask2rtstruct` resolves
 against that internally so its `exists()` check, its log messages, and its

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

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

{tk_rt_viewer-2.3.1 → tk_rt_viewer-2.3.3}/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.3}/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.3}/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.3}/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.3}/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.3}/src/tk_rt_viewer/io.py

@@ -55,18 +55,18 @@ import re
 from collections.abc import Iterable, Iterator, Sequence
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field, replace
-from typing import TypedDict
+from typing import TypedDict, cast
 
 import numpy as np
 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()
+    image = cast(sitk.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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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