pymodaq 3.6.13__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/utils/plotting/data_viewers/viewer.py

@@ -0,0 +1,393 @@
+from typing import List, Union, TYPE_CHECKING, Iterable
+
+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
+from pymodaq.utils.exceptions import ViewerError
+from pymodaq.utils.enums import BaseEnum, enum_checker
+from pymodaq.utils.factory import ObjectFactory, BuilderBase
+from pymodaq.utils.plotting import data_viewers
+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 = {
+}
+
+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')
+    if Naxes == 0:
+        viewer_enum = ViewersEnum['Viewer0D']
+    elif Naxes == 1:
+        viewer_enum = ViewersEnum['Viewer1D']
+    elif Naxes == 2:
+        viewer_enum = ViewersEnum['Viewer2D']
+    else:
+        viewer_enum = ViewersEnum['ViewerND']
+    return viewer_enum
+
+
+class ViewerFactory(ObjectFactory):
+    def get(self, viewer_name, **kwargs):
+        if viewer_name not in ViewersEnum.names():
+            raise ValueError(f'{viewer_name} is not a valid PyMoDAQ Viewer: {ViewersEnum.names()}')
+        return self.create(viewer_name, **kwargs)
+
+    @property
+    def viewers(self):
+        return self.keys
+
+
+@ViewerFactory.register('Viewer0D')
+def create_viewer0D(parent: QtWidgets.QWidget = None, **_ignored):
+    return data_viewers.viewer0D.Viewer0D(parent)
+
+
+@ViewerFactory.register('Viewer1D')
+def create_viewer1D(parent: QtWidgets.QWidget, **_ignored):
+    return data_viewers.viewer1D.Viewer1D(parent)
+
+
+@ViewerFactory.register('Viewer2D')
+def create_viewer2D(parent: QtWidgets.QWidget, **_ignored):
+    return data_viewers.viewer2D.Viewer2D(parent)
+
+
+@ViewerFactory.register('ViewerND')
+def create_viewerND(parent: QtWidgets.QWidget, **_ignored):
+    return data_viewers.viewerND.ViewerND(parent)
+
+
+# @ViewerFactory.register('ViewerSequential')
+# def create_viewer_sequential(widget: QtWidgets.QWidget, **_ignored):
+#     return data_viewers.viewer_sequential.ViewerSequential(widget)
+
+
+viewer_factory = ViewerFactory()
+
+
+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, title: str = '', next_to_dock: Dock = None):
+        super().__init__()
+        self._title = title
+        self._next_to_dock = next_to_dock
+
+        self.dockarea = dockarea
+
+        self._viewer_docks = []
+        self._viewer_widgets = []
+        self._viewer_types = []
+        self._viewers = []
+
+    @property
+    def viewers(self):
+        return self._viewers
+
+    @property
+    def viewer_docks(self):
+        return self._viewer_docks
+
+    @property
+    def viewer_widgets(self):
+        return self._viewer_widgets
+
+    @property
+    def viewer_types(self):
+        return self._viewer_types
+
+    def remove_viewers(self, Nviewers_to_leave: int = 0):
+        """Remove viewers from the list after index Nviewers_to_leave
+
+        Parameters
+        ----------
+        Nviewers
+
+        Returns
+        -------
+
+        """
+        while len(self.viewer_docks) > Nviewers_to_leave:
+            widget = self.viewer_widgets.pop()
+            widget.close()
+            dock = self.viewer_docks.pop()
+            dock.close()
+            self.viewers.pop()
+            self.viewer_types.pop()
+            QtWidgets.QApplication.processEvents()
+
+    def add_viewer(self, viewer_type: ViewersEnum, dock_viewer=None, dock_name=None):
+        viewer_type = enum_checker(ViewersEnum, viewer_type)
+
+        if dock_viewer is None:
+            if dock_name is None:
+                dock_name = f'{self._title}_Viewer_{len(self.viewer_docks) + 1}'
+            dock_viewer = Dock(dock_name, size=(350, 350), closable=False)
+        self.viewer_docks.append(dock_viewer)
+
+        self._viewer_widgets.append(QtWidgets.QWidget())
+        self.viewers.append(viewer_factory.get(viewer_type.name, parent=self._viewer_widgets[-1]))
+
+        self.viewer_types.append(viewer_type)
+
+        self.viewer_docks[-1].addWidget(self._viewer_widgets[-1])
+        # if len(self.viewer_docks) == 1:
+        #     if self._next_to_dock is not None:
+        #         self.dockarea.addDock(self.viewer_docks[-1], 'right', self._next_to_dock)
+        #     else:
+        #         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')
+
+    def update_viewers(self, viewers_type: List[ViewersEnum], viewers_name: List[str] = None, force=False):
+        """
+
+        Parameters
+        ----------
+        viewers_type: List[ViewersEnum]
+        viewers_name: List[str] or None
+        force: bool
+            if True remove all viewers before update else check if new viewers type are compatible with old ones
+
+        Returns
+        -------
+
+        """
+
+        Nviewers_to_leave = 0
+        if not force:
+            # check if viewers are compatible with new data dim
+            for ind, viewer_type in enumerate(viewers_type):
+                if len(self.viewer_types) > ind:
+                    if viewer_type == self.viewer_types[ind]:
+                        Nviewers_to_leave += 1
+                    else:
+                        break
+                else:
+                    break
+        self.remove_viewers(Nviewers_to_leave)
+        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)
+            ind_loop += 1
+        QtWidgets.QApplication.processEvents()
+
+    def close(self):
+        for dock in self.viewer_docks:
+            dock.close()
+
+
+class ViewerBase(QObject):
+    """Base Class for data viewers implementing all common functionalities
+
+    Parameters
+    ----------
+    parent: QtWidgets.QWidget
+    title: str
+
+    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=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)
+
+
+if __name__ == '__main__':
+    import sys
+    import random
+    app = QtWidgets.QApplication(sys.argv)
+
+    dockarea = DockArea()
+    prog = ViewerDispatcher(dockarea=dockarea, title='Dispatcher')
+    dockarea.show()
+    N = 2
+    viewers = ['Viewer0D', 'Viewer1D', 'Viewer2D']
+    viewers = [ViewersEnum[random.choice(viewers)] for ind in range(N)]
+    viewers = ['Viewer2D', 'Viewer2D', ]
+    print(viewers)
+    prog.update_viewers(viewers)
+
+    sys.exit(app.exec_())

pymodaq/utils/plotting/data_viewers/viewer0D.py

@@ -0,0 +1,251 @@
+from typing import List, Union
+from numbers import Real
+
+from qtpy import QtWidgets, QtGui
+from qtpy.QtCore import QObject, Slot, Signal, Qt
+import sys
+import pyqtgraph
+
+import pymodaq.utils.daq_utils as utils
+from pymodaq.utils import data as data_mod
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase
+from pymodaq.utils.managers.action_manager import ActionManager
+from pymodaq.utils.plotting.widgets import PlotWidget
+from pymodaq.utils.plotting.utils.plot_utils import Data0DWithHistory
+
+import numpy as np
+from collections import OrderedDict
+import datetime
+
+logger = set_logger(get_module_name(__file__))
+PLOT_COLORS = utils.plot_colors
+
+
+class DataDisplayer(QObject):
+    """
+    This Object deals with the display of 0D data  on a plotitem
+    """
+
+    updated_item = Signal(list)
+    labels_changed = Signal(list)
+
+    def __init__(self, plotitem: pyqtgraph.PlotItem):
+        super().__init__()
+        self._plotitem = plotitem
+        self._plotitem.addLegend()
+        self._plot_items: List[pyqtgraph.PlotDataItem] = []
+        self._min_lines: List[pyqtgraph.InfiniteLine] = []
+        self._max_lines: List[pyqtgraph.InfiniteLine] = []
+        self._data = Data0DWithHistory()
+
+        self._mins: List = []
+        self._maxs: List = []
+
+        self._show_lines: bool = False
+
+        axis = self._plotitem.getAxis('bottom')
+        axis.setLabel(text='Samples', units='S')
+
+    @property
+    def legend(self):
+        return self._plotitem.legend
+
+    @property
+    def axis(self):
+        return self._data.xaxis
+
+    def clear_data(self):
+        self._data.clear_data()
+        self._mins = []
+        self._maxs = []
+
+    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)
+
+        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 = []
+
+        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.DataRaw):
+        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)
+
+    def show_min_max(self, show=True):
+        self._show_lines = show
+        for line in self._max_lines:
+            line.setVisible(show)
+        for line in self._min_lines:
+            line.setVisible(show)
+
+
+class View0D(ActionManager, QObject):
+    def __init__(self, parent_widget: QtWidgets.QWidget = None):
+        QObject.__init__(self)
+        ActionManager.__init__(self, toolbar=QtWidgets.QToolBar())
+
+        self.data_displayer: DataDisplayer = None
+        self.plot_widget: PlotWidget = PlotWidget()
+        self.values_list = QtWidgets.QListWidget()
+
+        self.setup_actions()
+
+        self.parent_widget = parent_widget
+        if self.parent_widget is None:
+            self.parent_widget = QtWidgets.QWidget()
+            self.parent_widget.show()
+
+        self.data_displayer = DataDisplayer(self.plotitem)
+
+        self._setup_widgets()
+        self._connect_things()
+        self._prepare_ui()
+
+        self.get_action('Nhistory').setValue(200) #default history length
+
+    def setup_actions(self):
+        self.add_action('clear', 'Clear plot', 'clear2', 'Clear the current plots')
+        self.add_widget('Nhistory', pyqtgraph.SpinBox, tip='Set the history length of the plot',
+                        setters=dict(setMaximumWidth=100))
+        self.add_action('show_data_as_list', 'Show numbers', 'ChnNum', 'If triggered, will display last data as numbers'
+                                                                       'in a side panel', checkable=True)
+        self.add_action('show_min_max', 'Show Min/Max lines', 'Statistics',
+                        'If triggered, will display horizontal dashed lines for min/max of data', checkable=True)
+
+    def _setup_widgets(self):
+        self.parent_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.parent_widget.layout().addWidget(self.toolbar)
+
+        splitter_hor = QtWidgets.QSplitter(Qt.Horizontal)
+        self.parent_widget.layout().addWidget(splitter_hor)
+
+        splitter_hor.addWidget(self.plot_widget)
+        splitter_hor.addWidget(self.values_list)
+
+        font = QtGui.QFont()
+        font.setPointSize(20)
+        self.values_list.setFont(font)
+
+    def _connect_things(self):
+        self.connect_action('clear', self.data_displayer.clear_data)
+        self.connect_action('show_data_as_list', self.show_data_list)
+        self.connect_action('Nhistory', self.data_displayer.update_axis, signal_name='valueChanged')
+        self.connect_action('show_min_max', self.data_displayer.show_min_max)
+
+    def _prepare_ui(self):
+        """add here everything needed at startup"""
+        self.values_list.setVisible(False)
+
+    def get_double_clicked(self):
+        return self.plot_widget.view.sig_double_clicked
+
+    @property
+    def plotitem(self):
+        return self.plot_widget.plotItem
+
+    def display_data(self, data: data_mod.DataRaw):
+        self.data_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])
+            QtWidgets.QApplication.processEvents()
+
+    def show_data_list(self, state=None):
+        if state is None:
+            state = self.is_action_checked('show_data_as_list')
+        self.values_list.setVisible(state)
+
+
+class Viewer0D(ViewerBase):
+    """this plots 0D data on a plotwidget with history. Display as numbers in a table is possible.
+
+    Datas and measurements are then exported with the signal data_to_export_signal
+    """
+
+    def __init__(self, parent=None, title=''):
+        super().__init__(parent, title)
+        self.view = View0D(self.parent)
+        self._labels = []
+
+    @property
+    def labels(self):
+        return self._labels
+
+    @labels.setter
+    def labels(self, labels):
+        if labels != self._labels:
+            self._labels = labels
+
+    @Slot(list)
+    def _show_data(self, data: data_mod.DataRaw):
+        self.labels = data.labels
+        self.view.display_data(data)
+        self.data_to_export_signal.emit(self.data_to_export)
+
+
+def main_view():
+    app = QtWidgets.QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+    prog = View0D(widget)
+    widget.show()
+    sys.exit(app.exec_())
+
+
+def main():
+    app = QtWidgets.QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+    prog = Viewer0D(widget)
+    from pymodaq.utils.daq_utils import gauss1D
+
+    x = np.linspace(0, 200, 201)
+    y1 = gauss1D(x, 75, 25) + 0.1*np.random.rand(len(x))
+    y2 = 0.7 * gauss1D(x, 120, 50, 2) + 0.2*np.random.rand(len(x))
+    widget.show()
+    prog.get_action('show_data_as_list').trigger()
+    for ind, data in enumerate(y1):
+        prog.show_data(data_mod.DataRaw('mydata', data=[np.array([data]), np.array([y2[ind]])],
+                                        labels=['lab1', 'lab2']))
+        QtWidgets.QApplication.processEvents()
+
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':  # pragma: no cover
+    #main_view()
+    main()