pymodaq 4.1.5__py3-none-any.whl → 4.2.1__py3-none-any.whl

pymodaq/utils/plotting/data_viewers/viewerND.py

@@ -178,21 +178,21 @@ class UniformDataDisplayer(BaseDataDisplayer):
             )
         if len(sig_axis_limits) == 1:
             self._viewer1D.roi.setPos((float(np.mean(sig_axis_limits[0]) -
-                                             np.abs(np.diff(sig_axis_limits[0])) / 3),
+                                             np.abs(np.diff(sig_axis_limits[0]))[0] / 3),
                                        float(np.mean(sig_axis_limits[0]) +
-                                             np.abs(np.diff(sig_axis_limits[0])) / 3))
+                                             np.abs(np.diff(sig_axis_limits[0]))[0] / 3))
                                       )
         if len(sig_axis_limits) == 2:
             scaled_axes = np.array(self._viewer2D.view.unscale_axis(np.array(sig_axis_limits[1]),
                                                                     np.array(sig_axis_limits[0])))
 
             self._viewer2D.roi.setSize(
-                float(np.diff(scaled_axes[0])) / 3,
-                float(np.diff(scaled_axes[1])) / 3)
+                float(np.diff(scaled_axes[0])[0]) / 3,
+                float(np.diff(scaled_axes[1])[0]) / 3)
 
             self._viewer2D.roi.setPos(
-                float(np.mean(scaled_axes[0])) - float(np.diff(scaled_axes[0])) / 6,
-                float(np.mean(scaled_axes[1])) - float(np.diff(scaled_axes[1])) / 6)
+                float(np.mean(scaled_axes[0])) - float(np.diff(scaled_axes[0])[0]) / 6,
+                float(np.mean(scaled_axes[1])) - float(np.diff(scaled_axes[1])[0]) / 6)
 
     def updated_nav_integration(self):
         """ Means the ROI select of the 2D viewer has been moved """
@@ -286,7 +286,7 @@ class UniformDataDisplayer(BaseDataDisplayer):
         try:
             navigator_data = None
             if len(data.axes_manager.sig_shape) == 0:  # signal data is 0D
-                navigator_data = data
+                navigator_data = data.deepcopy()
 
             elif len(data.axes_manager.sig_shape) == 1:  # signal data is 1D
                 indx, indy = data.get_axis_from_index(data.sig_indexes[0])[0].find_indexes((x, y))
@@ -660,25 +660,29 @@ class ViewerND(ParameterManager, ActionManager, ViewerBase):
                                   axes=[Axis(data=z, index=0, label='z_axis', units='zunits')])
         self._show_data(dataraw, force_update=True)
 
-    def update_widget_visibility(self, data: DataRaw = None):
+    def update_widget_visibility(self, data: DataRaw = None,
+                                 nav_indexes:Tuple[int] = None):
         if data is None:
             data = self._data
-        self.viewer0D.setVisible(len(data.shape) - len(data.nav_indexes) == 0)
-        self.viewer1D.setVisible(len(data.shape) - len(data.nav_indexes) == 1)
-        self.viewer2D.setVisible(len(data.shape) - len(data.nav_indexes) == 2)
-        self.viewer1D.roi.setVisible(len(data.nav_indexes) != 0)
-        self.viewer2D.roi.setVisible(len(data.nav_indexes) != 0)
-        self._dock_navigation.setVisible(len(data.nav_indexes) != 0)
-        nav_axes = data.get_nav_axes()
+        if nav_indexes is None:
+            nav_indexes = data.nav_indexes
+        self.viewer0D.setVisible(len(data.shape) - len(nav_indexes) == 0)
+        self.viewer1D.setVisible(len(data.shape) - len(nav_indexes) == 1)
+        self.viewer2D.setVisible(len(data.shape) - len(nav_indexes) == 2)
+        self.viewer1D.roi.setVisible(len(nav_indexes) != 0)
+        self.viewer2D.roi.setVisible(len(nav_indexes) != 0)
+        self._dock_navigation.setVisible(len(nav_indexes) != 0)
+        #nav_axes = data.get_nav_axes()
 
         if data.distribution.name == 'uniform':
-            self.navigator1D.setVisible(len(nav_axes) == 1)
-            self.navigator2D.setVisible(len(nav_axes) == 2)
-            self.axes_viewer.setVisible(len(data.nav_indexes) > 2)
+            self.navigator1D.setVisible(len(nav_indexes) == 1)
+            self.navigator2D.setVisible(len(nav_indexes) == 2)
+            self.axes_viewer.setVisible(len(nav_indexes) > 2)
         else:
-            self.navigator2D.setVisible(len(nav_axes) == 2 and self.data_displayer.triangulation)
-            self.navigator1D.setVisible(len(nav_axes) == 1 or len(nav_axes) > 2 or
-                                        len(nav_axes) == 2 and not self.data_displayer.triangulation)
+            self.navigator2D.setVisible(len(nav_indexes) == 2 and self.data_displayer.triangulation)
+            self.navigator1D.setVisible(len(nav_indexes) == 1 or len(nav_indexes) > 2 or
+                                        len(nav_indexes) == 2 and
+                                        not self.data_displayer.triangulation)
 
     def update_filters(self, processor: DataProcessorFactory):
         self.get_action('filters').clear()
@@ -705,7 +709,7 @@ class ViewerND(ParameterManager, ActionManager, ViewerBase):
     def reshape_data(self):
         _nav_indexes = [int(index) for index in
                         self.settings.child('data_shape_settings', 'navigator_axes').value()['selected']]
-        self.update_widget_visibility()
+        self.update_widget_visibility(nav_indexes=_nav_indexes)
         self.data_displayer.update_nav_indexes(_nav_indexes)
 
     def connect_things(self):

pymodaq/utils/plotting/items/crosshair.py

@@ -10,7 +10,7 @@ class Crosshair(pg.GraphicsObject):
     crosshair_dragged = Signal(float, float, name='crosshair_dragged')
     # signal used to pass crosshair position to other methods
 
-    def __init__(self, plotitem, orientation='both'):
+    def __init__(self, plotitem, orientation='both', pen=None):
         super().__init__()
         
         if hasattr(plotitem, 'plotitem'):
@@ -30,8 +30,8 @@ class Crosshair(pg.GraphicsObject):
             self.vline_visible = False
             self.hline_visible = True
 
-        self.vLine = pg.InfiniteLine(angle=90, movable=True)
-        self.hLine = pg.InfiniteLine(angle=0, movable=True)
+        self.vLine = pg.InfiniteLine(angle=90, movable=True, pen=pen)
+        self.hLine = pg.InfiniteLine(angle=0, movable=True, pen=pen)
 
         self.plotitem.addItem(self.vLine, ignoreBounds=True)
         self.plotitem.addItem(self.hLine, ignoreBounds=True)

pymodaq/utils/plotting/items/image.py

@@ -8,12 +8,13 @@ from qtpy import QtCore, QtGui
 
 
 class PymodaqImage(pg.ImageItem):
-    def __init__(self, image=None, **kargs):
+    def __init__(self, image=None, pen='r', **kargs):
         super().__init__(image, **kargs)
         self.flipud = False
         self.fliplr = False
         self.rotate90 = False
         self.rescale = None
+        self.opts = {'pen': pen}
 
     def get_val_at(self, xy):
         """

pymodaq/utils/plotting/plotter/plotter.py

@@ -0,0 +1,94 @@
+# Standard imports
+import typing
+from abc import ABCMeta, abstractmethod
+from importlib import import_module
+from pathlib import Path
+from typing import Callable, List, Union
+
+# 3rd party imports
+import numpy as np
+
+# project imports
+from pymodaq.utils.abstract import abstract_attribute
+from pymodaq.utils.logger import set_logger, get_module_name
+
+from pymodaq.utils.factory import ObjectFactory
+
+if typing.TYPE_CHECKING:
+    from pymodaq.utils.data import DataWithAxes, DataDim
+    from pymodaq.utils.plotting.data_viewers import Viewer0D, Viewer1D, Viewer2D, ViewerND
+
+logger = set_logger(get_module_name(__file__))
+
+
+def register_plotter(parent_module_name: str = 'pymodaq.utils.plotting.plotter'):
+    plotters = []
+    try:
+        plotter_module = import_module(f'{parent_module_name}.plotters')
+
+        plotter_path = Path(plotter_module.__path__[0])
+
+        for file in plotter_path.iterdir():
+            if file.is_file() and 'py' in file.suffix and file.stem != '__init__':
+                try:
+                    plotters.append(import_module(f'.{file.stem}', plotter_module.__name__))
+                except ModuleNotFoundError:
+                    pass
+    except ModuleNotFoundError:
+        pass
+    finally:
+        return plotters
+
+
+class PlotterBase(metaclass=ABCMeta):
+    """Base class for a plotter. """
+
+    backend: str = abstract_attribute()
+    def __init__(self):
+        """Abstract Exporter Constructor"""
+        pass
+
+    @abstractmethod
+    def plot(self, data, *args, **kwargs) -> None:
+        """Abstract method to plot data object with a given backend"""
+        pass
+
+
+class PlotterFactory(ObjectFactory):
+    """Factory class registering and storing interactive plotter"""
+
+    @classmethod
+    def register(cls) -> Callable:
+        """ To be used as a decorator
+
+        Register in the class registry a new plotter class using its 2 identifiers: backend and
+        data_dim
+        """
+        def inner_wrapper(wrapped_class: PlotterBase) -> Callable:
+            if cls.__name__ not in cls._builders:
+                cls._builders[cls.__name__] = {}
+            key = wrapped_class.backend
+
+            if key not in cls._builders[cls.__name__]:
+                cls._builders[cls.__name__][key] = wrapped_class
+            else:
+                logger.warning(f'The {cls.__name__}/{key} builder is already registered.'
+                               f' Replacing it')
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def create(cls, key, **kwargs) -> PlotterBase:
+        builder = cls._builders[cls.__name__].get(key)
+        if not builder:
+            raise ValueError(key)
+        return builder(**kwargs)
+
+    def get(self, backend: str, **kwargs):
+        return self.create(backend, **kwargs)
+
+    def backends(self) -> List[str]:
+        """Returns the list of plotter backends, main identifier of a given plotter"""
+        return sorted(list(self.builders[self.__class__.__name__].keys()))
+

pymodaq/utils/plotting/plotter/plotters/matplotlib_plotters.py

@@ -0,0 +1,134 @@
+from typing import List, Tuple, Any, TYPE_CHECKING, Union
+import sys
+import datetime
+
+import numpy as np
+from qtpy import QtWidgets
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils import config as configmod
+from pymodaq.utils.data import DataDim, DataWithAxes, DataToExport
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.plotting.plotter.plotter import PlotterBase, PlotterFactory
+
+from matplotlib import pyplot as plt
+
+if TYPE_CHECKING:
+    pass
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+PLOT_COLORS = utils.plot_colors.copy()
+PLOT_COLORS.remove((255, 255, 255))  # remove white color as plotted on white background
+PLOT_COLORS = [(np.array(color) / 255).tolist() for color in PLOT_COLORS]  # translation to matplotlib
+
+
+@PlotterFactory.register()
+class Plotter(PlotterBase):
+    backend = 'matplotlib'
+
+    def __init__(self, **_ignored):
+        super().__init__()
+        self.n_lines = 1
+        self.n_columns = 1
+        self.ind_line = 0
+        self.ind_column = 0
+
+    def plot(self, data: Union[DataWithAxes, DataToExport], *args, viewer=None,
+             **kwargs) -> plt.Figure:
+        fig = plt.figure()
+
+        if isinstance(data, DataWithAxes):
+            self.n_columns = len(data) if data.dim.name == 'Data2D' else 1
+            self.plot_dwa(data, *args, **kwargs)
+        elif isinstance(data, DataToExport):
+            self.n_columns = max([len(dwa) if dwa.dim.name == 'Data2D' else 1 for dwa in data])
+            self.n_lines = len(data)
+            self.plot_dte(data, *args, **kwargs)
+        plt.tight_layout()
+        fig.suptitle(f'{data.name} taken the {datetime.datetime.fromtimestamp(data.timestamp)}')
+        return fig
+
+    def plot_dwa(self, dwa: DataWithAxes, *args, **kwargs):
+        if dwa.dim.name == 'Data1D':
+            if len(dwa.axes) == 0:
+                dwa.create_missing_axes()
+            self.ind_column = 0
+            self.plot1D(dwa, *args, **kwargs)
+        elif dwa.dim.name == 'Data2D':
+            if len(dwa.axes) < 2:
+                dwa.create_missing_axes()
+            self.plot2D(dwa, *args, **kwargs)
+
+    def plot_dte(self, dte: DataToExport, *args, **kwargs):
+        for ind in range(len(dte)):
+            self.ind_line = ind
+            self.plot_dwa(dte[ind], *args, **kwargs)
+
+    def plot1D(self, dwa: DataWithAxes, *args, **kwargs):
+        plt.subplot(self.n_lines, self.n_columns,
+                    (self.n_columns * self.ind_line) + 1)
+        for ind_data, data_array in enumerate(dwa):
+            plt.plot(dwa.axes[0].get_data(), data_array, *args,  color=PLOT_COLORS[ind_data],
+                     **kwargs)
+            if dwa.errors is not None:
+                plt.fill_between(dwa.axes[0].get_data(), data_array - dwa.get_error(ind_data),
+                                 data_array + dwa.get_error(ind_data), *args,
+                                 color=PLOT_COLORS[ind_data] + [0.3], **kwargs)
+        plt.legend(dwa.labels)
+        #plt.title(f'{dwa.name}')
+        plt.xlabel(f'{dwa.axes[0].label} ({dwa.axes[0].units})')
+        plt.ylabel(dwa.name)
+
+    def plot2D(self, dwa: DataWithAxes, *args, **kwargs):
+        xaxis = dwa.get_axis_from_index(1)[0]
+        yaxis = dwa.get_axis_from_index(0)[0]
+
+        x = xaxis.get_data()
+        y = yaxis.get_data()
+        for ind_plot, dwa_array in enumerate(dwa):
+            self.ind_column = ind_plot
+            plt.subplot(self.n_lines, self.n_columns,
+                        (self.n_columns * self.ind_line) + ind_plot + 1)
+            X, Y = np.meshgrid(x, y)
+            plt.pcolormesh(X, Y, dwa_array, *args, **kwargs)
+            plt.title(f'{dwa.name}/{dwa.labels[ind_plot]}')
+            plt.xlabel(f'{xaxis.label} ({xaxis.units})')
+            plt.ylabel(f'{yaxis.label} ({yaxis.units})')
+
+
+# if __name__ == '__main__':
+#     from pymodaq.utils import data as data_mod
+#     import numpy as np
+#     from pymodaq.utils.math_utils import gauss1D, gauss2D
+#     from pymodaq.utils.plotting.plotter.plotter import PlotterFactory
+#     plotter_factory = PlotterFactory()
+#
+#     x = np.linspace(0, 100, 101)
+#     y = np.linspace(0, 100, 101)
+#     y1 = gauss2D(x, 50, 20, y, 40, 7)
+#
+#
+#     QtWidgets.QApplication.processEvents()
+#     dwa = data_mod.DataRaw('mydata', data=[y1, y1, y1],
+#                            axes=[data_mod.Axis('xaxis', 'x units', data=x, index=0,
+#                                                 spread_order=0),
+#                                   data_mod.Axis('yaxis', 'y units', data=y, index=1,
+#                                                 spread_order=0)
+#                                   ],
+#                            labels=['MAG', 'PHASE'],
+#                            nav_indexes=())
+#     dte = dwa.as_dte('mydte')
+#     dwa_mean = dwa.mean()
+#     dwa_mean.name = 'mean'
+#     dwa_mean_2 = dwa.mean(1)
+#     dwa_mean_2.name = 'mean2'
+#     dte.append(dwa_mean)
+#     dte.append(dwa_mean_2)
+#
+#     fig = dwa.plot('matplotlib')
+#     fig.savefig('myplot.png')
+#
+#     fig2 = dte.plot('matplotlib')
+#     fig2.savefig('mydte.png')

pymodaq/utils/plotting/plotter/plotters/qt_plotters.py

@@ -0,0 +1,78 @@
+from typing import List, Tuple, Any, TYPE_CHECKING, Union
+import sys
+
+from qtpy import QtWidgets
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils import config as configmod
+from pymodaq.utils.gui_utils.utils import start_qapplication
+from pymodaq.utils.plotting.plotter.plotter import PlotterBase, PlotterFactory
+from pymodaq.utils.data import DataWithAxes, DataToExport
+from pymodaq.utils.plotting.data_viewers import (Viewer1D, Viewer2D, ViewerND, ViewerDispatcher,
+                                                 Viewer0D, ViewersEnum)
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase, viewer_factory
+from pymodaq.utils.gui_utils.dock import DockArea
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+@PlotterFactory.register()
+class Plotter(PlotterBase):
+    backend = 'qt'
+
+    def __init__(self, **_ignored):
+        super().__init__()
+
+    def plot(self, data: Union[DataWithAxes, DataToExport], viewer=None, **kwargs) -> ViewerBase:
+        do_exit = False
+        qapp = QtWidgets.QApplication.instance()
+        if qapp is None:
+            do_exit = True
+            qapp = start_qapplication()
+
+        if viewer is None:
+            if isinstance(data, DataToExport):
+                widget = DockArea()
+                viewer = ViewerDispatcher(widget, title=data.name)
+            else:
+                widget = QtWidgets.QWidget()
+                viewer_enum = ViewersEnum.get_viewers_enum_from_data(data)
+                viewer = viewer_factory.get(viewer_enum.name, parent=widget)
+            widget.show()
+
+        if viewer is not None:
+            viewer.show_data(data, **kwargs)
+            if isinstance(viewer, Viewer1D):
+                if not viewer.is_action_checked('errors'):
+                    viewer.get_action('errors').trigger()
+            QtWidgets.QApplication.processEvents()
+
+        if do_exit:
+            sys.exit(qapp.exec())
+        return viewer
+
+
+if __name__ == '__main__':
+    from pymodaq.utils import data as data_mod
+    import numpy as np
+    from pymodaq.utils.math_utils import gauss1D
+    from pymodaq.utils.plotting.plotter.plotter import PlotterFactory
+
+    qapp = start_qapplication()
+
+    plotter_factory = PlotterFactory()
+
+    x = np.random.randint(201, size=201)
+    y1 = gauss1D(x, 75, 25)
+    y2 = gauss1D(x, 120, 50, 2)
+
+    QtWidgets.QApplication.processEvents()
+    dwa = data_mod.DataRaw('mydata', data=[y1, y2],
+                            axes=[data_mod.Axis('myaxis', 'units', data=x, index=0,
+                                                spread_order=0)],
+                            nav_indexes=())
+
+    dwa.plot('qt')
+    dwa.as_dte('mydte').plot('qt')
+    sys.exit(qapp.exec())

pymodaq/utils/plotting/utils/axes_viewer.py

@@ -44,7 +44,7 @@ class AxesViewer(QtCore.QObject):
 
         for ind in range(len(axes)):
             self.nav_axes_viewers[ind].roi_line_signal.connect(self._emit_nav_signal)
-            self.nav_axes_viewers[ind].show_data([axes[ind].data])
+            self.nav_axes_viewers[ind].show_data([axes[ind].get_data()])
             self.nav_axes_viewers[ind].set_axis_label(dict(orientation='bottom',
                                                            label='Scan index',
                                                            units=''))