PlotPy 2.6.2__tar.gz → 2.6.3__tar.gz

{plotpy-2.6.2 → plotpy-2.6.3}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog #
 
+## Version 2.6.3 ##
+
+🧯 In this release, test coverage is 79%.
+
+🛠️ Bug fixes:
+
+* [Issue #25](https://github.com/PlotPyStack/PlotPy/issues/25) - `OverflowError` with Contrast Adjustment panel for constant images
+* When updating image parameters (`ImageParam`) from the associated item object:
+  * If `xmin`, `xmax`, `ymin`, `ymax` attributes are not yet set (i.e. `None`), do not update them with the image data bounds
+  * Previous behavior was to update them with the image data bounds, which was leading to breaking the automatic bounds update when the image data is updated
+* [Issue #24](https://github.com/PlotPyStack/PlotPy/issues/24) - Colormap: side effect on image axes when changing the colormap
+* [Issue #23](https://github.com/PlotPyStack/PlotPy/issues/23) - Windows: Image `_scaler` engine performance regression
+* PySide6 compatibility issues:
+  * Fixed deprecated call to `QMouseEvent` in `tests/unit/utils.py`
+  * Added workaround for `QPolygonF` shape point slicing
+* [Issue #21](https://github.com/PlotPyStack/PlotPy/issues/21) - PySide6 on Linux: segfault in test_colormap_editor.py
+* Fixed `sliderMoved` signal connection in `ColorMapEditor`
+* Fixed `AssertionError` in test_rect_zoom.py (Linux, Python 3.12, PyQt6)
+* Fixed typing issues in `plotpy.events` module:
+  * Event objects were not properly typed (`QtCore.QEvent` instead of `QtGui.QMouseEvent`)
+  * Event position arguments were not properly typed (`QtCore.QPoint` instead of `QtCore.QPointF`)
+* Fix NumPy `FutureWarning: Format strings passed to MaskedConstant are ignored [...]` when displaying masked pixel coordinates
+
 ## Version 2.6.2 ##
 
 💥 New features / Enhancements:

{plotpy-2.6.2/PlotPy.egg-info → plotpy-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PlotPy
-Version: 2.6.2
+Version: 2.6.3
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License

{plotpy-2.6.2 → plotpy-2.6.3/PlotPy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PlotPy
-Version: 2.6.2
+Version: 2.6.3
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/__init__.py

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

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/events.py

@@ -98,6 +98,7 @@ from plotpy.items.shape.marker import Marker
 
 if TYPE_CHECKING:
     from qtpy.QtCore import QPoint
+    from qtpy.QtGui import QMouseEvent
 
     from plotpy.plot.base import BasePlot
 
@@ -259,7 +260,7 @@ class MouseEventMatch(EventMatch):
         """Return the set of event types handled by this event match"""
         return frozenset((self.evt_type,))
 
-    def __call__(self, event: QG.QMouseEvent) -> bool:
+    def __call__(self, event: QMouseEvent) -> bool:
         """Returns True if the event matches the event match
 
         Args:
@@ -282,7 +283,7 @@ class MouseEventMatch(EventMatch):
 
 
 class MouseMoveMatch(MouseEventMatch):
-    def __call__(self, event: QG.QMouseEvent) -> bool:
+    def __call__(self, event: QMouseEvent) -> bool:
         """Returns True if the event matches the event match
 
         Args:
@@ -655,7 +656,7 @@ class DragHandler(QC.QObject):
         self.last = QC.QPointF(pos)
         return dx, dy
 
-    def start_tracking(self, _filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def start_tracking(self, _filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Start tracking the mouse movement
 
         Args:
@@ -664,7 +665,7 @@ class DragHandler(QC.QObject):
         """
         self.start = self.last = QC.QPointF(event.pos())
 
-    def start_moving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def start_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Start moving the mouse
 
         Args:
@@ -673,7 +674,7 @@ class DragHandler(QC.QObject):
         """
         return self.move(filter, event)
 
-    def stop_tracking(self, _filter: StatefulEventFilter, _event: QC.QEvent) -> None:
+    def stop_tracking(self, _filter: StatefulEventFilter, _event: QMouseEvent) -> None:
         """Stop tracking the mouse movement
 
         Args:
@@ -683,7 +684,7 @@ class DragHandler(QC.QObject):
         pass
         # filter.plot.canvas().setMouseTracking(self.parent_tracking)
 
-    def stop_notmoving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_notmoving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Stop tracking the mouse movement when the mouse is not moving.
 
         Args:
@@ -692,7 +693,7 @@ class DragHandler(QC.QObject):
         """
         self.stop_tracking(filter, event)
 
-    def stop_moving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Stop moving the mouse
 
         Args:
@@ -701,7 +702,7 @@ class DragHandler(QC.QObject):
         """
         self.stop_tracking(filter, event)
 
-    def move(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Move the mouse
 
         Args:
@@ -755,28 +756,28 @@ class ClickHandler(QC.QObject):
 class PanHandler(DragHandler):
     cursor = QC.Qt.ClosedHandCursor
 
-    def move(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Move the mouse.
 
         Args:
             filter: The StatefulEventFilter instance.
             event: The mouse event.
         """
-        x_state, y_state = self.get_move_state(filter, event.pos())
+        x_state, y_state = self.get_move_state(filter, QC.QPointF(event.pos()))
         filter.plot.do_pan_view(x_state, y_state)
 
 
 class ZoomHandler(DragHandler):
     cursor = QC.Qt.SizeAllCursor
 
-    def move(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Move the mouse.
 
         Args:
             filter: The StatefulEventFilter instance.
             event: The mouse event.
         """
-        x_state, y_state = self.get_move_state(filter, event.pos())
+        x_state, y_state = self.get_move_state(filter, QC.QPointF(event.pos()))
         filter.plot.do_zoom_view(x_state, y_state)
 
 
@@ -1144,7 +1145,7 @@ class QtDragHandler(DragHandler):
     #: Signal emitted by QtDragHandler when moving
     SIG_MOVE = QC.Signal(object, "QEvent")
 
-    def start_tracking(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def start_tracking(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Starts tracking the drag event.
 
         Args:
@@ -1154,7 +1155,7 @@ class QtDragHandler(DragHandler):
         DragHandler.start_tracking(self, filter, event)
         self.SIG_START_TRACKING.emit(filter, event)
 
-    def stop_notmoving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_notmoving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Stops tracking when the drag event is not moving.
 
         Args:
@@ -1163,7 +1164,7 @@ class QtDragHandler(DragHandler):
         """
         self.SIG_STOP_NOT_MOVING.emit(filter, event)
 
-    def stop_moving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """
         Stops the movement of the drag event.
 
@@ -1173,7 +1174,7 @@ class QtDragHandler(DragHandler):
         """
         self.SIG_STOP_MOVING.emit(filter, event)
 
-    def move(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Handles the move event.
 
         Args:
@@ -1655,7 +1656,7 @@ class RectangularSelectionHandler(DragHandler):
         self.setup_shape_cb = setup_shape_cb
         self.avoid_null_shape = avoid_null_shape
 
-    def start_tracking(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def start_tracking(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Start tracking the mouse movement for selection and interaction.
 
         Args:
@@ -1664,7 +1665,7 @@ class RectangularSelectionHandler(DragHandler):
         """
         self.start = self.last = QC.QPointF(event.pos())
 
-    def start_moving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def start_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Start moving the object.
 
         Args:
@@ -1676,7 +1677,7 @@ class RectangularSelectionHandler(DragHandler):
         if self.avoid_null_shape:
             self.start -= QC.QPointF(1, 1)
         self.shape.move_local_point_to(self.shape_h0, self.start)
-        self.shape.move_local_point_to(self.shape_h1, event.pos())
+        self.shape.move_local_point_to(self.shape_h1, QC.QPointF(event.pos()))
         self.start_moving_action(filter, event)
         if self.setup_shape_cb is not None:
             self.setup_shape_cb(self.shape)
@@ -1684,7 +1685,7 @@ class RectangularSelectionHandler(DragHandler):
         filter.plot.replot()
 
     def start_moving_action(
-        self, filter: StatefulEventFilter, event: QC.QEvent
+        self, filter: StatefulEventFilter, event: QMouseEvent
     ) -> None:
         """Start moving the object.
 
@@ -1694,18 +1695,18 @@ class RectangularSelectionHandler(DragHandler):
         """
         pass
 
-    def move(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Move the object.
 
         Args:
             filter: The StatefulEventFilter instance.
             event: The mouse event.
         """
-        self.shape.move_local_point_to(self.shape_h1, event.pos())
+        self.shape.move_local_point_to(self.shape_h1, QC.QPointF(event.pos()))
         self.move_action(filter, event)
         filter.plot.replot()
 
-    def move_action(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def move_action(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Move the object.
 
         Args:
@@ -1714,7 +1715,7 @@ class RectangularSelectionHandler(DragHandler):
         """
         pass
 
-    def stop_moving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Stop moving the object.
 
         Args:
@@ -1725,20 +1726,22 @@ class RectangularSelectionHandler(DragHandler):
         self.stop_moving_action(filter, event)
         filter.plot.replot()
 
-    def stop_moving_action(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_moving_action(
+        self, filter: StatefulEventFilter, event: QMouseEvent
+    ) -> None:
         """Stop moving the object.
 
         Args:
             filter: The StatefulEventFilter instance.
             event: The mouse event.
         """
-        self.SIG_END_RECT.emit(filter, self.start, event.pos())
+        self.SIG_END_RECT.emit(filter, self.start, QC.QPointF(event.pos()))
 
 
 class PointSelectionHandler(RectangularSelectionHandler):
     """Class to handle point selections."""
 
-    def stop_notmoving(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_notmoving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:
         """Stop the point selection when the point is not moving.
 
         Args:
@@ -1751,14 +1754,16 @@ class PointSelectionHandler(RectangularSelectionHandler):
 class ZoomRectHandler(RectangularSelectionHandler):
     """Class to handle zoom rectangles."""
 
-    def stop_moving_action(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:
+    def stop_moving_action(
+        self, filter: StatefulEventFilter, event: QMouseEvent
+    ) -> None:
         """Stop moving the object.
 
         Args:
             filter: The StatefulEventFilter instance.
             event: The mouse event.
         """
-        filter.plot.do_zoom_rect_view(self.start, event.pos())
+        filter.plot.do_zoom_rect_view(self.start, QC.QPointF(event.pos()))
 
 
 def setup_standard_tool_filter(filter: StatefulEventFilter, start_state: int) -> int:

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/external/sliders/_generic_range_slider.py

@@ -27,20 +27,29 @@ class _GenericRangeSlider(_GenericSlider):
     integers.
     """
 
-    # Emitted when the slider value has changed, with the new slider values
-    _valuesChanged = Signal(tuple)
-
-    # Emitted when sliderDown is true and the slider moves
-    # This usually happens when the user is dragging the slider
-    # The value is the positions of *all* handles.
-    _slidersMoved = Signal(tuple)
+    # -- BEGIN -- Original implementation, causing segfault on Linux with PySide6
+    # https://github.com/PlotPyStack/PlotPy/issues/21
+    # _valuesChanged = Signal(tuple)
+    # _slidersMoved = Signal(tuple)
+    # -- END --
+
+    # -- BEGIN -- New implementation: avoid segfault by overriding the class attributes
+    # instead of overriding them through instance attributes in `__init__`
+    valueChanged = Signal(tuple)
+    sliderMoved = Signal(tuple)
+    # -- END --
 
     def __init__(self, *args, **kwargs):
         self._style = RangeSliderStyle()
 
         super().__init__(*args, **kwargs)
-        self.valueChanged = self._valuesChanged
-        self.sliderMoved = self._slidersMoved
+
+        # -- BEGIN -- Original implementation, causing segfault on Linux with PySide6
+        # https://github.com/PlotPyStack/PlotPy/issues/21
+        # self.valueChanged = self._valuesChanged
+        # self.sliderMoved = self._slidersMoved
+        # -- END --
+
         # list of values
         self._value: List[_T] = [20, 80]
 

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/external/sliders/_generic_slider.py

@@ -19,6 +19,7 @@ So that's what `_GenericSlider` is below.
 scalar (with one handle per item), and it forms the basis of
 QRangeSlider.
 """
+
 import os
 import platform
 from typing import TypeVar
@@ -59,9 +60,19 @@ USE_MAC_SLIDER_PATCH = (
 
 
 class _GenericSlider(QSlider):
-    _fvalueChanged = Signal(int)
-    _fsliderMoved = Signal(int)
-    _frangeChanged = Signal(int, int)
+    # -- BEGIN -- Original implementation, causing segfault on Linux with PySide6
+    # https://github.com/PlotPyStack/PlotPy/issues/21
+    # _fvalueChanged = Signal(int)
+    # _fsliderMoved = Signal(int)
+    # _frangeChanged = Signal(int, int)
+    # -- END --
+
+    # -- BEGIN -- New implementation: avoid segfault by overriding the class attributes
+    # instead of overriding them through instance attributes in `__init__`
+    valueChanged = Signal(int)
+    sliderMoved = Signal(int)
+    rangeChanged = Signal(int, int)
+    # -- END --
 
     MAX_DISPLAY = 5000
 
@@ -88,9 +99,13 @@ class _GenericSlider(QSlider):
         self._control_fraction = 0.04
 
         super().__init__(*args, **kwargs)
-        self.valueChanged = self._fvalueChanged
-        self.sliderMoved = self._fsliderMoved
-        self.rangeChanged = self._frangeChanged
+
+        # -- BEGIN -- Original implementation, causing segfault on Linux with PySide6
+        # https://github.com/PlotPyStack/PlotPy/issues/21
+        # self.valueChanged = self._fvalueChanged
+        # self.sliderMoved = self._fsliderMoved
+        # self.rangeChanged = self._frangeChanged
+        # -- END --
 
         self.setAttribute(Qt.WidgetAttribute.WA_Hover)
         self.setStyleSheet("")

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/items/image/base.py

@@ -398,7 +398,8 @@ class BaseImageItem(QwtPlotItem):
         """
         title = self.title().text()
         z = self.get_data(x, y)
-        return f"{title}:<br>x = {int(x):d}<br>y = {int(y):d}<br>z = {z:g}"
+        zstr = "--" if z is np.ma.masked else f"{z:g}"
+        return f"{title}:<br>x = {int(x):d}<br>y = {int(y):d}<br>z = {zstr}"
 
     def set_background_color(self, qcolor: QColor | str) -> None:
         """Set background color

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/items/shape/polygon.py

@@ -276,8 +276,10 @@ class PolygonShape(AbstractShape):
         painter.setBrush(brush)
         points = self.transform_points(xMap, yMap)
         if self.ADDITIONNAL_POINTS:
-            shape_points = points[: -self.ADDITIONNAL_POINTS]
-            other_points = points[-self.ADDITIONNAL_POINTS :]
+            # Slice indexing is not supported by PySide6, so we convert the `QPolygonF`
+            # object to a list before converting it back to a `QPolygonF` object:
+            shape_points = QG.QPolygonF(list(points)[: -self.ADDITIONNAL_POINTS])
+            other_points = QG.QPolygonF(list(points)[-self.ADDITIONNAL_POINTS :])
         else:
             shape_points = points
             other_points = []

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/items/shape/range.py

@@ -22,7 +22,9 @@ if TYPE_CHECKING:
     import qwt.scale_map
     from qtpy.QtCore import QPointF, QRectF
     from qtpy.QtGui import QPainter
+    from qwt import QwtSymbol
 
+    from plotpy.plot import BasePlot
     from plotpy.styles.base import ItemParameters
 
 
@@ -48,7 +50,7 @@ class XRangeSelection(AbstractShape):
             self.shapeparam = RangeShapeParam(_("Range"), icon="xrange.png")
             self.shapeparam.read_config(CONF, "histogram", "range")
         else:
-            self.shapeparam = shapeparam
+            self.shapeparam: RangeShapeParam = shapeparam
         self.pen = None
         self.sel_pen = None
         self.brush = None
@@ -78,7 +80,7 @@ class XRangeSelection(AbstractShape):
     def __setstate__(self, state: tuple) -> None:
         """Restore state information from pickling"""
         self.shapeparam, self._min, self._max = state
-        self.shapeparam.update_range(self)
+        self.shapeparam.update_item(self)
 
     def serialize(
         self,
@@ -137,34 +139,31 @@ class XRangeSelection(AbstractShape):
             yMap: Y axis scale map
             canvasRect: Canvas rectangle
         """
-        plot = self.plot()
+        plot: BasePlot = self.plot()
         if not plot:
             return
         if self.selected:
-            pen = self.sel_pen
-            sym = self.sel_symbol
+            pen: QG.QPen = self.sel_pen
+            sym: QwtSymbol = self.sel_symbol
         else:
-            pen = self.pen
-            sym = self.symbol
+            pen: QG.QPen = self.pen
+            sym: QwtSymbol = self.symbol
 
-        rct = plot.canvas().contentsRect()
-        rct2 = QC.QRectF(rct)
-        rct2.setLeft(xMap.transform(self._min))
-        rct2.setRight(xMap.transform(self._max))
+        rct = QC.QRectF(plot.canvas().contentsRect())
+        rct.setLeft(xMap.transform(self._min))
+        rct.setRight(xMap.transform(self._max))
 
-        painter.fillRect(rct2, self.brush)
+        painter.fillRect(rct, self.brush)
         painter.setPen(pen)
-        painter.drawLine(rct2.topLeft(), rct2.bottomLeft())
-        painter.drawLine(rct2.topRight(), rct2.bottomRight())
+        painter.drawLine(rct.topLeft(), rct.bottomLeft())
+        painter.drawLine(rct.topRight(), rct.bottomRight())
+
         dash = QG.QPen(pen)
         dash.setStyle(QC.Qt.DashLine)
         dash.setWidth(1)
         painter.setPen(dash)
-
-        center_x = int(rct2.center().x())
-        top = int(rct2.top())
-        bottom = int(rct2.bottom())
-        painter.drawLine(center_x, top, center_x, bottom)
+        cx = rct.center().x()
+        painter.drawLine(QC.QPointF(cx, rct.top()), QC.QPointF(cx, rct.bottom()))
 
         painter.setPen(pen)
         x0, x1, y = self.get_handles_pos()

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/styles/image.py

@@ -350,12 +350,12 @@ class ImageParam(RawImageParam):
         help=_("Locked images are not movable with the mouse"),
     )
     _xdata = BeginGroup(_("Image placement along X-axis"))
-    xmin = FloatItem(_("x|min"), default=None)
-    xmax = FloatItem(_("x|max"), default=None)
+    xmin = FloatItem(_("x|min"), default=None, check=False)
+    xmax = FloatItem(_("x|max"), default=None, check=False)
     _end_xdata = EndGroup(_("Image placement along X-axis"))
     _ydata = BeginGroup(_("Image placement along Y-axis"))
-    ymin = FloatItem(_("y|min"), default=None)
-    ymax = FloatItem(_("y|max"), default=None)
+    ymin = FloatItem(_("y|min"), default=None, check=False)
+    ymax = FloatItem(_("y|max"), default=None, check=False)
     _end_ydata = EndGroup(_("Image placement along Y-axis"))
 
     def update_param(self, item: ImageItem) -> None:
@@ -366,21 +366,9 @@ class ImageParam(RawImageParam):
         """
         super().update_param(item)
         self.xmin = item.xmin
-        if self.xmin is None:
-            self.xmin = 0.0
         self.ymin = item.ymin
-        if self.ymin is None:
-            self.ymin = 0.0
-        if item.is_empty():
-            shape = (0, 0)
-        else:
-            shape = item.data.shape
         self.xmax = item.xmax
-        if self.xmax is None:
-            self.xmax = float(shape[1])
         self.ymax = item.ymax
-        if self.ymax is None:
-            self.ymax = float(shape[0])
 
     def update_item(self, item: ImageItem) -> None:
         """Update the given image item from the parameters.

{plotpy-2.6.2 → plotpy-2.6.3}/plotpy/tests/features/test_image_data_update.py

@@ -23,6 +23,7 @@ import numpy as np
 import pytest
 from guidata.qthelpers import exec_dialog, qt_app_context
 from qtpy import QtCore as QC
+from qtpy import QtGui as QG
 from qtpy import QtWidgets as QW
 
 from plotpy.builder import make
@@ -31,31 +32,33 @@ from plotpy.tests import data as ptd
 from plotpy.tools import LockLUTRangeTool
 
 
-def get_data() -> np.ndarray:
+def get_data(variable_size: bool) -> np.ndarray:
     """Compute 2D Gaussian data and add a narrower Gaussian on top with a random
     position and amplitude."""
+    size = np.random.randint(50, 200) if variable_size else 100
     dtype = np.uint16
     amp = np.iinfo(dtype).max * 0.3
-    data = ptd.gen_2d_gaussian(100, dtype, sigma=10.0, x0=0.0, y0=0.0, amp=amp)
+    data = ptd.gen_2d_gaussian(size, dtype, sigma=10.0, x0=0.0, y0=0.0, amp=amp)
     # Choose a random position: x0, y0 have to be in the range [-10.0, 10.0]
     x0 = np.random.uniform(-10.0, 10.0)
     y0 = np.random.uniform(-10.0, 10.0)
     # Choose a random amplitude: a has to be in the range [0.1, 0.5]
     a = np.random.uniform(0.1, 0.7) * np.iinfo(dtype).max
     # Add the narrower Gaussian on top
-    data += ptd.gen_2d_gaussian(100, dtype, sigma=4.0, x0=x0, y0=y0, amp=a)
+    data += ptd.gen_2d_gaussian(size, dtype, sigma=4.0, x0=x0, y0=y0, amp=a)
     return data
 
 
 class ImageUpdateDialog(PlotDialog):
     """Dialog box for image update"""
 
-    def __init__(self, title):
+    def __init__(self, title: str, variable_size: bool = False) -> None:
+        self.variable_size = variable_size
         options = PlotOptions(title="-", show_contrast=True, type="image")
         super().__init__(title=title, toolbar=True, edit=False, options=options)
         self.resize(600, 600)
         self.timer = QC.QTimer()
-        self.item = make.image(get_data(), interpolation="nearest")
+        self.item = make.image(get_data(self.variable_size), interpolation="nearest")
         self.item.set_lut_range((15000, 28000))
         plot = self.get_plot()
         plot.add_item(self.item)
@@ -63,7 +66,7 @@ class ImageUpdateDialog(PlotDialog):
         self.counter = 0
         self.keep_lut_cb: QW.QCheckBox | None = None
 
-    def populate_plot_layout(self):
+    def populate_plot_layout(self) -> None:
         """Populate the plot layout"""
         start_btn = QW.QPushButton("Start image update")
         start_btn.clicked.connect(self.start_image_update)
@@ -74,9 +77,17 @@ class ImageUpdateDialog(PlotDialog):
         self.keep_lut_cb = QW.QCheckBox()
         self.keep_lut_cb.setChecked(False)
         self.add_widget(self.keep_lut_cb, 0, 2)
+        variable_size_cb = QW.QCheckBox("Variable size")
+        variable_size_cb.setChecked(self.variable_size)
+        variable_size_cb.stateChanged.connect(self.toggle_variable_size)
+        self.add_widget(variable_size_cb, 0, 3)
         self.add_widget(self.plot_widget, 1, 0, 1, 0)
 
-    def register_tools(self):
+    def toggle_variable_size(self, state: int) -> None:
+        """Toggle the variable size of the image"""
+        self.variable_size = state == QC.Qt.Checked
+
+    def register_tools(self) -> None:
         """Reimplement to connect the Keep LUT range checkbox to the item"""
         mgr = self.get_manager()
         keep_lut_tool = mgr.add_tool(LockLUTRangeTool)
@@ -87,18 +98,18 @@ class ImageUpdateDialog(PlotDialog):
         self.keep_lut_cb.setToolTip(keep_lut_tool.action.toolTip())
         self.keep_lut_cb.stateChanged.connect(keep_lut_tool.activate)
 
-    def start_image_update(self):
+    def start_image_update(self) -> None:
         """Start updating the image"""
         self.timer.timeout.connect(self.update_image)
         self.timer.start(500)
 
-    def stop_image_update(self):
+    def stop_image_update(self) -> None:
         """Stop updating the image"""
         self.timer.stop()
 
-    def update_image(self):
+    def update_image(self) -> None:
         """Update the image"""
-        data = get_data()
+        data = get_data(self.variable_size)
         self.counter += 1
         plot = self.get_plot()
 
@@ -111,7 +122,7 @@ class ImageUpdateDialog(PlotDialog):
         plot.set_title(f"Image update {self.counter:03d}")
         plot.replot()
 
-    def closeEvent(self, event):
+    def closeEvent(self, event: QG.QCloseEvent) -> None:
         """Reimplement closeEvent to stop the timer before closing the dialog"""
         self.timer.stop()
         super().closeEvent(event)