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

pymodaq/utils/managers/roi_manager.py

@@ -1,6 +1,7 @@
+from abc import abstractmethod
 import os
 import sys
-from typing import List, TYPE_CHECKING
+from typing import List, TYPE_CHECKING, Tuple
 import pymodaq.utils
 from qtpy import QtCore, QtGui, QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal, QPointF
@@ -83,10 +84,25 @@ class ROIPositionMapper(QtWidgets.QWidget):
 
 
 class ROI(pgROI):
-    def __init__(self, *args, **kwargs):
+    index_signal = Signal(int)
+
+    def __init__(self, *args, index=0, name='roi', **kwargs):
         super().__init__(*args, **kwargs)
+        self.name = name
+        self.index = index
         self._menu = QtWidgets.QMenu()
         self._menu.addAction('Set ROI positions', self.set_positions)
+        self.sigRegionChangeFinished.connect(self.emit_index_signal)
+
+    def emit_index_signal(self):
+        self.index_signal.emit(self.index)
+
+    @property
+    def color(self):
+        return self.pen.color()
+
+    def center(self):
+        return QPointF(self.pos().x() + self.size().x() / 2, self.pos().y() + self.size().y() / 2)
 
     def set_positions(self):
         mapper = ROIPositionMapper(self.pos(), self.size())
@@ -100,6 +116,12 @@ class ROI(pgROI):
         if self._menu is not None:
             self._menu.exec(event.screenPos())
 
+    def width(self) -> float:
+        return self.size().x()
+
+    def height(self) -> float:
+        return self.size().y()
+
 
 class ROIBrushable(ROI):
     def __init__(self, brush=None, *args, **kwargs):
@@ -133,20 +155,29 @@ class ROIBrushable(ROI):
 class LinearROI(pgLinearROI):
     index_signal = Signal(int)
 
-    def __init__(self, index=0, pos=[0, 10], **kwargs):
+    def __init__(self, index=0, pos=[0, 10], name = 'roi', **kwargs):
         super().__init__(values=pos, **kwargs)
+        self.name = name
         self.index = index
         self.sigRegionChangeFinished.connect(self.emit_index_signal)
 
-    def pos(self):
+    def pos(self) -> Tuple[float, float]:
         return self.getRegion()
 
-    def setPos(self, pos):
+    def center(self) -> float:
+        pos = self.pos()
+        return (pos[0] + pos[1]) / 2
+
+    def setPos(self, pos: Tuple[int, int]):
         self.setRegion(pos)
 
     def setPen(self, color):
         self.setBrush(color)
 
+    @property
+    def color(self):
+        return self.brush.color()
+
     def emit_index_signal(self):
         self.index_signal.emit(self.index)
 
@@ -164,23 +195,13 @@ class EllipseROI(ROI):
     ============== =============================================================
 
     """
-    index_signal = Signal(int)
+
 
     def __init__(self, index=0, pos=[0, 0], size=[10, 10], **kwargs):
         # QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1])
-        super().__init__(pos=pos, size=size, **kwargs)
+        super().__init__(pos=pos, size=size, index=index, **kwargs)
         self.addRotateHandle([1.0, 0.5], [0.5, 0.5])
         self.addScaleHandle([0.5 * 2. ** -0.5 + 0.5, 0.5 * 2. ** -0.5 + 0.5], [0.5, 0.5])
-        self.index = index
-        self.sigRegionChangeFinished.connect(self.emit_index_signal)
-
-    def center(self):       
-        # Project width/height in rotated frame         
-        width,height = rotate2D((0,0),(self.size().x(),self.size().y()),np.deg2rad(self.angle()))
-        return QPointF(self.pos().x() + width / 2, self.pos().y() + height / 2)
-
-    def emit_index_signal(self):
-        self.index_signal.emit(self.index)
 
     def getArrayRegion(self, arr, img=None, axes=(0, 1), **kwds):
         """
@@ -211,9 +232,6 @@ class EllipseROI(ROI):
         else:
             return arr * mask
 
-    def height(self):
-        return self.size().y()
-
     def paint(self, p, opt, widget):
         r = self.boundingRect()
         p.setRenderHint(QtGui.QPainter.Antialiasing)
@@ -229,9 +247,6 @@ class EllipseROI(ROI):
         self.path.addEllipse(self.boundingRect())
         return self.path
 
-    def width(self):
-        return self.size().x()
-
 
 class SimpleRectROI(ROI):
     r"""
@@ -252,22 +267,10 @@ class SimpleRectROI(ROI):
 
 
 class RectROI(ROI):
-    index_signal = Signal(int)
-
-    def __init__(self, index=0, pos=[0, 0], size=[10, 10]):
-        super().__init__(pos=pos, size=size)  # , scaleSnap=True, translateSnap=True)
+    def __init__(self, index=0, pos=[0, 0], size=[10, 10], **kwargs):
+        super().__init__(pos=pos, size=size, index=index, **kwargs)  # , scaleSnap=True, translateSnap=True)
         self.addScaleHandle([1, 1], [0, 0])
         self.addRotateHandle([0, 0], [0.5, 0.5])
-        self.index = index
-        self.sigRegionChangeFinished.connect(self.emit_index_signal)
-
-    def center(self):       
-        # Project width/height in rotated frame         
-        width,height = rotate2D((0,0),(self.size().x(),self.size().y()),np.deg2rad(self.angle()))
-        return QPointF(self.pos().x() + width / 2, self.pos().y() + height / 2)
-
-    def emit_index_signal(self):
-        self.index_signal.emit(self.index)
 
 
 ROI_NAME_PREFIX = 'ROI_'
@@ -298,7 +301,7 @@ class ROIScalableGroup(GroupParameter):
         if self.roi_type == '2D':
             children.extend([{'title': 'ROI Type', 'name': 'roi_type', 'type': 'str', 'value': typ, 'readonly': True},
                              {'title': 'Use channel', 'name': 'use_channel', 'type': 'list',
-                              'limits': ['red', 'green', 'blue', 'spread']}, ])
+                              'limits': ['red', 'green', 'blue']}, ])
             children.append({'title': 'Math type:', 'name': 'math_function', 'type': 'list',
                              'limits': data_processors.functions_filtered('Data2D')})
         else:
@@ -332,15 +335,13 @@ class ROIScalableGroup(GroupParameter):
 
 
 class ROIManager(QObject):
-    ROI_changed = Signal()
-    ROI_changed_finished = Signal()
 
-    new_ROI_signal = Signal(int, str)
+    new_ROI_signal = Signal(int, str, str)
     remove_ROI_signal = Signal(str)
     roi_value_changed = Signal(str, tuple)
-
+    color_signal = Signal(list)
     roi_update_children = Signal(list)
-
+    roi_changed = Signal()
     color_list = np.array(plot_colors)
 
     def __init__(self, viewer_widget=None, ROI_type='1D'):
@@ -348,7 +349,7 @@ class ROIManager(QObject):
         self.ROI_type = ROI_type
         self.roiwidget = QtWidgets.QWidget()
         self.viewer_widget = viewer_widget  # either a PlotWidget or a ImageWidget
-        self._ROIs = OrderedDict([])
+        self._ROIs: OrderedDict[str, ROI] = OrderedDict([])
         self.setupUI()
 
     @staticmethod
@@ -374,6 +375,9 @@ class ROIManager(QObject):
         else:
             raise KeyError(f'{roi_key} is not a valid ROI identifier for {self.ROIs}')
 
+    def emit_colors(self):
+        self.color_signal.emit([self._ROIs[roi_key].color for roi_key in self._ROIs])
+
     def add_roi_programmatically(self, roitype=ROI2D_TYPES[0]):
         self.settings.child('ROIs').addNew(roitype)
 
@@ -420,15 +424,16 @@ class ROIManager(QObject):
             else:
                 childName = param.name()
             if change == 'childAdded':  # new roi to create
-                par = data[0]
+                par: Parameter = data[0]
                 newindex = int(par.name()[-2:])
-
+                roi_type = ''
                 if par.child('type').value() == '1D':
                     roi_type = ''
 
                     pos = self.viewer_widget.plotItem.vb.viewRange()[0]
                     pos = pos[0] + np.diff(pos)*np.array([2,4])/6
                     newroi = LinearROI(index=newindex, pos=pos)
+
                     newroi.setZValue(-10)
                     newroi.setBrush(par.child('Color').value())
                     newroi.setOpacity(0.2)
@@ -443,14 +448,13 @@ class ROIManager(QObject):
 
                     if roi_type == 'RectROI':
                         newroi = RectROI(index=newindex, pos=pos,
-                                         size=[width, height])
+                                         size=[width, height], name=par.name())
                     else:
                         newroi = EllipseROI(index=newindex, pos=pos,
-                                            size=[width, height])
+                                            size=[width, height], name=par.name())
                     newroi.setPen(par['Color'])
 
-                newroi.sigRegionChanged.connect(lambda: self.ROI_changed.emit())
-                newroi.sigRegionChangeFinished.connect(lambda: self.ROI_changed_finished.emit())
+                newroi.sigRegionChangeFinished.connect(lambda: self.roi_changed.emit())
                 newroi.index_signal[int].connect(self.update_roi_tree)
                 try:
                     self.settings.sigTreeStateChanged.disconnect()
@@ -461,27 +465,31 @@ class ROIManager(QObject):
 
                 self._set_roi_from_index(newindex, newroi)
 
-                self.new_ROI_signal.emit(newindex, roi_type)
+                self.new_ROI_signal.emit(newindex, roi_type, par.name())
                 self.update_roi_tree(newindex)
+                self.emit_colors()
+                self.roi_changed.emit()
 
             elif change == 'value':
                 if param.name() in putils.iter_children(self.settings.child('ROIs'), []):
                     parent_name = putils.get_param_path(param)[putils.get_param_path(param).index('ROIs')+1]
                     self.update_roi(parent_name, param)
                     self.roi_value_changed.emit(parent_name, (param, param.value()))
+                if param.name() == 'Color':
+                    self.emit_colors()
 
             elif change == 'parent':
                 if 'ROI' in param.name():
                     roi = self._ROIs.pop(param.name())
                     self.viewer_widget.plotItem.removeItem(roi)
                     self.remove_ROI_signal.emit(param.name())
-
-        self.ROI_changed_finished.emit()
+                    self.emit_colors()
 
     def update_use_channel(self, channels: List[str]):
+        channels.append('All')
         for ind in range(len(self)):
             val = self.settings['ROIs', self.roi_format(ind), 'use_channel']
-            self.settings.child('ROIs', self.roi_format(ind), 'use_channel').setOpts(limits=channels)
+            self.settings.child('ROIs', self.roi_format(ind), 'use_channel').setLimits(channels)
             if val not in channels:
                 self.settings.child('ROIs', self.roi_format(ind), 'use_channel').setValue(channels[0])
 
@@ -489,6 +497,7 @@ class ROIManager(QObject):
         self._ROIs[roi_key].index_signal[int].disconnect()
         if param.name() == 'Color':
             self._ROIs[roi_key].setPen(param.value())
+            self.emit_colors()
         elif param.name() == 'left' or param.name() == 'x':
             pos = self._ROIs[roi_key].pos()
             poss = [param.value(), pos[1]]

pymodaq/utils/math_utils.py

@@ -105,7 +105,7 @@ def linspace_step(start, stop, step):
     scalar array
         The computed distribution axis as an array.
     """
-    if np.abs(step) < 1e-12 or np.sign(stop - start) != np.sign(step) or start == stop:
+    if np.sign(stop - start) != np.sign(step) or start == stop:
         raise ValueError('Invalid value for one parameter')
     Nsteps = int(np.ceil((stop - start) / step))
     new_stop = start + (Nsteps - 1) * step

pymodaq/utils/plotting/data_viewers/__init__.py

@@ -1,8 +1,10 @@
+from .base import ViewersEnum
+
 from .viewer0D import Viewer0D
 from .viewer1D import Viewer1D
 from .viewer2D import Viewer2D
 from .viewerND import ViewerND
 from .viewer import ViewerDispatcher
-from .viewer import ViewersEnum
+
 
 DATA_TYPES = ['Data0D', 'Data1D', 'Data2D', 'DataND']

pymodaq/utils/plotting/data_viewers/base.py

@@ -0,0 +1,286 @@
+
+from typing import Union, TYPE_CHECKING, Iterable
+
+from pymodaq.utils.enums import BaseEnum
+from pyqtgraph.graphicsItems import InfiniteLine, ROI
+from qtpy import QtWidgets
+from qtpy.QtCore import QObject, Signal, QRectF
+
+from pymodaq.utils.data import DataToExport, DataWithAxes, DataDim, DataDistribution
+from pymodaq.utils.exceptions import ViewerError
+from pymodaq.utils.plotting.utils.plot_utils import RoiInfo
+
+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
+
+
+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']
+
+    @classmethod
+    def from_n_axes(cls, n_axes: int):
+        if n_axes == 0:
+            return ViewersEnum['Viewer0D']
+        elif n_axes == 1:
+            return ViewersEnum['Viewer1D']
+        elif n_axes == 2:
+            return ViewersEnum['Viewer2D']
+        elif n_axes > 2:
+            return ViewersEnum['ViewerND']
+
+    @staticmethod
+    def get_viewers_enum_from_metadata(dim: DataDim,
+                                       distribution: DataDistribution,
+                                       n_nav_axes: int,
+                                       n_sig_indexes: int,
+                                       shape_len: int,
+                                       size: int) -> 'ViewersEnum':
+        if dim.name == 'Data0D':
+            viewer = 'Viewer0D'
+        elif dim.name == 'Data1D':
+            viewer = 'Viewer1D'
+        elif dim.name == 'Data2D':
+            viewer = 'Viewer2D'
+        else:
+            if distribution.name == 'uniform':
+                if shape_len < 3:
+                    if shape_len == 1 and size == 1:
+                        viewer = 'Viewer0D'
+                    elif shape_len == 1 and size > 1:
+                        viewer = 'Viewer1D'
+                    elif shape_len == 2:
+                        viewer = 'Viewer2D'
+                    else:
+                        viewer = 'ViewerND'
+                else:
+                    viewer = 'ViewerND'
+            else:
+                if n_sig_indexes == 0:
+                    if n_nav_axes == 1:
+                        viewer = 'Viewer1D'
+                    elif n_nav_axes == 2:
+                        viewer = 'Viewer2D'
+                    else:
+                        viewer = 'ViewerND'
+                else:
+                    viewer = 'ViewerND'
+        return ViewersEnum[viewer]
+
+    @staticmethod
+    def get_viewers_enum_from_data(dwa: DataWithAxes) -> 'ViewersEnum':
+        if dwa.dim.name == 'Data0D':
+            viewer = 'Viewer0D'
+        elif dwa.dim.name == 'Data1D':
+            viewer = 'Viewer1D'
+        elif dwa.dim.name == 'Data2D':
+            viewer = 'Viewer2D'
+        else:
+            if dwa.distribution.name == 'uniform':
+                if len(dwa.shape) < 3:
+                    dwa.nav_indexes = ()
+                    if len(dwa.shape) == 1 and dwa.size == 1:
+                        viewer = 'Viewer0D'
+                    elif len(dwa.shape) == 1 and dwa.size > 1:
+                        viewer = 'Viewer1D'
+                    elif len(dwa.shape) == 2:
+                        viewer = 'Viewer2D'
+                    else:
+                        viewer = 'ViewerND'
+                else:
+                    viewer = 'ViewerND'
+            else:
+                if len(dwa.sig_indexes) == 0:
+                    if len(dwa.get_nav_axes()) == 1:
+                        viewer = 'Viewer1D'
+                    elif len(dwa.get_nav_axes()) == 2:
+                        viewer = 'Viewer2D'
+                    else:
+                        viewer = 'ViewerND'
+                else:
+                    viewer = 'ViewerND'
+        return ViewersEnum[viewer]
+
+
+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)
+    ROI_select_signal = Signal(QRectF)  # deprecated: use roi_select_signal
+    roi_select_signal = Signal(RoiInfo)
+
+    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: DataWithAxes, **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: DataWithAxes, *args, **kwargs):
+        """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)
+
+