pymodaq 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

pymodaq/utils/plotting/data_viewers/viewer.py

@@ -1,56 +1,22 @@
-from typing import List, Union, TYPE_CHECKING, Iterable
+from typing import List, Union
 import numpy as np
 
 from qtpy import QtWidgets
-from qtpy.QtCore import QObject, Signal, Slot
-
-from pyqtgraph.graphicsItems import InfiniteLine, ROI
 
 from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.data import DataToExport, DataRaw, DataWithAxes, Axis, DataSource
-from pymodaq.utils.exceptions import ViewerError
-from pymodaq.utils.enums import BaseEnum, enum_checker
-from pymodaq.utils.factory import ObjectFactory, BuilderBase
+from pymodaq.utils.data import DataToExport, DataWithAxes, Axis, DataSource
+
+from pymodaq.utils.enums import enum_checker
+from pymodaq.utils.factory import ObjectFactory
 from pymodaq.utils.plotting import data_viewers
+from pymodaq.utils.plotting.data_viewers.base import ViewerBase, ViewersEnum
 from pymodaq.utils.gui_utils import DockArea, Dock
-from pymodaq.utils.managers.parameter_manager import ParameterManager
 
-if TYPE_CHECKING:
-    from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
-    from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
-    from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
-    from pymodaq.utils.plotting.data_viewers.viewerND import ViewerND
-
-config_viewers = {
-}
+config_viewers = {}
 
 logger = set_logger(get_module_name(__file__))
 
 
-class ViewersEnum(BaseEnum):
-    """enum relating a given viewer with data type"""
-    Viewer0D = 'Data0D'
-    Viewer1D = 'Data1D'
-    Viewer2D = 'Data2D'
-    ViewerND = 'DataND'
-    ViewerSequential = 'DataSequential'
-
-    def get_dim(self):
-        return self.value.split('Data')[1].split('D')[0]
-
-    def increase_dim(self, ndim: int):
-        dim = self.get_dim()
-        if dim != 'N':
-            dim_as_int = int(dim) + ndim
-            if dim_as_int > 2:
-                dim = 'N'
-            else:
-                dim = str(dim_as_int)
-        else:
-            dim = 'N'
-        return ViewersEnum[f'Viewer{dim}D']
-
-
 def get_viewer_enum_from_axes(Naxes: int):
     if Naxes < 0:
         raise ValueError('Naxes could not be below 0')
@@ -104,176 +70,35 @@ def create_viewerND(parent: QtWidgets.QWidget, **_ignored):
 viewer_factory = ViewerFactory()
 
 
-class ViewerBase(QObject):
-    """Base Class for data viewers implementing all common functionalities
+class ViewerDispatcher:
+    """MixIn class to add easy control for adding multuiple data viewers in docks depending on
+    data to be plotted
 
     Parameters
     ----------
-    parent: QtWidgets.QWidget
+    dockarea: DockArea
     title: str
+    next_to_dock: Dock
+        (deprecated) has no effect
+    direction: str
+        either 'right', 'left', 'bottom', 'top'.
 
-    Attributes
-    ----------
-    view: QObject
-        Ui interface of the viewer
-
-    data_to_export_signal: Signal[DataToExport]
-    ROI_changed: Signal
-    crosshair_dragged: Signal[float, float]
-    crosshair_clicked: Signal[bool]
-    sig_double_clicked: Signal[float, float]
-    status_signal: Signal[str]
     """
-    data_to_export_signal = Signal(DataToExport)
-    _data_to_show_signal = Signal(DataWithAxes)
-
-    ROI_changed = Signal()
-    crosshair_dragged = Signal(float, float)  # Crosshair position in units of scaled top/right axes
-    status_signal = Signal(str)
-    crosshair_clicked = Signal(bool)
-    sig_double_clicked = Signal(float, float)
 
-    def __init__(self, parent: QtWidgets.QWidget = None, title=''):
-        super().__init__()
-        self.title = title if title != '' else self.__class__.__name__
-
-        self._raw_data = None
-        self.data_to_export: DataToExport = DataToExport(name=self.title)
-        self.view: Union[Viewer0D, Viewer1D, Viewer2D, ViewerND] = None
-
-        if parent is None:
-            parent = QtWidgets.QWidget()
-            parent.show()
-        self.parent = parent
-
-        self._display_temporary = False
-
-    @property
-    def has_action(self):
-        """Convenience method"""
-        if hasattr(self.view, 'has_action'):
-            return self.view.has_action
-
-    @property
-    def is_action_checked(self):
-        """Convenience method"""
-        if hasattr(self.view, 'is_action_checked'):
-            return self.view.is_action_checked
-
-    @property
-    def is_action_visible(self):
-        """Convenience method"""
-        if hasattr(self.view, 'is_action_visible'):
-            return self.view.is_action_visible
-
-    @property
-    def set_action_checked(self):
-        """Convenience method"""
-        if hasattr(self.view, 'set_action_checked'):
-            return self.view.set_action_checked
-
-    @property
-    def set_action_visible(self):
-        """Convenience method"""
-        if hasattr(self.view, 'set_action_visible'):
-            return self.view.set_action_visible
-
-    @property
-    def get_action(self):
-        """Convenience method"""
-        if hasattr(self.view, 'get_action'):
-            return self.view.get_action
-
-    @property
-    def toolbar(self):
-        """Convenience property"""
-        if hasattr(self.view, 'toolbar'):
-            return self.view.toolbar
-
-    @property
-    def viewer_type(self):
-        """str: the viewer data type see DATA_TYPES"""
-        return ViewersEnum[self.__class__.__name__].value
-
-    def show_data(self, data: DataWithAxes, **kwargs):
-        """Entrypoint to display data into the viewer
-
-        Parameters
-        ----------
-        data: data_mod.DataFromPlugins
-        """
-        if len(data.shape) > 4:
-            raise ViewerError(f'Ndarray of dim: {len(data.shape)} cannot be plotted using a {self.viewer_type}')
-
-        self.data_to_export = DataToExport(name=self.title)
-        self._raw_data = data
-
-        self._display_temporary = False
-
-        self._show_data(data, **kwargs)
-
-    def show_data_temp(self, data: DataRaw, **kwargs):
-        """Entrypoint to display temporary data into the viewer
-
-        No processed data signal is emitted from the viewer
-
-        Parameters
-        ----------
-        data: data_mod.DataFromPlugins
-        """
-        self._display_temporary = True
-        self.show_data(data, **kwargs)
-
-    def _show_data(self, data: DataRaw):
-        """Specific viewers should implement it"""
-        raise NotImplementedError
-
-    def add_attributes_from_view(self):
-        """Convenience function to add attributes from the view to self"""
-        for attribute in self.convenience_attributes:
-            if hasattr(self.view, attribute):
-                setattr(self, attribute, getattr(self.view, attribute))
-
-    def trigger_action(self, action_name: str):
-        """Convenience function to trigger programmatically one of the action of the related view"""
-        if self.has_action(action_name):
-            self.get_action(action_name).trigger()
-
-    def activate_roi(self, activate=True):
-        """Activate the Roi manager using the corresponding action"""
-        raise NotImplementedError
-
-    def setVisible(self, show=True):
-        """convenience method to show or hide the paretn widget"""
-        self.parent.setVisible(show)
-
-    @property
-    def roi_target(self) -> Union[InfiniteLine.InfiniteLine, ROI.ROI]:
-        """To be implemented if necessary (Viewer1D and above)"""
-        return None
-
-    def move_roi_target(self, pos: Iterable[float] = None, **kwargs):
-        """move a specific read only ROI at the given position on the viewer"""
-        ...
-
-    def show_roi_target(self, show=True):
-        """Show/Hide a specific read only ROI"""
-        if self.roi_target is not None:
-            self.roi_target.setVisible(show)
-
-
-class ViewerDispatcher:
-    """MixIn class to add easy control for adding multuiple data viewers in docks depending on data to be plotted"""
-
-    def __init__(self, dockarea: DockArea = None, title: str = '', next_to_dock: Dock = None):
+    def __init__(self, dockarea: DockArea = None, title: str = '', next_to_dock: Dock = None,
+                 direction='right'):
         super().__init__()
         self._title = title
+
         self._next_to_dock = next_to_dock
+
         if dockarea is None:
             dockarea = DockArea()
             dockarea.show()
         self.dockarea = dockarea
 
+        self._direction = direction
+
         self._viewer_docks = []
         self._viewer_widgets = []
         self._viewer_types = []
@@ -337,9 +162,10 @@ class ViewerDispatcher:
         #         self.dockarea.addDock(self.viewer_docks[-1])
         # else:
         #     self.dockarea.addDock(self.viewer_docks[-1], 'right', self.viewer_docks[-2])
-        self.dockarea.addDock(self.viewer_docks[-1], 'right')
+        self.dockarea.addDock(self.viewer_docks[-1], self._direction)
 
-    def update_viewers(self, viewers_type: List[ViewersEnum], viewers_name: List[str] = None, force=False):
+    def update_viewers(self, viewers_type: List[Union[str, ViewersEnum]],
+                       viewers_name: List[str] = None, force=False):
         """
 
         Parameters
@@ -369,7 +195,8 @@ class ViewerDispatcher:
         ind_loop = 0
         while len(self.viewers) < len(viewers_type):
             self.add_viewer(viewers_type[Nviewers_to_leave + ind_loop],
-                            dock_name=viewers_name[Nviewers_to_leave + ind_loop] if viewers_name is not None else None)
+                            dock_name=viewers_name[Nviewers_to_leave + ind_loop]
+                            if viewers_name is not None else None)
             ind_loop += 1
         QtWidgets.QApplication.processEvents()
 
@@ -377,9 +204,9 @@ class ViewerDispatcher:
         for dock in self.viewer_docks:
             dock.close()
 
-    def show_data(self, data: DataToExport):
+    def show_data(self, data: DataToExport, **kwargs):
         """ Convenience method. Display each dwa in a dedicated data viewer"""
-        viewer_types = [ViewersEnum(dwa.dim.name) for dwa in data]
+        viewer_types = [ViewersEnum.get_viewers_enum_from_data(dwa) for dwa in data]
         if self.viewer_types != viewer_types:
             self.update_viewers(viewer_types)
         for viewer, dwa in zip(self.viewers, data):
@@ -426,7 +253,7 @@ if __name__ == '__main__':
         return dat1, dat2, data
 
     import sys
-    import random
+
     app = QtWidgets.QApplication(sys.argv)
 
     dockarea = DockArea()

pymodaq/utils/plotting/data_viewers/viewer0D.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Union, Dict
 from numbers import Real
 
 from qtpy import QtWidgets, QtGui
@@ -19,7 +19,7 @@ from collections import OrderedDict
 import datetime
 
 logger = set_logger(get_module_name(__file__))
-PLOT_COLORS = utils.plot_colors
+PLOT_COLORS = [dict(color=color) for color in utils.plot_colors]
 
 
 class DataDisplayer(QObject):
@@ -30,9 +30,10 @@ class DataDisplayer(QObject):
     updated_item = Signal(list)
     labels_changed = Signal(list)
 
-    def __init__(self, plotitem: pyqtgraph.PlotItem):
+    def __init__(self, plotitem: pyqtgraph.PlotItem, plot_colors=PLOT_COLORS):
         super().__init__()
         self._plotitem = plotitem
+        self.colors = plot_colors
         self._plotitem.addLegend()
         self._plot_items: List[pyqtgraph.PlotDataItem] = []
         self._min_lines: List[pyqtgraph.InfiniteLine] = []
@@ -47,10 +48,18 @@ class DataDisplayer(QObject):
         axis = self._plotitem.getAxis('bottom')
         axis.setLabel(text='Samples', units='S')
 
+    def update_colors(self, colors: List[QtGui.QPen]):
+        self.colors[0:len(colors)] = colors
+        self.update_data(self._data.last_data, force_update=True)
+
     @property
-    def legend(self):
+    def legend(self) -> pyqtgraph.LegendItem:
         return self._plotitem.legend
 
+    @property
+    def legend_names(self) -> List[str]:
+        return [item[1].text for item in self.legend.items]
+
     @property
     def axis(self):
         return self._data.xaxis
@@ -63,49 +72,58 @@ class DataDisplayer(QObject):
     def update_axis(self, history_length: int):
         self._data.length = history_length
 
-    def update_data(self, data: data_mod.DataRaw):
-        if len(data) != len(self._plot_items):
-            self.update_display_items(data)
+    @property
+    def Ndata(self):
+        return len(self._data.last_data) if self._data.last_data is not None else 0
 
-        self._data.add_datas(data)
-        for ind, data_str in enumerate(self._data.datas):
-            self._plot_items[ind].setData(self._data.xaxis, self._data.datas[data_str])
-        if len(self._mins) != len(self._data.datas):
-            self._mins = []
-            self._maxs = []
+    def update_data(self, data: data_mod.DataWithAxes, force_update=False):
+        if data is not None:
+            if len(data) != len(self._plot_items) or force_update or data.labels != self.legend_names:
+                self.update_display_items(data)
 
-        for ind, label in enumerate(self._data.datas):
+            self._data.add_datas(data)
+            for ind, data_str in enumerate(self._data.datas):
+                self._plot_items[ind].setData(self._data.xaxis, self._data.datas[data_str])
             if len(self._mins) != len(self._data.datas):
-                self._mins.append(float(np.min(self._data.datas[label])))
-                self._maxs.append(float(np.max(self._data.datas[label])))
-            else:
-                self._mins[ind] = min(self._mins[ind], float(np.min(self._data.datas[label])))
-                self._maxs[ind] = max(self._maxs[ind], float(np.max(self._data.datas[label])))
-            self._min_lines[ind].setValue(self._mins[ind])
-            self._max_lines[ind].setValue(self._maxs[ind])
-
-    def update_display_items(self, data: data_mod.DataRaw):
+                self._mins = []
+                self._maxs = []
+
+            for ind, label in enumerate(self._data.datas):
+                if len(self._mins) != len(self._data.datas):
+                    self._mins.append(float(np.min(self._data.datas[label])))
+                    self._maxs.append(float(np.max(self._data.datas[label])))
+                else:
+                    self._mins[ind] = min(self._mins[ind], float(np.min(self._data.datas[label])))
+                    self._maxs[ind] = max(self._maxs[ind], float(np.max(self._data.datas[label])))
+                self._min_lines[ind].setValue(self._mins[ind])
+                self._max_lines[ind].setValue(self._maxs[ind])
+
+    def update_display_items(self, data: data_mod.DataWithAxes = None):
         while len(self._plot_items) > 0:
             plot_item = self._plotitem.removeItem(self._plot_items.pop(0))
             self.legend.removeItem(plot_item)
             self._plotitem.removeItem(self._max_lines.pop(0))
             self._plotitem.removeItem(self._min_lines.pop(0))
-
-        for ind in range(len(data)):
-            self._plot_items.append(pyqtgraph.PlotDataItem(pen=PLOT_COLORS[ind]))
-            self._plotitem.addItem(self._plot_items[-1])
-            self.legend.addItem(self._plot_items[-1], data.labels[ind])
-            max_line = pyqtgraph.InfiniteLine(angle=0, pen=pyqtgraph.mkPen(color=PLOT_COLORS[ind], style=Qt.DashLine))
-            min_line = pyqtgraph.InfiniteLine(angle=0, pen=pyqtgraph.mkPen(color=PLOT_COLORS[ind], style=Qt.DashLine))
-            self._max_lines.append(max_line)
-            self._min_lines.append(min_line)
-            max_line.setVisible(self._show_lines)
-            min_line.setVisible(self._show_lines)
-            self._plotitem.addItem(self._max_lines[-1])
-            self._plotitem.addItem(self._min_lines[-1])
-
-        self.updated_item.emit(self._plot_items)
-        self.labels_changed.emit(data.labels)
+        if data is not None:
+            for ind in range(len(data)):
+                self._plot_items.append(pyqtgraph.PlotDataItem(pen=self.colors[ind]))
+                self._plotitem.addItem(self._plot_items[-1])
+                self.legend.addItem(self._plot_items[-1], data.labels[ind])
+                max_line = pyqtgraph.InfiniteLine(angle=0,
+                                                  pen=pyqtgraph.mkPen(color=self.colors[ind]['color'],
+                                                                      style=Qt.DashLine))
+                min_line = pyqtgraph.InfiniteLine(angle=0,
+                                                  pen=pyqtgraph.mkPen(color=self.colors[ind]['color'],
+                                                                      style=Qt.DashLine))
+                self._max_lines.append(max_line)
+                self._min_lines.append(min_line)
+                max_line.setVisible(self._show_lines)
+                min_line.setVisible(self._show_lines)
+                self._plotitem.addItem(self._max_lines[-1])
+                self._plotitem.addItem(self._min_lines[-1])
+
+            self.updated_item.emit(self._plot_items)
+            self.labels_changed.emit(data.labels)
 
     def show_min_max(self, show=True):
         self._show_lines = show
@@ -116,11 +134,14 @@ class DataDisplayer(QObject):
 
 
 class View0D(ActionManager, QObject):
-    def __init__(self, parent_widget: QtWidgets.QWidget = None):
+    def __init__(self, parent_widget: QtWidgets.QWidget = None, show_toolbar=True,
+                 no_margins=False):
         QObject.__init__(self)
         ActionManager.__init__(self, toolbar=QtWidgets.QToolBar())
 
+        self.no_margins = no_margins
         self.data_displayer: DataDisplayer = None
+        self.other_data_displayers: Dict[str, DataDisplayer] = {}
         self.plot_widget: PlotWidget = PlotWidget()
         self.values_list = QtWidgets.QListWidget()
 
@@ -136,6 +157,8 @@ class View0D(ActionManager, QObject):
         self._setup_widgets()
         self._connect_things()
         self._prepare_ui()
+        if not show_toolbar:
+            self.splitter.setSizes([0,1])
 
         self.get_action('Nhistory').setValue(200) #default history length
 
@@ -149,11 +172,17 @@ class View0D(ActionManager, QObject):
                         'If triggered, will display horizontal dashed lines for min/max of data', checkable=True)
 
     def _setup_widgets(self):
+        self.splitter = QtWidgets.QSplitter(Qt.Vertical)
         self.parent_widget.setLayout(QtWidgets.QVBoxLayout())
-        self.parent_widget.layout().addWidget(self.toolbar)
+        if self.no_margins:
+            self.parent_widget.layout().setContentsMargins(0, 0, 0, 0)
+
+        self.parent_widget.layout().addWidget(self.splitter)
+        self.splitter.addWidget(self.toolbar)
+        self.splitter.setStretchFactor(0, 0)
 
         splitter_hor = QtWidgets.QSplitter(Qt.Horizontal)
-        self.parent_widget.layout().addWidget(splitter_hor)
+        self.splitter.addWidget(splitter_hor)
 
         splitter_hor.addWidget(self.plot_widget)
         splitter_hor.addWidget(self.values_list)
@@ -179,8 +208,11 @@ class View0D(ActionManager, QObject):
     def plotitem(self):
         return self.plot_widget.plotItem
 
-    def display_data(self, data: data_mod.DataRaw):
-        self.data_displayer.update_data(data)
+    def display_data(self, data: data_mod.DataWithAxes, displayer: str = None, **kwargs):
+        if displayer is None:
+            self.data_displayer.update_data(data)
+        elif displayer in self.other_data_displayers:
+            self.other_data_displayers[displayer].update_data(data)
         if self.is_action_checked('show_data_as_list'):
             self.values_list.clear()
             self.values_list.addItems(['{:.03e}'.format(dat[0]) for dat in data])
@@ -191,6 +223,15 @@ class View0D(ActionManager, QObject):
             state = self.is_action_checked('show_data_as_list')
         self.values_list.setVisible(state)
 
+    def add_data_displayer(self, displayer_name: str, plot_colors=PLOT_COLORS):
+        self.other_data_displayers[displayer_name] = DataDisplayer(self.plotitem, plot_colors)
+        self.connect_action('clear', self.other_data_displayers[displayer_name].clear_data)
+
+    def remove_data_displayer(self, displayer_name: str):
+        displayer = self.other_data_displayers.pop(displayer_name, None)
+        if displayer is not None:
+            displayer.update_display_items()
+
 
 class Viewer0D(ViewerBase):
     """this plots 0D data on a plotwidget with history. Display as numbers in a table is possible.
@@ -198,11 +239,17 @@ class Viewer0D(ViewerBase):
     Datas and measurements are then exported with the signal data_to_export_signal
     """
 
-    def __init__(self, parent=None, title=''):
+    def __init__(self, parent=None, title='', show_toolbar=True, no_margins=False):
         super().__init__(parent, title)
-        self.view = View0D(self.parent)
+        self.view = View0D(self.parent, show_toolbar=show_toolbar, no_margins=no_margins)
         self._labels = []
 
+    def update_colors(self, colors: list, displayer=None):
+        if displayer is None:
+            self.view.data_displayer.update_colors(colors)
+        elif displayer in self.view.other_data_displayers:
+            self.view.other_data_displayers[displayer].update_colors(colors)
+
     @property
     def labels(self):
         return self._labels
@@ -230,7 +277,7 @@ def main_view():
 def main():
     app = QtWidgets.QApplication(sys.argv)
     widget = QtWidgets.QWidget()
-    prog = Viewer0D(widget)
+    prog = Viewer0D(widget, show_toolbar=False)
     from pymodaq.utils.daq_utils import gauss1D
 
     x = np.linspace(0, 200, 201)