Add SyncPlotDialog class for synchronized plotting in a dialog interface

Author: PierreRaybaut

CHANGELOG.md

@@ -18,6 +18,9 @@
   * Added `AnnotatedXRange` and `AnnotatedYRange` items
   * These items provide X and Y range selection with an annotation label
   * They can be created using `make.annotated_xrange` and `make.annotated_yrange` functions
+* New `SyncPlotDialog` class:
+  * This class provides a dialog for displaying synchronized plots.
+  * This is a complementary class to `SyncPlotWindow`, providing a modal dialog interface for synchronized plotting.
 
 🧹 API cleanup: removed deprecated update methods (use `update_item` instead)
 

plotpy/plot/__init__.py

@@ -12,5 +12,6 @@
     PlotWindow,
     SubplotWidget,
     SyncPlotWindow,
+    SyncPlotDialog,
     set_widget_title_icon,
 )

plotpy/plot/plotwidget.py

@@ -889,57 +889,33 @@ def add_plot(
         self.manager.add_plot(plot, plot_id)
 
 
-class SyncPlotWindow(QW.QMainWindow):
-    """Window for showing plots, optionally synchronized
-
-    Args:
-        parent: parent widget
-        toolbar: show/hide toolbar
-        options: plot options
-        panels: additionnal panels
-        auto_tools: If True, the plot tools are automatically registered.
-         If False, the user must register the tools manually.
-        title: The window title
-        icon: The window icon
-        size: The window size (width, height). Defaults to None (no resize)
-
-    Usage: first, create a window, then add plots to it, then call the
-    :py:meth:`.SyncPlotWindow.finalize_configuration` method to add panels and
-    eventually register tools.
-
-    Example::
-
-        from plotpy.plot import BasePlot, SyncPlotWindow
-        win = SyncPlotWindow(title="My window")
-        plot = BasePlot()
-        win.add_plot(plot)
-        win.finalize_configuration()
-        win.show()
-    """
+class BaseSyncPlot:
+    """Base class for synchronized plot windows and dialogs"""
 
     def __init__(
         self,
-        parent: QWidget | None = None,
         toolbar: bool = True,
         options: PlotOptions | dict[str, Any] | None = None,
         auto_tools: bool = True,
         title: str = "PlotPy",
         icon: str = "plotpy.svg",
         size: tuple[int, int] | None = None,
     ) -> None:
-        super().__init__(parent)
-        set_widget_title_icon(self, title, icon, size)
         self.manager = PlotManager(None)
         self.manager.set_main(self)
         self.subplotwidget = SubplotWidget(self.manager, parent=self, options=options)
-        self.setCentralWidget(self.subplotwidget)
         self.toolbar = QW.QToolBar(_("Tools"), self)
         self.toolbar.setVisible(toolbar)
         self.manager.add_toolbar(self.toolbar, "default")
         self.toolbar.setMovable(True)
         self.toolbar.setFloatable(True)
-        self.addToolBar(self.toolbar)
         self.auto_tools = auto_tools
+        set_widget_title_icon(self, title, icon, size)
+        # Note: setup_layout() is called by subclasses after Qt widget initialization
+
+    def setup_layout(self) -> None:
+        """Setup the layout - to be implemented by subclasses"""
+        raise NotImplementedError("Subclasses must implement `setup_layout` method")
 
     def get_toolbar(self) -> QW.QToolBar:
         """Return main toolbar
@@ -969,11 +945,6 @@ def rescale_plots(self) -> None:
         for plot in self.subplotwidget.plots:
             plot.do_autoscale()
 
-    def showEvent(self, event):  # pylint: disable=C0103
-        """Reimplement Qt method"""
-        super().showEvent(event)
-        QC.QTimer.singleShot(0, self.rescale_plots)
-
     def add_plot(
         self,
         row: int,
@@ -995,10 +966,15 @@ def add_plot(
             plot_id = str(len(self.subplotwidget.plots) + 1)
         self.subplotwidget.add_plot(plot, row, col, plot_id)
         if sync and len(self.subplotwidget.plots) > 1:
-            syncaxis = self.manager.synchronize_axis
-            for i_plot in range(len(self.subplotwidget.plots) - 1):
-                syncaxis(X_BOTTOM, [plot_id, f"{i_plot + 1}"])
-                syncaxis(Y_LEFT, [plot_id, f"{i_plot + 1}"])
+            self._synchronize_with_existing_plots(plot_id)
+
+    def _synchronize_with_existing_plots(self, plot_id: str) -> None:
+        """Synchronize the new plot with existing plots"""
+        syncaxis = self.manager.synchronize_axis
+        for i_plot in range(len(self.subplotwidget.plots) - 1):
+            existing_plot_id = f"{i_plot + 1}"
+            syncaxis(X_BOTTOM, [plot_id, existing_plot_id])
+            syncaxis(Y_LEFT, [plot_id, existing_plot_id])
 
     def get_plots(self) -> list[BasePlot]:
         """Return the plots
@@ -1007,3 +983,117 @@ def get_plots(self) -> list[BasePlot]:
             list[BasePlot]: The plots
         """
         return self.subplotwidget.get_plots()
+
+
+class SyncPlotWindow(QW.QMainWindow, BaseSyncPlot):
+    """Window for showing plots, optionally synchronized
+
+    Args:
+        parent: parent widget
+        toolbar: show/hide toolbar
+        options: plot options
+        panels: additionnal panels
+        auto_tools: If True, the plot tools are automatically registered.
+         If False, the user must register the tools manually.
+        title: The window title
+        icon: The window icon
+        size: The window size (width, height). Defaults to None (no resize)
+
+    Usage: first, create a window, then add plots to it, then call the
+    :py:meth:`.SyncPlotWindow.finalize_configuration` method to add panels and
+    eventually register tools.
+
+    Example::
+
+        from plotpy.plot import BasePlot, SyncPlotWindow
+        win = SyncPlotWindow(title="My window")
+        plot = BasePlot()
+        win.add_plot(plot)
+        win.finalize_configuration()
+        win.show()
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        toolbar: bool = True,
+        options: PlotOptions | dict[str, Any] | None = None,
+        auto_tools: bool = True,
+        title: str = "PlotPy",
+        icon: str = "plotpy.svg",
+        size: tuple[int, int] | None = None,
+    ) -> None:
+        self.subplotwidget: SubplotWidget
+        self.toolbar: QW.QToolBar
+        QW.QMainWindow.__init__(self, parent)
+        BaseSyncPlot.__init__(self, toolbar, options, auto_tools, title, icon, size)
+        self.setup_layout()
+
+    def showEvent(self, event):  # pylint: disable=C0103
+        """Reimplement Qt method"""
+        super().showEvent(event)
+        QC.QTimer.singleShot(0, self.rescale_plots)
+
+    def setup_layout(self) -> None:
+        """Setup the main window layout"""
+        self.setCentralWidget(self.subplotwidget)
+        self.addToolBar(self.toolbar)
+
+
+class SyncPlotDialog(QW.QDialog, BaseSyncPlot):
+    """Dialog for showing plots, optionally synchronized
+
+    Args:
+        parent: parent widget
+        toolbar: show/hide toolbar
+        options: plot options
+        auto_tools: If True, the plot tools are automatically registered.
+         If False, the user must register the tools manually.
+        title: The window title
+        icon: The window icon
+        size: The window size (width, height). Defaults to None (no resize)
+
+    Usage: first, create a dialog, then add plots to it, then call the
+    :py:meth:`.SyncPlotDialog.finalize_configuration` method to add panels and
+    eventually register tools.
+
+    Example::
+
+        from plotpy.plot import BasePlot, SyncPlotDialog
+        dlg = SyncPlotDialog(title="My dialog")
+        plot = BasePlot()
+        dlg.add_plot(plot)
+        dlg.finalize_configuration()
+        dlg.exec()
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        toolbar: bool = True,
+        options: PlotOptions | dict[str, Any] | None = None,
+        auto_tools: bool = True,
+        title: str = "PlotPy",
+        icon: str = "plotpy.svg",
+        size: tuple[int, int] | None = None,
+    ) -> None:
+        self.subplotwidget: SubplotWidget
+        self.toolbar: QW.QToolBar
+        QW.QDialog.__init__(self, parent)
+        BaseSyncPlot.__init__(self, toolbar, options, auto_tools, title, icon, size)
+        self.setup_layout()
+        self.setWindowFlags(QC.Qt.Window)
+
+    def showEvent(self, event):  # pylint: disable=C0103
+        """Reimplement Qt method"""
+        super().showEvent(event)
+        QC.QTimer.singleShot(0, self.rescale_plots)
+
+    def setup_layout(self) -> None:
+        """Setup the dialog layout"""
+        self.plot_layout = QW.QGridLayout()
+        self.plot_layout.addWidget(self.subplotwidget)
+        layout = QW.QVBoxLayout()
+        layout.addWidget(self.toolbar)
+        layout.addLayout(self.plot_layout)
+        self.setLayout(layout)

plotpy/tests/widgets/test_syncplot.py

@@ -8,19 +8,21 @@
 from __future__ import annotations
 
 import numpy as np
-from guidata.qthelpers import qt_app_context
+from guidata.env import execenv
+from guidata.qthelpers import exec_dialog, qt_app_context
 from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
 
 from plotpy.builder import make
 from plotpy.plot import BasePlot, PlotOptions
-from plotpy.plot.plotwidget import SyncPlotWindow
+from plotpy.plot.plotwidget import SyncPlotDialog, SyncPlotWindow
 from plotpy.tests.data import gen_2d_gaussian
 
 
-def plot(plot_type, *itemlists):
-    """Plot items in SyncPlotDialog"""
-    win = SyncPlotWindow(
-        title="Window for showing plots, optionally synchronized",
+def show_with(cls: type[SyncPlotDialog] | type[SyncPlotWindow], plot_type, *itemlists):
+    """Show plot items in SyncPlotWindow or SyncPlotDialog"""
+    widget = cls(
+        title=f"{cls.__name__}: showing plots, optionally synchronized ({plot_type})",
         options=PlotOptions(type=plot_type),
     )
     row, col = 0, 0
@@ -30,16 +32,22 @@ def plot(plot_type, *itemlists):
             plot.add_item(item)
         plot.set_axis_font("left", QG.QFont("Courier"))
         plot.set_items_readonly(False)
-        win.add_plot(row, col, plot, sync=True)
+        widget.add_plot(row, col, plot, sync=True)
         col += 1
         if col == 2:
             row += 1
             col = 0
-    win.finalize_configuration()
+    widget.finalize_configuration()
     if plot_type == "image":
-        win.manager.get_contrast_panel().show()
-    win.resize(800, 600)
-    win.show()
+        widget.get_manager().get_contrast_panel().show()
+    widget.resize(800, 600)
+    if cls is SyncPlotWindow:
+        widget.show()
+        if not execenv.unattended:
+            app = QW.QApplication.instance()
+            app.exec()
+    else:
+        exec_dialog(widget)
 
 
 def test_syncplot_curves():
@@ -49,9 +57,8 @@ def test_syncplot_curves():
     y = np.sin(np.sin(np.sin(x)))
     x2 = np.linspace(-10, 10, 20)
     y2 = np.sin(np.sin(np.sin(x2)))
-    with qt_app_context(exec_loop=True):
-        plot(
-            "curve",
+    with qt_app_context():
+        itemlists = [
             [
                 make.curve(x, y, color="b"),
                 make.label(
@@ -70,21 +77,26 @@ def test_syncplot_curves():
                 make.label("Absolute position", "R", (0, 0), "R"),
                 make.legend("TR"),
             ],
-        )
+        ]
+        for cls in (SyncPlotWindow, SyncPlotDialog):
+            show_with(cls, "curve", *itemlists)
 
 
 def test_syncplot_images():
     """Test plot synchronization: images"""
     img1 = gen_2d_gaussian(20, np.uint8, x0=-10.0, y0=-10.0, mu=7.0, sigma=10.0)
     img2 = gen_2d_gaussian(20, np.uint8, x0=-10.0, y0=-10.0, mu=5.0, sigma=8.0)
     img3 = gen_2d_gaussian(20, np.uint8, x0=-10.0, y0=-10.0, mu=3.0, sigma=6.0)
-    with qt_app_context(exec_loop=True):
+    with qt_app_context():
 
         def makeim(data):
             """Make image item"""
             return make.image(data, interpolation="nearest")
 
-        plot("image", [makeim(img1)], [makeim(img2)], [makeim(img3)])
+        itemlists = [[makeim(img1)], [makeim(img2)], [makeim(img3)]]
+
+        for cls in (SyncPlotWindow, SyncPlotDialog):
+            show_with(cls, "image", *itemlists)
 
 
 if __name__ == "__main__":