PlotPy 2.9.0__tar.gz → 2.10.0__tar.gz

{plotpy-2.9.0 → plotpy-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PlotPy
-Version: 2.9.0
+Version: 2.10.0
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License
@@ -63,7 +63,7 @@ Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: guidata>=3.14.1
-Requires-Dist: PythonQwt>=0.15
+Requires-Dist: PythonQwt>=0.16
 Requires-Dist: numpy>=1.22
 Requires-Dist: SciPy>=1.7.3
 Requires-Dist: scikit-image>=0.19

{plotpy-2.9.0 → plotpy-2.10.0}/PlotPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PlotPy
-Version: 2.9.0
+Version: 2.10.0
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License
@@ -63,7 +63,7 @@ Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: guidata>=3.14.1
-Requires-Dist: PythonQwt>=0.15
+Requires-Dist: PythonQwt>=0.16
 Requires-Dist: numpy>=1.22
 Requires-Dist: SciPy>=1.7.3
 Requires-Dist: scikit-image>=0.19

{plotpy-2.9.0 → plotpy-2.10.0}/PlotPy.egg-info/SOURCES.txt

@@ -117,6 +117,7 @@ doc/release_notes/release_2.06.md
 doc/release_notes/release_2.07.md
 doc/release_notes/release_2.08.md
 doc/release_notes/release_2.09.md
+doc/release_notes/release_2.10.md
 plotpy/__init__.py
 plotpy/config.py
 plotpy/constants.py
@@ -464,6 +465,7 @@ plotpy/tests/unit/__init__.py
 plotpy/tests/unit/test_annotation_tools.py
 plotpy/tests/unit/test_arrayfuncs.py
 plotpy/tests/unit/test_aspect_ratio_tool.py
+plotpy/tests/unit/test_autoscale_strategy.py
 plotpy/tests/unit/test_baseplot.py
 plotpy/tests/unit/test_builder_annotation.py
 plotpy/tests/unit/test_builder_curve.py
@@ -477,6 +479,7 @@ plotpy/tests/unit/test_display_coords_tool.py
 plotpy/tests/unit/test_events.py
 plotpy/tests/unit/test_fontparam.py
 plotpy/tests/unit/test_geometry.py
+plotpy/tests/unit/test_image_log_set_data.py
 plotpy/tests/unit/test_io.py
 plotpy/tests/unit/test_line.py
 plotpy/tests/unit/test_line_cross_section_tool.py
@@ -489,6 +492,7 @@ plotpy/tests/unit/test_plot_curve.py
 plotpy/tests/unit/test_plot_image.py
 plotpy/tests/unit/test_rect_zoom.py
 plotpy/tests/unit/test_seg_dist.py
+plotpy/tests/unit/test_snapshot_original_size.py
 plotpy/tests/unit/test_styles.py
 plotpy/tests/unit/test_tools_export.py
 plotpy/tests/unit/utils.py

{plotpy-2.9.0 → plotpy-2.10.0}/PlotPy.egg-info/requires.txt

@@ -1,5 +1,5 @@
 guidata>=3.14.1
-PythonQwt>=0.15
+PythonQwt>=0.16
 numpy>=1.22
 SciPy>=1.7.3
 scikit-image>=0.19

plotpy-2.10.0/doc/release_notes/release_2.10.md

@@ -0,0 +1,34 @@
+# Version 2.10 #
+
+## PlotPy Version 2.10.0 ##
+
+✨ New features:
+
+* **Per-axis autoscale strategy**: Added configurable autoscale behavior for each axis via the axis parameters dialog. Three strategies are available: *Auto* (default — compute bounds from items), *Fixed range* (apply user-defined Min/Max values) and *Disabled* (leave the axis untouched on autoscale). New API: `BasePlot.set_axis_autoscale_strategy()` / `BasePlot.get_axis_autoscale_strategy()` (closes [Issue #63](https://github.com/PlotPyStack/PlotPy/issues/63), partial)
+* **Symbol border width**: Added an `edgewidth` parameter to `SymbolParam` for customizable marker border thickness — previously the border was always 1 pixel wide
+
+🛠️ Bug fixes:
+
+* **Rectangular snapshot tool** — Fixed the "Original size" computation (closes [Issue #57](https://github.com/PlotPyStack/PlotPy/issues/57)):
+  * The preview no longer displays negative dimensions when the X or Y axis is
+    reversed
+  * The "Original size" is now computed from pixel coordinates instead of axis
+    units, so it is correct for `XYImageItem` (and any item with non-uniform
+    axis scaling) regardless of axis orientation
+  * The `ValueError` raised by the resize dialog when the selection produced
+    negative dimensions on a reversed axis is gone
+  * Selecting a region larger than the plotted image now reports the same
+    native pixel resolution for both `ImageItem` and `XYImageItem`
+    (previously `XYImageItem` reported ``shape - 1`` while `ImageItem`
+    reported the full oversized resolution): exporting at "Original size"
+    now consistently preserves the source pixel density and avoids
+    upsampling, regardless of the item type
+* **Snapshot tool cursor** — Fixed the mouse cursor remaining stuck as a cross (`+`) outside the plot canvas (axes, toolbar) after using the snapshot tool. The modal dialogs are now opened after Qt has released the implicit pointer grab, so the cursor is correctly restored (closes [Issue #58](https://github.com/PlotPyStack/PlotPy/issues/58))
+* **Z-axis log tool** — Fixed the `ZAxisLogTool` being always disabled for non-`ImageItem` image types (`XYImageItem`, `MaskedImageItem`, `MaskedXYImageItem`, `TrImageItem`, `RGBImageItem`). The Z-axis log API (`get_zaxis_log_state` / `set_zaxis_log_state`) was moved from `ImageItem` up to `BaseImageItem` so all image item types support it. This notably fixes the tool being permanently greyed out in DataLab's image panel (closes [Issue #59](https://github.com/PlotPyStack/PlotPy/issues/59))
+* **Z-axis log data update** — Fixed image data not being recomputed when calling `set_data()` while Z-axis log scale is active — the log-transformed data is now refreshed and the LUT range preserved in log mode
+* **`YRangeCursorTool`** — Fixed incorrect inequality display and negative ∆y when the Y-range cursors are inverted (dragging the top cursor below the bottom one). Values are now sorted and ∆y is always positive (closes [Issue #55](https://github.com/PlotPyStack/PlotPy/issues/55))
+* **`CurveStatsTool`** — Replaced `min`/`max`/`mean`/`std`/`sum` with their NaN-safe equivalents (`nanmin`, `nanmax`, `nanmean`, `nanstd`, `nansum`) so that signal statistics are computed correctly when the data contains NaN values
+
+⚙️ Dependencies:
+
+* Bumped minimum PythonQwt version from 0.15 to **0.16** to benefit from the Qt6 performance optimizations (closes [Issue #22](https://github.com/PlotPyStack/PlotPy/issues/22) — see [PythonQwt#93](https://github.com/PlotPyStack/PythonQwt/issues/93) for the full optimization log)

{plotpy-2.9.0 → plotpy-2.10.0}/doc/requirements.rst

@@ -14,7 +14,7 @@ The `PlotPy` package requires the following Python modules:
       - >= 3.14.1
       - Automatic GUI generation for easy dataset editing and display
     * - PythonQwt
-      - >= 0.15
+      - >= 0.16
       - Qt plotting widgets for Python
     * - numpy
       - >= 1.22
@@ -26,10 +26,10 @@ The `PlotPy` package requires the following Python modules:
       - >= 0.19
       - Image processing in Python
     * - Pillow
-      -
+      - 
       - Python Imaging Library (fork)
     * - tifffile
-      -
+      - 
       - Read and write TIFF files
 
 Optional modules for GUI support (Qt):
@@ -55,26 +55,32 @@ Optional modules for development:
       - Version
       - Summary
     * - build
-      -
+      - 
       - A simple, correct Python build frontend
     * - babel
-      -
+      - 
       - Internationalization utilities
     * - Coverage
-      -
+      - 
       - Code coverage measurement for Python
     * - Cython
       - >=3.0
       - The Cython compiler for writing C extensions in the Python language.
     * - pylint
-      -
+      - 
       - python code static checker
     * - ruff
-      -
+      - 
       - An extremely fast Python linter and code formatter, written in Rust.
     * - pre-commit
-      -
+      - 
       - A framework for managing and maintaining multi-language pre-commit hooks.
+    * - setuptools
+      - 
+      - Most extensible Python build backend with support for C/C++ extension modules
+    * - wheel
+      - 
+      - Command line tool for manipulating wheel files
 
 Optional modules for building the documentation:
 
@@ -86,19 +92,19 @@ Optional modules for building the documentation:
       - Version
       - Summary
     * - sphinx
-      -
+      - 
       - Python documentation generator
     * - myst_parser
-      -
+      - 
       - An extended [CommonMark](https://spec.commonmark.org/) compliant parser,
     * - sphinx-copybutton
-      -
+      - 
       - Add a copy button to each of your code cells.
     * - sphinx_qt_documentation
-      -
+      - 
       - Plugin for proper resolve intersphinx references for Qt elements
     * - python-docs-theme
-      -
+      - 
       - The Sphinx theme for the CPython docs and related projects
 
 Optional modules for running test suite:
@@ -111,8 +117,8 @@ Optional modules for running test suite:
       - Version
       - Summary
     * - pytest
-      -
+      - 
       - pytest: simple powerful testing with Python
     * - pytest-xvfb
-      -
+      - 
       - A pytest plugin to run Xvfb (or Xephyr/Xvnc) for tests.

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/__init__.py

@@ -20,7 +20,7 @@ External resources:
 .. _GitHub: https://github.com/PierreRaybaut/plotpy
 """
 
-__version__ = "2.9.0"
+__version__ = "2.10.0"
 __VERSION__ = tuple([int(number) for number in __version__.split(".")])
 
 # --- Important note: DATAPATH and LOCALEPATH are used by guidata.configtools

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/__init__.py

@@ -33,6 +33,7 @@ from .image import (
     XYImageFilterItem,
     XYImageItem,
     assemble_imageitems,
+    compute_image_items_original_size,
     compute_trimageitems_original_size,
     get_image_from_plot,
     get_image_from_qrect,

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/image/__init__.py

@@ -11,6 +11,7 @@ from .misc import (
     Histogram2DItem,
     QuadGridItem,
     assemble_imageitems,
+    compute_image_items_original_size,
     compute_trimageitems_original_size,
     get_image_from_plot,
     get_image_from_qrect,

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/image/base.py

@@ -132,6 +132,12 @@ class BaseImageItem(QwtPlotItem):
         self._filename = None  # The file this image comes from
 
         self.histogram_cache = None
+
+        # Z-axis logarithmic scale support
+        self._log_data: np.ndarray | None = None
+        self._lin_lut_range: tuple[float, float] | None = None
+        self._is_zaxis_log = False
+
         if data is not None:
             self.set_data(data)
         self.param.update_item(self)
@@ -334,6 +340,15 @@ class BaseImageItem(QwtPlotItem):
         """
         return self.get_x_values(i0, i1)
 
+    def _recompute_log_data(self) -> None:
+        """Refresh the cached log10 data from the current ``self.data``.
+
+        Used both when toggling the Z-axis log scale on and when the underlying
+        data is replaced (e.g. via :meth:`set_data`) while the log scale is
+        already active.
+        """
+        self._log_data = np.array(np.log10(self.data.clip(1)), dtype=np.float64)
+
     def set_data(
         self, data: np.ndarray, lut_range: tuple[float, float] | None = None
     ) -> None:
@@ -347,9 +362,15 @@ class BaseImageItem(QwtPlotItem):
         self.histogram_cache = None
         self.update_bounds()
         self.update_border()
+        # Refresh the cached log10 data when log scale is active, otherwise the
+        # display would keep using the previous (now stale) log data.
+        if self.get_zaxis_log_state():
+            self._recompute_log_data()
         if not self.param.keep_lut_range:
             if lut_range is not None:
                 _min, _max = lut_range
+            elif self.get_zaxis_log_state():
+                _min, _max = get_nan_range(self._log_data)
             else:
                 _min, _max = get_nan_range(data)
             self.set_lut_range((_min, _max))
@@ -552,6 +573,34 @@ class BaseImageItem(QwtPlotItem):
         """
         return get_nan_range(self.data)
 
+    # ---- Z-axis logarithmic scale --------------------------------------------
+    def get_zaxis_log_state(self) -> bool:
+        """Return True if Z-axis is in logarithmic scale"""
+        return self._is_zaxis_log
+
+    def set_zaxis_log_state(self, state: bool) -> None:
+        """Set Z-axis logarithmic scale state
+
+        Args:
+            state: True to enable logarithmic scale, False otherwise
+        """
+        self._is_zaxis_log = state
+        plot = self.plot()
+        if state:
+            self._lin_lut_range = self.get_lut_range()
+            if self._log_data is None:
+                self._recompute_log_data()
+            self.set_lut_range(get_nan_range(self._log_data))
+            dtype = self._log_data.dtype
+        else:
+            self._log_data = None
+            self.set_lut_range(self._lin_lut_range)
+            dtype = self.data.dtype
+        if self.interpolate[0] == INTERP_AA:
+            self.interpolate = (INTERP_AA, self.interpolate[1].astype(dtype))
+        if plot is not None:
+            plot.update_colormap_axis(self)
+
     def get_lut_range_max(self) -> tuple[float, float]:
         """Get maximum range for this dataset
 

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/image/misc.py

@@ -577,19 +577,27 @@ def get_items_in_rectangle(
 
 def compute_trimageitems_original_size(
     items: list[TrImageItem],
-    src_w: list[float, float, float, float],
-    src_h: list[float, float, float, float],
+    src_w: float,
+    src_h: float,
 ) -> tuple[float, float]:
     """Compute `TrImageItem` original size from max dx and dy
 
     Args:
         items: List of image items
-        src_w: Source width
-        src_h: Source height
+        src_w: Source width (in plot axis units)
+        src_h: Source height (in plot axis units)
 
     Returns:
         Tuple of original size
+
+    .. note::
+
+        The returned size is always positive: when the source rectangle is
+        defined on a reversed axis, ``src_w`` and/or ``src_h`` may be
+        negative. The original (pixel) size is intrinsically positive,
+        independent of axis orientation.
     """
+    src_w, src_h = abs(src_w), abs(src_h)
     trparams = [item.get_transform() for item in items if isinstance(item, TrImageItem)]
     if trparams:
         dx_max = max([dx for _x, _y, _angle, dx, _dy, _hf, _vf in trparams])
@@ -598,6 +606,81 @@ def compute_trimageitems_original_size(
     return src_w, src_h
 
 
+def compute_image_items_original_size(
+    items: list[BaseImageItem],
+    plot: qwt.plot.QwtPlot,
+    p0: QPointF,
+    p1: QPointF,
+) -> tuple[float, float]:
+    """Compute the **native pixel resolution** of a rectangular selection
+    across the given image items.
+
+    The "Original size" semantics is *original resolution*: the returned
+    size is the number of source pixels that span the selection at the
+    item's native resolution, *independent of axis orientation or scaling*.
+    When the selection is larger than the plotted image, the returned size
+    is consequently larger than the image (the missing area will be padded
+    by the export step). When the selection is smaller, it is smaller in
+    pixels — there is **no** clipping to the image bounding rectangle, so
+    that exporting at "Original size" always preserves the source pixel
+    density.
+
+    Args:
+        plot: Plot
+        items: List of image items in the selection
+        p0: First canvas point (top-left, in canvas coordinates)
+        p1: Second canvas point (bottom-right, in canvas coordinates)
+
+    Returns:
+        Tuple ``(width, height)`` in pixels (always positive). When no
+        compatible item is found, falls back to the absolute axis-units
+        size of the selection.
+    """
+    p0x = plot.invTransform(X_BOTTOM, p0.x())
+    p0y = plot.invTransform(Y_LEFT, p0.y())
+    p1x = plot.invTransform(X_BOTTOM, p1.x() + 1)
+    p1y = plot.invTransform(Y_LEFT, p1.y() + 1)
+    sel_x0, sel_x1 = sorted([p0x, p1x])
+    sel_y0, sel_y1 = sorted([p0y, p1y])
+    sel_w = sel_x1 - sel_x0
+    sel_h = sel_y1 - sel_y0
+    widths: list[float] = []
+    heights: list[float] = []
+    for item in items:
+        data = getattr(item, "data", None)
+        if data is None:
+            continue
+        if isinstance(item, TrImageItem):
+            # Use the item's affine transform (handles rotation and shear)
+            get_pix = item.get_pixel_coordinates
+            try:
+                x0p, y0p = get_pix(sel_x0, sel_y0)
+                x1p, y1p = get_pix(sel_x1, sel_y1)
+            except (ValueError, TypeError, IndexError):
+                continue
+            widths.append(abs(x1p - x0p))
+            heights.append(abs(y1p - y0p))
+        else:
+            # For ImageItem / XYImageItem: convert the (possibly oversized)
+            # selection to pixels via the item's own pixel density. This
+            # avoids ``XYImageItem.get_pixel_coordinates`` clamping to
+            # integer indices and yields oversized values when the
+            # selection extends beyond the image — consistently with the
+            # historical behavior of ``ImageItem``.
+            brect = item.boundingRect()
+            bw = abs(brect.width())
+            bh = abs(brect.height())
+            if bw <= 0 or bh <= 0:
+                continue
+            widths.append(sel_w / bw * data.shape[1])
+            heights.append(sel_h / bh * data.shape[0])
+    if widths:
+        return max(widths), max(heights)
+    # Fallback: axis-units size (always positive)
+    _src_x, _src_y, src_w, src_h = get_plot_qrect(plot, p0, p1).getRect()
+    return abs(src_w), abs(src_h)
+
+
 def get_image_from_qrect(
     plot: BasePlot,
     p0: QPointF,
@@ -636,12 +719,12 @@ def get_image_from_qrect(
     if not items:
         raise TypeError(_("There is no supported image item in current plot."))
     if src_size is None:
-        _src_x, _src_y, src_w, src_h = get_plot_qrect(plot, p0, p1).getRect()
+        destw, desth = compute_image_items_original_size(items, plot, p0, p1)
     else:
         # The only benefit to pass the src_size list is to avoid any
         # rounding error in the transformation computed in `get_plot_qrect`
         src_w, src_h = src_size
-    destw, desth = compute_trimageitems_original_size(items, src_w, src_h)
+        destw, desth = compute_trimageitems_original_size(items, src_w, src_h)
     data = get_image_from_plot(
         plot,
         p0,

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/image/standard.py

@@ -11,7 +11,6 @@ from guidata.utils.misc import assert_interfaces_valid
 from qtpy import QtCore as QC
 
 from plotpy import io
-from plotpy._scaler import INTERP_AA
 from plotpy.config import _
 from plotpy.constants import LUTAlpha
 from plotpy.coords import canvas_to_axes, pixelround
@@ -29,7 +28,6 @@ from plotpy.interfaces import (
 )
 from plotpy.items.image.base import RawImageItem
 from plotpy.items.image.filter import XYImageFilterItem, to_bins
-from plotpy.mathutils.arrayfuncs import get_nan_range
 from plotpy.styles.image import ImageParam, RGBImageParam, XYImageParam
 
 if TYPE_CHECKING:
@@ -84,9 +82,6 @@ class ImageItem(RawImageItem):
         self.xmax = None
         self.ymin = None
         self.ymax = None
-        self._log_data = None
-        self._lin_lut_range = None
-        self._is_zaxis_log = False
         super().__init__(data=data, param=param)
 
     # ---- BaseImageItem API ---------------------------------------------------
@@ -228,28 +223,6 @@ class ImageItem(RawImageItem):
         (xmin, xmax), (ymin, ymax) = self.get_xdata(), self.get_ydata()
         self.bounds = QC.QRectF(QC.QPointF(xmin, ymin), QC.QPointF(xmax, ymax))
 
-    def get_zaxis_log_state(self):
-        """Reimplement image.ImageItem method"""
-        return self._is_zaxis_log
-
-    def set_zaxis_log_state(self, state):
-        """Reimplement image.ImageItem method"""
-        self._is_zaxis_log = state
-        plot = self.plot()
-        if state:
-            self._lin_lut_range = self.get_lut_range()
-            if self._log_data is None:
-                self._log_data = np.array(np.log10(self.data.clip(1)), dtype=np.float64)
-            self.set_lut_range(get_nan_range(self._log_data))
-            dtype = self._log_data.dtype
-        else:
-            self._log_data = None
-            self.set_lut_range(self._lin_lut_range)
-            dtype = self.data.dtype
-        if self.interpolate[0] == INTERP_AA:
-            self.interpolate = (INTERP_AA, self.interpolate[1].astype(dtype))
-        plot.update_colormap_axis(self)
-
     # ---- BaseImageItem API ---------------------------------------------------
     def get_pixel_coordinates(self, xplot: float, yplot: float) -> tuple[float, float]:
         """Get pixel coordinates from plot coordinates
@@ -684,8 +657,12 @@ class XYImageItem(RawImageItem):
             return
         xytr = self.x, self.y, src_rect
         dst_rect = tuple([int(i) for i in dst_rect])
+        if self.get_zaxis_log_state():
+            data = self._log_data
+        else:
+            data = self.data
         dest = _scale_xy(
-            self.data, xytr, self._offscreen, dst_rect, self.lut, self.interpolate
+            data, xytr, self._offscreen, dst_rect, self.lut, self.interpolate
         )
         qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
         painter.drawImage(qrect, self._image, qrect)

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/items/image/transform.py

@@ -274,8 +274,12 @@ class TrImageItem(RawImageItem):
         mat = self.tr @ tr
 
         dst_rect = tuple([int(i) for i in dst_rect])
+        if self.get_zaxis_log_state():
+            data = self._log_data
+        else:
+            data = self.data
         dest = _scale_tr(
-            self.data, mat, self._offscreen, dst_rect, self.lut, self.interpolate
+            data, mat, self._offscreen, dst_rect, self.lut, self.interpolate
         )
         qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
         painter.drawImage(qrect, self._image, qrect)

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/plot/base.py

@@ -325,6 +325,9 @@ class BasePlot(qwt.QwtPlot):
 
         self.__autoscale_excluded_items: list[itf.IBasePlotItem] = []
         self.autoscale_margin_percent = options.autoscale_margin_percent
+        self._axis_autoscale_strategy: dict[
+            int, tuple[str, float | None, float | None]
+        ] = {axis_id: ("auto", None, None) for axis_id in self.AXIS_IDS}
         self.lock_aspect_ratio = options.lock_aspect_ratio
         self.__autoLockAspectRatio = False
         if self.lock_aspect_ratio is None:
@@ -2177,9 +2180,54 @@ class BasePlot(qwt.QwtPlot):
         ]
         return [item_ref() for item_ref in self.__autoscale_excluded_items]
 
+    def get_axis_autoscale_strategy(
+        self, axis_id: int
+    ) -> tuple[str, float | None, float | None]:
+        """Return the autoscale strategy configured for a given axis.
+
+        Args:
+            axis_id: the axis ID
+
+        Returns:
+            A 3-tuple ``(strategy, vmin, vmax)`` where ``strategy`` is one of
+            ``"auto"``, ``"fixed"`` or ``"none"``. ``vmin``/``vmax`` are the
+            user-defined bounds applied when ``strategy == "fixed"``
+            (``None`` otherwise).
+        """
+        return self._axis_autoscale_strategy.get(axis_id, ("auto", None, None))
+
+    def set_axis_autoscale_strategy(
+        self,
+        axis_id: int,
+        strategy: str,
+        vmin: float | None = None,
+        vmax: float | None = None,
+    ) -> None:
+        """Set the autoscale strategy for a given axis.
+
+        Args:
+            axis_id: the axis ID
+            strategy: one of ``"auto"`` (compute bounds from items, current
+             behavior), ``"fixed"`` (apply ``vmin``/``vmax``) or ``"none"``
+             (leave the axis untouched on autoscale)
+            vmin: lower bound applied when ``strategy == "fixed"``
+            vmax: upper bound applied when ``strategy == "fixed"``
+        """
+        if strategy not in ("auto", "fixed", "none"):
+            raise ValueError(
+                f"Invalid autoscale strategy {strategy!r}: "
+                "expected one of 'auto', 'fixed', 'none'"
+            )
+        self._axis_autoscale_strategy[axis_id] = (strategy, vmin, vmax)
+
     def do_autoscale(self, replot: bool = True, axis_id: int | None = None) -> None:
         """Do autoscale on all axes
 
+        The behavior of each axis depends on its autoscale strategy
+        (see :py:meth:`set_axis_autoscale_strategy`): ``"auto"`` computes
+        bounds from items (default), ``"fixed"`` applies the configured
+        ``vmin``/``vmax`` and ``"none"`` leaves the axis untouched.
+
         Args:
             replot (bool): replot the widget (optional, default=True)
             axis_id (int | None): the axis ID (optional, default=None)
@@ -2191,6 +2239,14 @@ class BasePlot(qwt.QwtPlot):
             vmin, vmax = None, None
             if not self.axisEnabled(axis_id):
                 continue
+            strategy, fixed_vmin, fixed_vmax = self.get_axis_autoscale_strategy(axis_id)
+            if strategy == "none":
+                continue
+            if strategy == "fixed":
+                if fixed_vmin is None or fixed_vmax is None:
+                    continue
+                self.set_axis_limits(axis_id, fixed_vmin, fixed_vmax)
+                continue
             for item in self.get_items():
                 if (
                     isinstance(item, self.AUTOSCALE_TYPES)

{plotpy-2.9.0 → plotpy-2.10.0}/plotpy/styles/axes.py

@@ -47,6 +47,20 @@ class AxisParam(DataSet):
         [("lin", _("linear")), ("log", _("logarithmic")), ("datetime", _("date/time"))],
         default="lin",
     )
+    autoscale = ChoiceItem(
+        _("Autoscale strategy"),
+        [
+            ("auto", _("Auto")),
+            ("fixed", _("Fixed range")),
+            ("none", _("Disabled")),
+        ],
+        default="auto",
+        help=_(
+            "Strategy used by the AutoScale action for this axis: "
+            "'Auto' computes bounds from items, 'Fixed range' applies the "
+            "Min/Max values defined above, 'Disabled' leaves the axis untouched."
+        ),
+    )
     vmin = FloatItem("Min", help=_("Lower axis limit"), default=0.0)
     vmax = FloatItem("Max", help=_("Upper axis limit"), default=1.0)
 
@@ -62,6 +76,13 @@ class AxisParam(DataSet):
         axis: QwtScaleDiv = plot.axisScaleDiv(axis_id)
         self.vmin = axis.lowerBound()
         self.vmax = axis.upperBound()
+        strategy, fixed_vmin, fixed_vmax = plot.get_axis_autoscale_strategy(axis_id)
+        self.autoscale = strategy
+        if strategy == "fixed":
+            if fixed_vmin is not None:
+                self.vmin = fixed_vmin
+            if fixed_vmax is not None:
+                self.vmax = fixed_vmax
 
     def update_axis(self, plot: BasePlot, axis_id: int) -> None:
         """
@@ -74,6 +95,9 @@ class AxisParam(DataSet):
         plot.enableAxis(axis_id, True)
         plot.set_axis_scale(axis_id, self.scale, autoscale=False)
         plot.setAxisScale(axis_id, self.vmin, self.vmax)
+        plot.set_axis_autoscale_strategy(
+            axis_id, self.autoscale, vmin=self.vmin, vmax=self.vmax
+        )
         plot.disable_unused_axes()
         plot.SIG_AXIS_PARAMETERS_CHANGED.emit(axis_id)