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

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/CHANGELOG.md

@@ -4,6 +4,34 @@ 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.0]
+
+Zoom per view, a reversible wheel, and views that fill the figure.
+
+### Added
+
+- **Ctrl + mouse wheel zooms** the view under the pointer, about the
+  pointer, from 1× (fitted) to 20×. Each view keeps its own zoom; a resize
+  keeps zoom and centre. Works while the brush tool is active.
+- **`DicomViewer.set_zoom(axis, zoom, anchor=None)`**, **`get_zoom(axis)`**
+  and **`reset_zoom(axis=None)`**.
+- **`DicomViewer(..., invert_scroll=False)`** and the
+  **`DicomViewer.scroll_inverted`** property reverse the wheel for slice
+  scrolling (`ViewerEventHandler.invert_scroll`). Brush resizing, zoom and
+  the arrow keys keep their direction.
+- **`ImageViewAxes`** (`tk_rt_viewer.rendering.view_axes`): the Axes class of
+  every image view. It fills its layout cell and keeps a 1:1 data aspect
+  through its limits; `set_aspect` is pinned to `"auto"` on it.
+
+### Changed
+
+- The image views no longer shrink their box to the slice's aspect
+  (`adjustable="box"`), so a zoomed slice uses the whole layout cell.
+- The constrained-layout padding around and between the views is reduced
+  to 1 pt (`DicomViewer._LAYOUT_PAD_INCHES` / `_LAYOUT_SPACE`). The figure is
+  created with `layout="constrained"` unless `fig_kwargs` sets `layout`,
+  `constrained_layout` or `tight_layout`.
+
 ## [2.2.0]
 
 Loading a series picked from a scan now reads only that series' files.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tk-rt-viewer
-Version: 2.2.1
+Version: 2.3.0
 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
@@ -58,7 +58,8 @@ The distribution name on PyPI is `tk-rt-viewer`; the import package is
 - **Blit-based rendering** — Idle-driven blit updates via `DrawingManager`; redraw requests are coalesced into a single Tk `after_idle` callback instead of a fixed-interval polling timer.
 - **Observer-pattern state management** — All view state lives in `SliceViewerState`; the widget reacts to changes without polling.
 - **SimpleITK-native coordinates** — Physical LPS coordinates, origin, spacing, and direction cosines are preserved throughout; axis reordering between SimpleITK and NumPy conventions is handled internally by the library.
-- **Interactive navigation** — Crosshair drag, mouse wheel, and keyboard (↑ / ↓ / PageUp / PageDown).
+- **Interactive navigation** — Crosshair drag, mouse wheel (direction reversible), and keyboard (↑ / ↓ / PageUp / PageDown).
+- **Per-view zoom** — Ctrl + mouse wheel zooms the view under the pointer about the pointer; each view keeps its own zoom factor. The views fill their layout cells, so a zoomed slice uses the whole cell.
 - **Independent window / level per image** — The primary and secondary images each carry their own display window, so a PET, MR, or dose overlay can be windowed without disturbing the CT underneath. The secondary follows the primary until an override is set. Right-click drag adjusts whichever image is targeted: horizontal → window width (WW), vertical → window centre (WL).
 - **RT-STRUCT support** — ROI masks stored in `StructureSet` (keyed by integer ROI number); contour overlay with optional semi-transparent fill; brush tool for mask editing.
 - **ROI operations** — Shape-based inter-slice interpolation, true Euclidean margins (uniform or 6-direction anisotropic), Gaussian smoothing, and boolean operations (union / intersection / subtraction).
@@ -132,7 +133,8 @@ tk_rt_viewer/
 │   ├── render.py               # RGBA colormap LUT and window/level helpers
 │   ├── isodose.py              # IsoDoseOverlay (fill bands + contour lines)
 │   ├── dvh.py                  # DvhPanel (cumulative DVH panel)
-│   └── layout.py               # LayoutManager (single / mpr / mpr_wide layouts)
+│   ├── layout.py               # LayoutManager (single / mpr / mpr_wide layouts)
+│   └── view_axes.py            # ImageViewAxes (fills its cell, 1:1 aspect, zoom)
 ├── registration/
 │   ├── session.py              # RegistrationSession, cropping, resampling
 │   ├── params.py               # RigidParams <-> transforms (Vert/Lat/Long/...)
@@ -749,6 +751,31 @@ box tool, crosshair, contours, isodose) works unchanged in `"single"` mode
 against the `"axial"` key — host code does not need a separate code path
 for it.
 
+## Zoom and wheel direction
+
+Ctrl + mouse wheel zooms the view under the pointer, keeping the point under
+the pointer in place. Each view is zoomed independently, from 1× (the whole
+slice fitted to the view) up to 20×, and a zoomed view cannot be moved off
+the slice. A figure resize keeps each view's zoom and centre; loading a new
+primary image or switching the layout starts fitted again. Ctrl + wheel zooms
+even while the brush tool is active (the plain wheel still resizes the brush).
+
+```python
+viewer.set_zoom("axial", 2.5)                     # about the view centre
+viewer.set_zoom("coronal", 4.0, anchor=(x, z))    # keep (x, z) in place
+viewer.get_zoom("axial")                          # -> 2.5
+viewer.reset_zoom()                               # fit every view again
+
+# Reverse the wheel for slice scrolling (brush size and zoom are unaffected)
+viewer = DicomViewer(parent, state=state, invert_scroll=True)
+viewer.scroll_inverted = False                    # or toggle at run time
+```
+
+The image views are `ImageViewAxes` (`tk_rt_viewer.rendering.view_axes`):
+they always fill their layout cell and keep a 1:1 data aspect by adjusting
+their limits instead of shrinking their box. At 1× the slice is letterboxed
+inside the cell where their aspect ratios differ.
+
 ## Embedding in a larger application
 
 `DicomViewer` is a `ttk.Frame` subclass, so it can be packed, gridded, or

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

@@ -21,7 +21,8 @@ The distribution name on PyPI is `tk-rt-viewer`; the import package is
 - **Blit-based rendering** — Idle-driven blit updates via `DrawingManager`; redraw requests are coalesced into a single Tk `after_idle` callback instead of a fixed-interval polling timer.
 - **Observer-pattern state management** — All view state lives in `SliceViewerState`; the widget reacts to changes without polling.
 - **SimpleITK-native coordinates** — Physical LPS coordinates, origin, spacing, and direction cosines are preserved throughout; axis reordering between SimpleITK and NumPy conventions is handled internally by the library.
-- **Interactive navigation** — Crosshair drag, mouse wheel, and keyboard (↑ / ↓ / PageUp / PageDown).
+- **Interactive navigation** — Crosshair drag, mouse wheel (direction reversible), and keyboard (↑ / ↓ / PageUp / PageDown).
+- **Per-view zoom** — Ctrl + mouse wheel zooms the view under the pointer about the pointer; each view keeps its own zoom factor. The views fill their layout cells, so a zoomed slice uses the whole cell.
 - **Independent window / level per image** — The primary and secondary images each carry their own display window, so a PET, MR, or dose overlay can be windowed without disturbing the CT underneath. The secondary follows the primary until an override is set. Right-click drag adjusts whichever image is targeted: horizontal → window width (WW), vertical → window centre (WL).
 - **RT-STRUCT support** — ROI masks stored in `StructureSet` (keyed by integer ROI number); contour overlay with optional semi-transparent fill; brush tool for mask editing.
 - **ROI operations** — Shape-based inter-slice interpolation, true Euclidean margins (uniform or 6-direction anisotropic), Gaussian smoothing, and boolean operations (union / intersection / subtraction).
@@ -95,7 +96,8 @@ tk_rt_viewer/
 │   ├── render.py               # RGBA colormap LUT and window/level helpers
 │   ├── isodose.py              # IsoDoseOverlay (fill bands + contour lines)
 │   ├── dvh.py                  # DvhPanel (cumulative DVH panel)
-│   └── layout.py               # LayoutManager (single / mpr / mpr_wide layouts)
+│   ├── layout.py               # LayoutManager (single / mpr / mpr_wide layouts)
+│   └── view_axes.py            # ImageViewAxes (fills its cell, 1:1 aspect, zoom)
 ├── registration/
 │   ├── session.py              # RegistrationSession, cropping, resampling
 │   ├── params.py               # RigidParams <-> transforms (Vert/Lat/Long/...)
@@ -712,6 +714,31 @@ box tool, crosshair, contours, isodose) works unchanged in `"single"` mode
 against the `"axial"` key — host code does not need a separate code path
 for it.
 
+## Zoom and wheel direction
+
+Ctrl + mouse wheel zooms the view under the pointer, keeping the point under
+the pointer in place. Each view is zoomed independently, from 1× (the whole
+slice fitted to the view) up to 20×, and a zoomed view cannot be moved off
+the slice. A figure resize keeps each view's zoom and centre; loading a new
+primary image or switching the layout starts fitted again. Ctrl + wheel zooms
+even while the brush tool is active (the plain wheel still resizes the brush).
+
+```python
+viewer.set_zoom("axial", 2.5)                     # about the view centre
+viewer.set_zoom("coronal", 4.0, anchor=(x, z))    # keep (x, z) in place
+viewer.get_zoom("axial")                          # -> 2.5
+viewer.reset_zoom()                               # fit every view again
+
+# Reverse the wheel for slice scrolling (brush size and zoom are unaffected)
+viewer = DicomViewer(parent, state=state, invert_scroll=True)
+viewer.scroll_inverted = False                    # or toggle at run time
+```
+
+The image views are `ImageViewAxes` (`tk_rt_viewer.rendering.view_axes`):
+they always fill their layout cell and keep a 1:1 data aspect by adjusting
+their limits instead of shrinking their box. At 1× the slice is letterboxed
+inside the cell where their aspect ratios differ.
+
 ## Embedding in a larger application
 
 `DicomViewer` is a `ttk.Frame` subclass, so it can be packed, gridded, or

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

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

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/src/tk_rt_viewer/event_controllers/viewer_events.py

@@ -21,18 +21,29 @@ Hover tracking:
 Scroll debounce:
     Wheel steps are accumulated for ``SCROLL_DEBOUNCE_MS`` and applied in one
     ``set_index`` call, on the Tk main thread. Brush resizing is immediate.
+
+Wheel priority:
+    1. Ctrl held: zoom the view under the pointer about the pointer
+       (:class:`~tk_rt_viewer.rendering.view_axes.ImageViewAxes`), even while
+       the brush is active
+    2. Brush tool: resize the brush
+    3. Otherwise: scroll slices; ``invert_scroll`` flips the direction
 """
 
 import numpy as np
 
 from .. import events
 from ..protocols import ViewerHost
+from ..rendering.view_axes import ImageViewAxes
 from ..state.viewer_state import SliceViewerState
 from .bbox3d_handler import Bbox3dEventHandler
 from .bbox_handler import BboxEventHandler
 from .brush_handler import BrushEventHandler
 from .crosshair_handler import CrosshairEventHandler
 
+#: Zoom ratio per Ctrl + wheel notch.
+ZOOM_STEP: float = 1.25
+
 #: Debounce window (ms) for batching scroll events; short enough to feel
 #: immediate, long enough to coalesce a wheel flick.
 SCROLL_DEBOUNCE_MS: int = 30
@@ -58,9 +69,18 @@ _MIN_WINDOW_WIDTH: float = 1.0
 class ViewerEventHandler:
     """Dispatch matplotlib canvas events to specialised sub-handlers."""
 
-    def __init__(self, state: SliceViewerState, viewer: ViewerHost) -> None:
+    def __init__(
+        self,
+        state: SliceViewerState,
+        viewer: ViewerHost,
+        *,
+        invert_scroll: bool = False,
+    ) -> None:
         self.state = state
         self.viewer = viewer
+        #: Reverse the wheel direction for slice scrolling only (the brush
+        #: size and zoom keep theirs)
+        self.invert_scroll: bool = invert_scroll
 
         self._current_axis: str = ""
 
@@ -130,7 +150,11 @@ class ViewerEventHandler:
     # Scroll
     # ------------------------------------------------------------------
     def on_scroll(self, event) -> None:
-        """Resize the brush immediately, or accumulate a debounced slice scroll."""
+        """Zoom (Ctrl), resize the brush, or accumulate a debounced slice scroll."""
+        if self._ctrl_held(event):
+            self._zoom_at_pointer(event)
+            return
+
         if self.state.brush_tool_active and self._current_axis:
             self.brush_handler.handle_scroll(event)
             return
@@ -145,7 +169,8 @@ class ViewerEventHandler:
             self._flush_scroll()
 
         self._scroll_axis = axis
-        self._scroll_accum += int(np.sign(event.step))
+        direction = -1 if self.invert_scroll else 1
+        self._scroll_accum += direction * int(np.sign(event.step))
 
         self._cancel_scroll_timer()
         handle = self.viewer.schedule(SCROLL_DEBOUNCE_MS, self._flush_scroll)
@@ -155,6 +180,35 @@ class ViewerEventHandler:
             return
         self._scroll_handle = handle
 
+    def _zoom_at_pointer(self, event) -> None:
+        """Zoom the view under the pointer one notch, about the pointer."""
+        ax = self.viewer.axes_map.get(self._current_axis)
+        if (
+            not isinstance(ax, ImageViewAxes)
+            or self.state.primary_image is None
+            or event.xdata is None
+            or event.ydata is None
+            or not event.step
+        ):
+            return
+        factor = ZOOM_STEP ** float(np.sign(event.step))
+        ax.zoom_to(ax.zoom_factor() * factor, anchor=(event.xdata, event.ydata))
+        self.viewer.refresh_canvas()
+
+    @staticmethod
+    def _ctrl_held(event) -> bool:
+        """Return whether Ctrl is held during *event*.
+
+        ``modifiers`` (Matplotlib >= 3.7) is read from the GUI event itself;
+        ``key`` only reflects the last key event the canvas received, so it
+        is a fallback.
+        """
+        modifiers = getattr(event, "modifiers", None)
+        if modifiers is not None:
+            return "ctrl" in modifiers
+        key = event.key or ""
+        return key in ("control", "ctrl") or key.startswith("ctrl+")
+
     def _cancel_scroll_timer(self) -> None:
         """Cancel the pending scroll-debounce callback, if any."""
         if self._scroll_handle is None:

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/src/tk_rt_viewer/rendering/image_layer.py

@@ -16,6 +16,7 @@ from matplotlib.image import AxesImage
 
 from ..geometry import AXES
 from .render import GRAY_LUT, build_cmap_lut, slice_to_rgba, window_level_to_clim
+from .view_axes import ImageViewAxes
 
 if TYPE_CHECKING:
     from ..state.viewer_state import SliceViewerState
@@ -163,6 +164,10 @@ class ImageLayer:
 
         Coronal / sagittal show superior (large z) at the top. Axial inverts y
         so anterior is at the top, per radiological convention.
+
+        An :class:`ImageViewAxes` (every view the layout builds) keeps its
+        box filling the layout cell and conforms these limits to it; a plain
+        Axes shrinks its box to the slice's aspect instead.
         """
         if axis in ("coronal", "sagittal"):
             y_bottom, y_top = extent[2], extent[3]
@@ -171,6 +176,8 @@ class ImageLayer:
         ax.set_xlim(extent[0], extent[1])
         ax.set_ylim(y_bottom, y_top)
         ax.set_aspect("equal", adjustable="box")
+        if isinstance(ax, ImageViewAxes):
+            ax.set_image_extent(extent)
 
     def _update_secondary(
         self,

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/src/tk_rt_viewer/rendering/layout.py

@@ -7,11 +7,15 @@ from matplotlib.axes import Axes
 from matplotlib.figure import Figure
 
 from ..geometry import LAYOUT_MODES
+from .view_axes import ImageViewAxes
 
 
 class LayoutManager:
     """Builds the Axes layout for a given mode inside a shared Figure.
 
+    The image views are :class:`ImageViewAxes`, which fill their cell and
+    support zooming; the DVH panel is a plain Axes.
+
     Supported modes:
         ``"mpr_wide"`` — left column: large Axial; right column: Coronal /
             Sagittal stacked (default, no DVH panel).
@@ -47,22 +51,22 @@ class LayoutManager:
             ``None`` except for ``"mpr"``.
         """
         if mode == "single":
-            axs = {"axial": self._fig.add_subplot(111)}
+            axs = {"axial": self._add_view(111)}
             dvh_ax = None
         elif mode == "mpr_wide":
             gs = gridspec.GridSpec(2, 2, figure=self._fig, width_ratios=[2, 1])
             axs = {
-                "axial": self._fig.add_subplot(gs[:, 0]),
-                "coronal": self._fig.add_subplot(gs[0, 1]),
-                "sagittal": self._fig.add_subplot(gs[1, 1]),
+                "axial": self._add_view(gs[:, 0]),
+                "coronal": self._add_view(gs[0, 1]),
+                "sagittal": self._add_view(gs[1, 1]),
             }
             dvh_ax = None
         elif mode == "mpr":
             gs = gridspec.GridSpec(2, 2, figure=self._fig)
             axs = {
-                "axial": self._fig.add_subplot(gs[0, 0]),
-                "coronal": self._fig.add_subplot(gs[1, 0]),
-                "sagittal": self._fig.add_subplot(gs[1, 1]),
+                "axial": self._add_view(gs[0, 0]),
+                "coronal": self._add_view(gs[1, 0]),
+                "sagittal": self._add_view(gs[1, 1]),
             }
             dvh_ax = self._fig.add_subplot(gs[0, 1])
             self._style_dvh_axes(dvh_ax)
@@ -77,3 +81,7 @@ class LayoutManager:
             ax.set_axis_off()
 
         return axs, dvh_ax
+
+    def _add_view(self, spec) -> ImageViewAxes:
+        """Add an image view in the grid cell *spec*."""
+        return self._fig.add_subplot(spec, axes_class=ImageViewAxes)

tk_rt_viewer-2.3.0/src/tk_rt_viewer/rendering/view_axes.py

@@ -0,0 +1,188 @@
+"""view_axes.py — Axes for an image view: fills its cell, keeps 1:1, zooms.
+
+Matplotlib keeps an equal data aspect either by shrinking the Axes box
+(``adjustable="box"``, which leaves empty bands in the layout cell) or by
+widening the limits (``adjustable="datalim"``, which logs a warning whenever
+the limits were set explicitly, i.e. after every zoom). :class:`ImageViewAxes`
+does the latter itself: the box always fills its cell and the limits are
+conformed to the box on every draw.
+
+Zoom is relative to the "fit" view, in which the whole slice just fits the
+box. It is read back from the limits, so a Matplotlib toolbar zoom or pan is
+picked up as well; after a resize the zoom factor and centre are kept.
+"""
+
+from matplotlib.axes import Axes
+
+#: Fit-to-view; zooming out never shrinks the slice below this.
+MIN_ZOOM: float = 1.0
+#: Upper bound on the zoom factor.
+MAX_ZOOM: float = 20.0
+
+# Relative span mismatch below which the limits are left alone (avoids
+# re-setting them every draw for floating-point noise)
+_TOLERANCE: float = 1e-6
+
+
+class ImageViewAxes(Axes):
+    """Axes that fills its layout cell and keeps a 1:1 data aspect via its limits.
+
+    :meth:`set_aspect` is pinned to ``"auto"`` (``imshow`` would otherwise
+    switch the box to ``aspect="equal"``); the equal aspect is enforced by
+    :meth:`apply_aspect` through the limits instead.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        # (x0, x1, y0, y1) sorted; None until an image is shown
+        self._image_extent: tuple[float, float, float, float] | None = None
+        # (xlim, ylim, box ratio) left by the last conform, to tell a resize
+        # (box changed, limits untouched) from a limit change by someone else
+        self._conformed: tuple | None = None
+
+    # ------------------------------------------------------------------
+    # Matplotlib hooks
+    # ------------------------------------------------------------------
+    def set_aspect(self, aspect, adjustable=None, anchor=None, share=False) -> None:
+        """Keep the box free; the equal aspect is kept through the limits."""
+        super().set_aspect("auto", adjustable=adjustable, anchor=anchor, share=share)
+
+    def apply_aspect(self, position=None) -> None:
+        """Place the box, then conform the limits to its aspect."""
+        super().apply_aspect(position)
+        self._conform_limits()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def set_image_extent(self, extent: tuple[float, float, float, float]) -> None:
+        """Record the slice extent that bounds zooming and panning."""
+        x0, x1, y0, y1 = extent
+        self._image_extent = (min(x0, x1), max(x0, x1), min(y0, y1), max(y0, y1))
+        self._conformed = None
+
+    def zoom_factor(self) -> float:
+        """Return the zoom relative to the fit view (1.0 without an image)."""
+        fit = self._fit_spans(self._box_ratio())
+        span = self._spans()[0]
+        if fit is None or span <= 0:
+            return 1.0
+        return fit[0] / span
+
+    def zoom_to(self, zoom: float, anchor: tuple[float, float] | None = None) -> None:
+        """Zoom to *zoom*, keeping *anchor* (data coordinates) where it is on screen.
+
+        Args:
+            zoom: Target factor, clipped to ``[MIN_ZOOM, MAX_ZOOM]``.
+            anchor: Point that stays put; ``None`` zooms about the view centre.
+        """
+        fit = self._fit_spans(self._box_ratio())
+        if fit is None:
+            return
+        zoom = min(max(float(zoom), MIN_ZOOM), MAX_ZOOM)
+        new_x, new_y = fit[0] / zoom, fit[1] / zoom
+        (old_x, old_y), (cx, cy) = self._spans(), self._center()
+        if anchor is not None and old_x > 0 and old_y > 0:
+            cx = anchor[0] + (cx - anchor[0]) * new_x / old_x
+            cy = anchor[1] + (cy - anchor[1]) * new_y / old_y
+        self._set_view(cx, cy, new_x, new_y)
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+    def _conform_limits(self) -> None:
+        """Make the limits match the box aspect.
+
+        After a resize (box changed, limits as last conformed) the zoom
+        factor and centre are kept. Otherwise the narrower span is widened
+        about the centre, as ``adjustable="datalim"`` would.
+        """
+        ratio = self._box_ratio()
+        if ratio is None:
+            return
+        (span_x, span_y), (cx, cy) = self._spans(), self._center()
+        if span_x <= 0 or span_y <= 0:
+            return
+
+        limits = (self.get_xlim(), self.get_ylim())
+        previous = self._conformed
+        resized = (
+            previous is not None and previous[:2] == limits and previous[2] != ratio
+        )
+        old_fit = self._fit_spans(previous[2]) if resized 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
+            span_x, span_y = new_fit[0] / zoom, new_fit[1] / zoom
+        elif span_y < span_x * ratio:
+            span_y = span_x * ratio
+        else:
+            span_x = span_y / ratio
+
+        self._set_view(cx, cy, span_x, span_y)
+        self._conformed = (self.get_xlim(), self.get_ylim(), ratio)
+
+    def _set_view(self, cx: float, cy: float, span_x: float, span_y: float) -> None:
+        """Set the limits around a centre, clamped to the slice, keeping inversion."""
+        if self._image_extent is not None:
+            x0, x1, y0, y1 = self._image_extent
+            cx = _clamp_center(cx, span_x, x0, x1)
+            cy = _clamp_center(cy, span_y, y0, y1)
+        xlim = _limits(cx, span_x, self.xaxis_inverted())
+        ylim = _limits(cy, span_y, self.yaxis_inverted())
+        if not _close(self.get_xlim(), xlim):
+            self.set_xlim(xlim, auto=None)
+        if not _close(self.get_ylim(), ylim):
+            self.set_ylim(ylim, auto=None)
+
+    def _box_ratio(self) -> float | None:
+        """Return the box's height / width on screen, or ``None`` if it is empty."""
+        width, height = self.bbox.width, self.bbox.height
+        if width <= 0 or height <= 0:
+            return None
+        return 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*."""
+        if ratio is None or self._image_extent is None:
+            return None
+        x0, x1, y0, y1 = self._image_extent
+        width, height = x1 - x0, y1 - y0
+        if width <= 0 or height <= 0:
+            return None
+        span_x = max(width, height / ratio)
+        return span_x, span_x * ratio
+
+    def _spans(self) -> tuple[float, float]:
+        (xa, xb), (ya, yb) = self.get_xlim(), self.get_ylim()
+        return abs(xb - xa), abs(yb - ya)
+
+    def _center(self) -> tuple[float, float]:
+        (xa, xb), (ya, yb) = self.get_xlim(), self.get_ylim()
+        return (xa + xb) / 2, (ya + yb) / 2
+
+
+def _clamp_center(center: float, span: float, low: float, high: float) -> float:
+    """Keep a view of width *span* over ``[low, high]``.
+
+    A view wider than the slice is centred on it; a narrower one may not
+    slide past either edge.
+    """
+    if span >= high - low:
+        return (low + high) / 2
+    return min(max(center, low + span / 2), high - span / 2)
+
+
+def _limits(center: float, span: float, inverted: bool) -> tuple[float, float]:
+    half = span / 2
+    return (
+        (center + half, center - half) if inverted else (center - half, center + half)
+    )
+
+
+def _close(a: tuple[float, float], b: tuple[float, float]) -> bool:
+    scale = max(abs(b[1] - b[0]), 1e-12)
+    return (
+        abs(a[0] - b[0]) <= _TOLERANCE * scale
+        and abs(a[1] - b[1]) <= _TOLERANCE * scale
+    )

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/src/tk_rt_viewer/viewer.py

@@ -21,9 +21,14 @@ Architecture:
 
 Slice navigation:
     - Drag a crosshair line.
-    - Mouse wheel over any view.
+    - Mouse wheel over any view (``scroll_inverted`` reverses it).
     - Up / Down / PageUp / PageDown keys.
 
+Zoom:
+    Ctrl + mouse wheel zooms the view under the pointer about the pointer,
+    each view independently (``set_zoom`` / ``get_zoom`` / ``reset_zoom``).
+    The views fill their layout cells; a new image or layout starts fitted.
+
 Window / level:
     Right-click drag: horizontal -> width, vertical -> centre, applied to
     ``state.window_level_target``; Shift targets the other image for that
@@ -49,6 +54,7 @@ from matplotlib.artist import Artist
 from matplotlib.axes import Axes
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 from matplotlib.figure import Figure
+from matplotlib.layout_engine import ConstrainedLayoutEngine
 from matplotlib.patches import Rectangle
 
 from .event_controllers.viewer_events import ViewerEventHandler
@@ -81,6 +87,7 @@ from .rendering.image_layer import ImageLayer
 from .rendering.isodose import IsoDoseOverlay
 from .rendering.layout import LayoutManager
 from .rendering.render import clim_to_window_level
+from .rendering.view_axes import ImageViewAxes
 from .state.viewer_state import SliceViewerState
 
 logger = logging.getLogger(__name__)
@@ -110,13 +117,30 @@ class DicomViewer(ttk.Frame):
     # must exceed the scroll debounce so a full render never lands mid-scroll
     _CACHE_REBUILD_IDLE_MS: int = 150
 
+    # Constrained-layout padding (inches / figure fraction). Matplotlib's
+    # defaults leave a visible frame around and between the views
+    _LAYOUT_PAD_INCHES: float = 1 / 72
+    _LAYOUT_SPACE: float = 0.0
+
     def __init__(
         self,
         parent: tk.Widget,
         state: SliceViewerState | None = None,
         fig_kwargs: dict | None = None,
+        *,
+        invert_scroll: bool = False,
     ) -> None:
+        """Build the widget.
+
+        Args:
+            parent: Tk parent widget.
+            state: Shared state; a private one is created when ``None``.
+            fig_kwargs: Extra ``Figure`` keyword arguments.
+            invert_scroll: Reverse the mouse-wheel direction for slice
+                scrolling (see :attr:`scroll_inverted`).
+        """
         super().__init__(parent)
+        self._invert_scroll_initial = invert_scroll
         self.rowconfigure(0, weight=1)
         self.columnconfigure(0, weight=1)
 
@@ -139,13 +163,21 @@ class DicomViewer(ttk.Frame):
     # ------------------------------------------------------------------
     def _build_widgets(self, fig_kwargs: dict | None) -> None:
         """Create the figure, canvas, toolbar and blend slider."""
-        kw: dict = {
-            "figsize": (10, 5),
-            "facecolor": (0.02, 0.02, 0.02),
-            "constrained_layout": True,
-        }
-        kw.update(fig_kwargs or {})
+        fig_kwargs = fig_kwargs or {}
+        kw: dict = {"figsize": (10, 5), "facecolor": (0.02, 0.02, 0.02)}
+        # Matplotlib rejects "layout" together with the legacy layout flags
+        if not {"layout", "constrained_layout", "tight_layout"} & fig_kwargs.keys():
+            kw["layout"] = "constrained"
+        kw.update(fig_kwargs)
         self.fig = Figure(**kw)
+        engine = self.fig.get_layout_engine()
+        if isinstance(engine, ConstrainedLayoutEngine):
+            engine.set(
+                w_pad=self._LAYOUT_PAD_INCHES,
+                h_pad=self._LAYOUT_PAD_INCHES,
+                wspace=self._LAYOUT_SPACE,
+                hspace=self._LAYOUT_SPACE,
+            )
         self.canvas = FigureCanvasTkAgg(self.fig, master=self)
         self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
         self.toolbar = NavigationToolbar2Tk(self.canvas, self)
@@ -223,7 +255,9 @@ class DicomViewer(ttk.Frame):
         # Last rendered slice per axis (several viewers may share one state)
         self._last_rendered_index: dict[str, int] = dict.fromkeys(AXES, -1)
 
-        self.event_handler = ViewerEventHandler(self.viewer_state, self)
+        self.event_handler = ViewerEventHandler(
+            self.viewer_state, self, invert_scroll=self._invert_scroll_initial
+        )
 
     def _bind_events(self) -> None:
         """Connect canvas events and subscribe to the state."""
@@ -833,6 +867,49 @@ class DicomViewer(ttk.Frame):
                 self.drawing_manager.add_request(axis)
             self.drawing_manager.flush()
 
+    @property
+    def scroll_inverted(self) -> bool:
+        """Whether the mouse wheel scrolls slices in the reverse direction.
+
+        Affects slice scrolling only; the brush size and the Ctrl + wheel
+        zoom keep the natural direction.
+        """
+        return self.event_handler.invert_scroll
+
+    @scroll_inverted.setter
+    def scroll_inverted(self, inverted: bool) -> None:
+        self.event_handler.invert_scroll = bool(inverted)
+
+    def get_zoom(self, axis: str) -> float:
+        """Return *axis*' zoom factor (1.0 = the whole slice fitted to the view).
+
+        Returns 1.0 for a view the current layout does not build.
+        """
+        ax = self.axs.get(axis)
+        return ax.zoom_factor() if isinstance(ax, ImageViewAxes) else 1.0
+
+    def set_zoom(
+        self, axis: str, zoom: float, anchor: tuple[float, float] | None = None
+    ) -> None:
+        """Zoom *axis* to *zoom*, independently of the other views.
+
+        Args:
+            axis: View to zoom (ignored if the current layout lacks it).
+            zoom: Factor, clipped to ``[MIN_ZOOM, MAX_ZOOM]`` of
+                :mod:`~tk_rt_viewer.rendering.view_axes`.
+            anchor: Data point kept at its screen position; ``None`` zooms
+                about the view centre.
+        """
+        ax = self.axs.get(axis)
+        if isinstance(ax, ImageViewAxes):
+            ax.zoom_to(zoom, anchor)
+            self.canvas.draw_idle()
+
+    def reset_zoom(self, axis: str | None = None) -> None:
+        """Fit the whole slice into *axis*, or into every view when ``None``."""
+        for name in [axis] if axis is not None else list(self.axs):
+            self.set_zoom(name, 1.0)
+
     def get_slice(self, view: str) -> np.ndarray:
         """Return the current 2-D slice for *view* as a NumPy array."""
         if self.viewer_state.primary_image is None:

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/tests/test_event_controllers.py

@@ -15,10 +15,12 @@ matplotlib.use("Agg")
 import numpy as np
 import pytest
 import SimpleITK as sitk
+from matplotlib.backends.backend_agg import FigureCanvasAgg
 from matplotlib.figure import Figure
 
 from tk_rt_viewer.event_controllers.viewer_events import ViewerEventHandler
 from tk_rt_viewer.protocols import ViewerHost
+from tk_rt_viewer.rendering.view_axes import ImageViewAxes
 from tk_rt_viewer.state.viewer_state import SliceViewerState
 
 
@@ -287,6 +289,135 @@ class TestScrollDebounce:
         assert dict(state.indices) == before
 
 
+class TestScrollInversion:
+    def test_inverted_scroll_moves_the_other_way(self) -> None:
+        ax = Figure().add_subplot(111)
+        state = loaded_state()
+        state.set_index("axial", 4)
+        handler, viewer = handler_for(state, FakeViewer({"axial": ax}))
+        handler.invert_scroll = True
+        handler.on_enter_axes(Event(inaxes=ax))
+        handler.on_scroll(Event(step=1))
+        handler.on_scroll(Event(step=1))
+        viewer.run_pending()
+        assert state.indices["axial"] == 2
+
+    def test_inversion_does_not_touch_the_keyboard(self) -> None:
+        ax = Figure().add_subplot(111)
+        state = loaded_state()
+        state.set_index("axial", 4)
+        handler, _viewer = handler_for(state, FakeViewer({"axial": ax}))
+        handler.invert_scroll = True
+        handler.on_enter_axes(Event(inaxes=ax))
+        handler.on_key_press(Event(key="up"))
+        assert state.indices["axial"] == 5
+
+
+class ScrollEvent(Event):
+    """Event carrying Matplotlib's ``modifiers`` set."""
+
+    def __init__(self, *args, modifiers=frozenset(), **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.modifiers = frozenset(modifiers)
+
+
+def zoomable_axes(state: SliceViewerState, axis: str = "axial") -> ImageViewAxes:
+    """An Agg-backed view set up as ImageLayer does for a new slice."""
+    fig = Figure(figsize=(6, 3))
+    FigureCanvasAgg(fig)
+    ax = fig.add_subplot(111, axes_class=ImageViewAxes)
+    x0, x1, y0, y1 = state.get_extent(axis)
+    ax.set_xlim(x0, x1)
+    ax.set_ylim(y1, y0) if axis == "axial" else ax.set_ylim(y0, y1)
+    ax.set_aspect("equal", adjustable="box")
+    ax.set_image_extent((x0, x1, y0, y1))
+    ax.apply_aspect()
+    return ax
+
+
+def x_fraction(ax, x: float) -> float:
+    """Horizontal screen position of data x within the view (0..1)."""
+    left, right = ax.get_xlim()
+    return (x - left) / (right - left)
+
+
+class TestZoom:
+    def _setup(self):
+        state = loaded_state((8, 16, 32))
+        axial = zoomable_axes(state, "axial")
+        coronal = zoomable_axes(state, "coronal")
+        handler, viewer = handler_for(
+            state, FakeViewer({"axial": axial, "coronal": coronal})
+        )
+        handler.on_enter_axes(Event(inaxes=axial))
+        return state, handler, axial, coronal
+
+    def test_starts_fitted(self) -> None:
+        _state, _handler, axial, _coronal = self._setup()
+        assert axial.zoom_factor() == pytest.approx(1.0)
+
+    def test_ctrl_wheel_zooms_about_the_pointer(self) -> None:
+        state, handler, axial, _coronal = self._setup()
+        before = dict(state.indices)
+        anchor = (10.0, 5.0)
+        frac = x_fraction(axial, anchor[0])
+        handler.on_scroll(
+            ScrollEvent(step=1, xdata=anchor[0], ydata=anchor[1], modifiers={"ctrl"})
+        )
+        axial.apply_aspect()
+        assert axial.zoom_factor() == pytest.approx(1.25)
+        assert x_fraction(axial, anchor[0]) == pytest.approx(frac)
+        assert dict(state.indices) == before  # no slice scroll
+        assert axial.yaxis_inverted()  # radiological orientation kept
+
+    def test_views_zoom_independently(self) -> None:
+        _state, _handler, axial, coronal = self._setup()
+        coronal_before = coronal.get_xlim()
+        axial.zoom_to(3.0)
+        assert axial.zoom_factor() == pytest.approx(3.0)
+        assert coronal.get_xlim() == coronal_before
+
+    def test_zoom_is_clamped_and_stays_on_the_image(self) -> None:
+        state, _handler, axial, _coronal = self._setup()
+        axial.zoom_to(100.0, anchor=(-50.0, -50.0))
+        assert axial.zoom_factor() == pytest.approx(20.0)
+        x0, _x1, _y0, _y1 = state.get_extent("axial")
+        assert min(axial.get_xlim()) >= x0 - 1e-9
+        axial.zoom_to(0.1)
+        assert axial.zoom_factor() == pytest.approx(1.0)
+
+    def test_ctrl_wheel_zooms_even_with_the_brush_active(self) -> None:
+        state, handler, axial, _coronal = self._setup()
+        state.set_brush_tool_active(True)
+        handler.on_scroll(ScrollEvent(step=1, xdata=8.0, ydata=4.0, modifiers={"ctrl"}))
+        assert axial.zoom_factor() == pytest.approx(1.25)
+
+    def test_a_resize_keeps_the_zoom_and_the_centre(self) -> None:
+        _state, _handler, axial, _coronal = self._setup()
+        axial.zoom_to(2.0, anchor=(20.0, 10.0))
+        axial.apply_aspect()
+        centre = np.mean(axial.get_xlim()), np.mean(axial.get_ylim())
+        axial.figure.set_size_inches(3, 6)
+        axial.apply_aspect()
+        assert axial.zoom_factor() == pytest.approx(2.0)
+        assert np.mean(axial.get_xlim()) == pytest.approx(centre[0])
+        # The taller box shows more than the slice height: centred on it
+        _x0, _x1, y0, y1 = axial._image_extent
+        assert np.mean(axial.get_ylim()) == pytest.approx((y0 + y1) / 2)
+        # 1:1 data aspect: data units per pixel match on both axes
+        width, height = axial.bbox.width, axial.bbox.height
+        x_span = abs(np.diff(axial.get_xlim())[0])
+        y_span = abs(np.diff(axial.get_ylim())[0])
+        assert x_span / width == pytest.approx(y_span / height)
+
+    def test_drawing_logs_no_aspect_warning(self, caplog) -> None:
+        _state, _handler, axial, _coronal = self._setup()
+        axial.zoom_to(3.0, anchor=(4.0, 4.0))
+        axial.figure.set_size_inches(5, 5)
+        axial.figure.canvas.draw()
+        assert "aspect" not in caplog.text
+
+
 class TestKeyboardNavigation:
     @pytest.mark.parametrize(
         "key,expected", [("up", 5), ("down", 3), ("pageup", 7), ("pagedown", 0)]

{tk_rt_viewer-2.2.1 → tk_rt_viewer-2.3.0}/tests/test_rendering.py

@@ -220,8 +220,8 @@ class TestBlitCompositor:
     ) -> None:
         """Pins the 2.0.3 fix: on_draw must key off ax.bbox, not just xlim/ylim.
 
-        With aspect="equal", adjustable="box" (every base image in this
-        package uses that), a figure resize changes ax.bbox but leaves
+        With aspect="equal", adjustable="box" (the base images used that
+        before 2.3.0), a figure resize changes ax.bbox but leaves
         get_xlim()/get_ylim() untouched. Comparing limits alone therefore
         missed every resize, leaving the background bitmap the old size and
         position until some unrelated event happened to trigger a full