pymodaq 4.2.4__py3-none-any.whl → 5.0.0__py3-none-any.whl

pymodaq/utils/plotting/data_viewers/viewer.py

@@ -1,274 +0,0 @@
-from typing import List, Union
-import numpy as np
-
-from qtpy import QtWidgets
-
-from pymodaq.utils.logger import set_logger, get_module_name
-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
-
-config_viewers = {}
-
-logger = set_logger(get_module_name(__file__))
-
-
-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
-
-    Parameters
-    ----------
-    dockarea: DockArea
-    title: str
-    next_to_dock: Dock
-        (deprecated) has no effect
-    direction: str
-        either 'right', 'left', 'bottom', 'top'.
-
-    """
-
-    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 = []
-        self._viewers = []
-
-    @property
-    def viewers(self) -> List[ViewerBase]:
-        return self._viewers
-
-    @property
-    def viewer_docks(self) -> List[Dock]:
-        return self._viewer_docks
-
-    @property
-    def viewer_widgets(self) -> List[QtWidgets.QWidget]:
-        return self._viewer_widgets
-
-    @property
-    def viewer_types(self) -> List[ViewersEnum]:
-        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], self._direction)
-
-    def update_viewers(self, viewers_type: List[Union[str, 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()
-
-    def show_data(self, data: DataToExport, **kwargs):
-        """ Convenience method. Display each dwa in a dedicated data viewer"""
-        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):
-            if len(dwa.axes) != len(dwa.shape):
-                dwa.create_missing_axes()
-            viewer.show_data(dwa)
-
-
-if __name__ == '__main__':
-
-    LABEL = 'A Label'
-    UNITS = 'units'
-    OFFSET = -20.4
-    SCALING = 0.22
-    SIZE = 20
-    DATA = OFFSET + SCALING * np.linspace(0, SIZE - 1, SIZE)
-
-    DATA0D = np.array([2.7])
-    DATA1D = np.arange(0, 10)
-    DATA2D = np.arange(0, 5 * 6).reshape((5, 6))
-    DATAND = np.arange(0, 5 * 6 * 3).reshape((5, 6, 3))
-    Nn0 = 10
-    Nn1 = 5
-
-
-    def init_axis(data=None, index=0):
-        if data is None:
-            data = DATA
-        return Axis(label=LABEL, units=UNITS, data=data, index=index)
-
-
-    def init_data(data=None, Ndata=1, axes=[], name='myData', source=DataSource['raw'],
-                  labels=None) -> DataWithAxes:
-        if data is None:
-            data = DATA2D
-        return DataWithAxes(name, source, data=[data for ind in range(Ndata)],
-                            axes=axes, labels=labels)
-
-
-    def ini_data_to_export():
-        dat1 = init_data(data=DATA2D, Ndata=2, name='data2D')
-        dat2 = init_data(data=DATA1D, Ndata=3, name='data1D')
-        data = DataToExport(name='toexport', data=[dat1, dat2])
-        return dat1, dat2, data
-
-    import sys
-
-    app = QtWidgets.QApplication(sys.argv)
-
-    dockarea = DockArea()
-    prog = ViewerDispatcher(dockarea=dockarea, title='Dispatcher')
-    dockarea.show()
-
-    _, _, dte = ini_data_to_export()
-
-    # 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)
-
-    prog.show_data(dte)
-
-    sys.exit(app.exec_())

pymodaq/utils/plotting/data_viewers/viewer0D.py

@@ -1,298 +0,0 @@
-from typing import List, Union, Dict
-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 = [dict(color=color) for color in 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, 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] = []
-        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')
-
-    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) -> 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
-
-    def clear_data(self):
-        self._data.clear_data()
-        self._mins = []
-        self._maxs = []
-
-    def update_axis(self, history_length: int):
-        self._data.length = history_length
-
-    @property
-    def Ndata(self):
-        return len(self._data.last_data) if self._data.last_data is not None else 0
-
-    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)
-
-            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.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))
-        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
-        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, 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()
-
-        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()
-        if not show_toolbar:
-            self.splitter.setSizes([0,1])
-
-        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.splitter = QtWidgets.QSplitter(Qt.Vertical)
-        self.parent_widget.setLayout(QtWidgets.QVBoxLayout())
-        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.splitter.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.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])
-            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)
-
-    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.
-
-    Datas and measurements are then exported with the signal data_to_export_signal
-    """
-
-    def __init__(self, parent=None, title='', show_toolbar=True, no_margins=False):
-        super().__init__(parent, title)
-        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
-
-    @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, show_toolbar=False)
-    from pymodaq.utils.math_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()