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

pymodaq/utils/plotting/utils/lineout.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 03/11/2022
+
+@author: Sebastien Weber
+"""
+from collections import OrderedDict
+from pyqtgraph import PlotCurveItem
+from qtpy.QtCore import QObject, Signal, Slot
+from pymodaq.utils.plotting.utils.plot_utils import Data0DWithHistory
+from pymodaq.utils.managers.roi_manager import ROIManager
+from pymodaq.utils.plotting.items.crosshair import Crosshair
+from pymodaq.utils.logger import set_logger, get_module_name
+import pymodaq.utils.daq_utils as utils
+from pymodaq.utils.logger import set_logger, get_module_name
+
+
+logger = set_logger(get_module_name(__file__))
+IMAGE_TYPES = ['red', 'green', 'blue']
+COLOR_LIST = utils.plot_colors
+COLORS_DICT = dict(red=(255, 0, 0), green=(0, 255, 0), blue=(0, 0, 255), spread=(128, 128, 128))
+
+
+def curve_item_factory(pen='red'):
+    """
+    Create a PlotCurveItem with the given pen
+    Parameters
+    ----------
+    pen: any type of arguments accepted by pyqtgraph.function.mkColor or one of the COLORS_DICT key
+
+    Returns
+    -------
+    PlotCurveItem
+    """
+    if isinstance(pen, str):
+        if pen in COLORS_DICT:
+            pen = COLORS_DICT[pen]
+    return PlotCurveItem(pen=pen)
+
+
+class LineoutPlotter(QObject):
+    """Base class to manage and display data filtered out into lineouts (1D, 0D)
+
+    Should be inherited and subclass some methods as appropriate
+
+    Parameters
+    ----------
+    graph_widgets: OrderedDict
+        Includes plotwidgets to display data
+    roi_manager:
+        The ROIManager to create ROIs and manage their properties
+    crosshair:
+        The Crosshair object
+    """
+
+    roi_changed = Signal(dict)
+    crosshair_lineout_plotted = Signal(dict)
+    roi_lineout_plotted = Signal(dict)
+
+    lineout_widgets = ['int']  # should be reimplemented see viewer2D
+
+    def __init__(self, graph_widgets: OrderedDict, roi_manager: ROIManager, crosshair: Crosshair):
+        super().__init__()
+
+        self._roi_manager = roi_manager
+        self._crosshair = crosshair
+
+        self._lineout_widgets = graph_widgets['lineouts']
+
+        self.integrated_data = Data0DWithHistory()
+
+        self._roi_curves = OrderedDict()
+        self._crosshair_curves = OrderedDict()
+        self._data_integrated = []
+
+        self.setup_crosshair()
+
+        self._roi_manager.new_ROI_signal.connect(self.add_ROI)
+        self._roi_manager.remove_ROI_signal.connect(self.remove_ROI)
+        self._roi_manager.roi_value_changed.connect(self.update_roi)
+
+    def plot_roi_lineouts(self, roi_dicts):
+        self.integrated_data.add_datas({roi_key: roi_dicts[roi_key].int_data for roi_key in roi_dicts})
+        for roi_key, lineout_data in roi_dicts.items():
+            if roi_key in self._roi_curves:
+                self._roi_curves[roi_key]['int'].setData(self.integrated_data.xaxis,
+                                                         self.integrated_data.datas[roi_key])
+        self.plot_other_lineouts(roi_dicts)
+
+        logger.debug('roi lineouts plotted')
+        self.roi_lineout_plotted.emit(roi_dicts)
+
+    def plot_other_lineouts(self, roi_dicts):
+        raise NotImplementedError
+
+    def plot_crosshair_lineouts(self, crosshair_dict):
+        self.plot_other_crosshair_lineouts(crosshair_dict)
+
+        logger.debug('crosshair lineouts plotted')
+        self.crosshair_lineout_plotted.emit(crosshair_dict)
+
+    def plot_other_crosshair_lineouts(self, crosshair_dict):
+        raise NotImplementedError
+
+    def get_lineout_widget(self, name):
+        if name not in self.lineout_widgets:
+            raise KeyError(f'The lineout_widget reference should be within {self.lineout_widgets} not {name}')
+        return self._lineout_widgets[name]
+
+    @Slot(str, tuple)
+    def update_roi(self, roi_key, param_changed):
+        param, param_value = param_changed
+
+        if param.name() == 'Color':
+            for curve in self._roi_curves[roi_key].values():
+                curve.setPen(param_value)
+
+        self.roi_changed.emit(self._roi_manager.ROIs)
+
+    @Slot(str)
+    def remove_ROI(self, roi_name):
+        index = int(roi_name.split('_')[1])
+        self.remove_roi_lineout_items(index)
+        self.roi_changed.emit(self._roi_manager.ROIs)
+
+    @Slot(int, str)
+    def add_ROI(self, newindex, roi_type):
+        item = self._roi_manager.get_roi_from_index(newindex)
+        item.sigRegionChangeFinished.connect(lambda: self.roi_changed.emit(self._roi_manager.ROIs))
+        item_param = self._roi_manager.settings.child('ROIs', 'ROI_{:02d}'.format(newindex))
+        color = item_param.child('Color').value()
+
+        self.add_roi_lineout_items(newindex, color)
+        self.roi_changed.emit(self._roi_manager.ROIs)
+
+    def add_roi_lineout_items(self, index, pen):
+        """
+        Add specifics lineouts generated from ROIs
+        Parameters
+        ----------
+        index: (int) index of the ROI generating these lineouts
+        pen: (str, tuple) any argument able to generate a QPen, see pyqtgraph.functions.mkPen
+        """
+        self._roi_curves[f'ROI_{index:02d}'] = \
+            {curv_key: curve_item_factory(pen) for curv_key in self.lineout_widgets}
+        self.add_lineout_items(*self._roi_curves[f'ROI_{index:02d}'].values())
+
+    def remove_roi_lineout_items(self, index):
+        """
+        Remove specifics lineouts generated from ROI referenced by a unique integer
+        Parameters
+        ----------
+        index: (int) index of the ROI generating these lineouts
+        """
+        items = self._roi_curves.pop(f'ROI_{index:02d}')
+        self.remove_lineout_items(*items.values())
+
+    def add_lineout_items(self, *curve_items):
+        """
+        Add Curve items sequentially to lineouts widgets: (hor, ver and int)
+        Parameters
+        ----------
+        curve_items: (PlotCurveItem) at most 3 of them
+        """
+        for ind, curve_item in enumerate(curve_items):
+            self.get_lineout_widget(self.lineout_widgets[ind]).addItem(curve_item)
+
+    def remove_lineout_items(self, *curve_items):
+        """
+        Remove Curve items sequentially to lineouts widgets: (hor, ver and int)
+        Parameters
+        ----------
+        curve_items: (PlotCurveItem) at most 3 of them
+        """
+
+        for ind, curve_item in enumerate(curve_items):
+            self.get_lineout_widget(self.lineout_widgets[ind]).removeItem(curve_item)
+
+    @Slot(bool)
+    def roi_clicked(self, isroichecked=True):
+        self._roi_manager.roiwidget.setVisible(isroichecked)
+
+        for k, roi in self._roi_manager.ROIs.items():
+            roi.setVisible(isroichecked)
+            for item in self.get_roi_curves_triplet()[k].values():
+                item.setVisible(isroichecked)
+
+    @Slot(bool)
+    def crosshair_clicked(self, iscrosshairchecked=True):
+        for image_key in IMAGE_TYPES:
+            self.show_crosshair_curves(image_key, iscrosshairchecked)
+
+    def get_roi_curves_triplet(self):
+        """
+        Get the dictionary (one key by ROI) containing dicts with ROI PlotCurveItem
+
+        Example:
+        --------
+        >>> roi_dict_triplet = self.get_roi_cruves_triplet()
+        >>> hor_curve = roi_dict_triplet['ROI_00']['hor']  # where 'hor' is an entry of self.lineout_widgets
+        """
+        return self._roi_curves
+
+    def get_crosshair_curves_triplet(self):
+        """
+        Get the dictionary (one key by ImageItem, see IMAGE_TYPES) containing dicts with PlotCurveItem
+
+        Example:
+        --------
+        >>> crosshair_dict_triplet = self.get_crosshair_curves_triplet()
+        >>> hor_curve = crosshair_dict_triplet['blue']['hor']  # where 'hor' is an entry of self.lineout_widgets
+        """
+        return self._crosshair_curves
+
+    def get_crosshair_curve_triplet(self, curve_name):
+        return self._crosshair_curves[curve_name]
+
+    def setup_crosshair(self):
+        """to reimplement if needed"""
+        pass
+
+    def show_crosshair_curves(self, curve_key, show=True):
+        """to reimplement if needed"""
+        pass

pymodaq/{daq_utils → utils}/plotting/utils/plot_utils.py

@@ -1,14 +1,160 @@
+from collections.abc import Iterable
+
+import copy
+from numbers import Real, Number
+from typing import List, Union
+from typing import Iterable as IterableType
+
+from easydict import EasyDict as edict
 from multipledispatch import dispatch
-from pymodaq.daq_utils.plotting.items.axis_scaled import AxisItem_Scaled
-from qtpy import QtGui, QtCore
-import pyqtgraph as pg
 import numpy as np
+import pyqtgraph as pg
+from qtpy import QtGui, QtCore, QtWidgets
 from scipy.spatial import Delaunay as Triangulation
-import copy
-from easydict import EasyDict as edict
 
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.messenger import deprecation_msg
+from pymodaq.utils import data as data_mod
+from pymodaq.utils.plotting.items.axis_scaled import AxisItem_Scaled
+from pymodaq.utils.plotting.data_viewers.viewer1Dbasic import Viewer1DBasic
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.messenger import deprecation_msg
+
+
+class Point:
+    def __init__(self, *elt: IterableType[float]):
+        """Initialize a geometric point in an arbitrary number of dimensions
+
+        Parameters
+        ----------
+        elt: either a tuple of floats, passed as multiple parameters or a single Iterable parameter
+        """
+        if len(elt) == 1 and isinstance(elt[0], Iterable):
+            elt = elt[0]
+
+        self._coordinates = np.atleast_1d(np.squeeze(elt))
+        self._ndim = len(elt)
+
+    @property
+    def coordinates(self):
+        return self._coordinates
+
+    def copy(self):
+        return Point(self.coordinates.copy())
+
+    def __getitem__(self, item: int):
+        return self._coordinates[item]
+
+    def __setitem__(self, key: int, value: float):
+        self._coordinates[key] = value
+
+    def __len__(self):
+        return self._ndim
+
+    def _compare_length(self, other: 'Point'):
+        if len(self) != len(other):
+            raise ValueError('Those points should be expressed in the same coordinate system and dimensions')
+
+    def __add__(self, other: Union['Point', 'Vector']):
+        self._compare_length(other)
+        return Point(*(self._coordinates + other._coordinates))
+
+    def __sub__(self, other: 'Point'):
+        self._compare_length(other)
+        return Point(*(self._coordinates - other._coordinates))
+
+    def __repr__(self):
+        return f'Point({self.coordinates})'
+
+
+class Vector:
+    def __init__(self, coordinates: Union[Point, np.ndarray], origin: Point = None):
+        if isinstance(coordinates, Point):
+            self._coordinates = coordinates.coordinates
+        else:
+            self._coordinates = coordinates
+
+        if origin is None:
+            origin = np.zeros((len(coordinates)))
+        else:
+            self._compare_length(origin)
+
+        self._origin = origin
+
+    def _compare_length(self, other: 'Point'):
+        if len(self) != len(other):
+            raise ValueError('Those Points/Vectors should be expressed in the same coordinate system and dimensions')
+
+    @property
+    def origin(self):
+        return self._origin
+
+    @property
+    def coordinates(self):
+        return self._coordinates
+
+    def copy(self):
+        return Vector(self.coordinates.copy(), origin=self.origin.copy())
+
+    def __len__(self):
+        return len(self._coordinates)
+
+    def norm(self):
+        return np.linalg.norm(self._coordinates)
+
+    def unit_vector(self):
+        return self * (1 / self.norm())
+
+    def __add__(self, other: 'Vector'):
+        self._compare_length(other)
+        return Vector(self.coordinates + other.coordinates, origin=self.origin.copy())
+
+    def __sub__(self, other: 'Vector'):
+        self._compare_length(other)
+        return Vector(self.coordinates - other.coordinates, origin=self.origin.copy())
+
+    def __mul__(self, other: Number):
+        if not isinstance(other, Number):
+            raise TypeError(f'Cannot multiply a vector with {other}')
+        return Vector(other * self.coordinates, origin=self.origin.copy())
+
+    def dot(self, other: 'Vector'):
+        self._compare_length(other)
+        return np.dot(self.coordinates, other.coordinates)
+
+    def cross(self, other: 'Vector'):
+        self._compare_length(other)
+        return np.cross(self.coordinates, other.coordinates)
+
+    def __repr__(self):
+        return f'Vector({self.coordinates})/Origin({self.origin.coordinates})'
+
+
+def get_sub_segmented_positions(spacing: float, points: List[Point]) -> List[np.ndarray]:
+    """Get Points coordinates spaced in between subsequent Points
+
+    Parameters
+    ----------
+    spacing: float
+        Distance between two subpoints
+    points: List[Point]
+        List of Points in arbitrary dimension forming segments one want to sample with a distance equal to spacing
+
+    Returns
+    -------
+    List[np.ndarray]: The list of the coordinates of the points
+    """
+    positions = []
+    for ind in range(len(points) - 1):
+        vect = Vector(points[ind+1]-points[ind], origin=points[ind])
+        npts = 0
+        while npts * spacing < vect.norm():
+            positions.append(
+                (vect.origin + vect.unit_vector() * npts * spacing).coordinates)
+            npts += 1
+
+    # # add_last point not taken into account
+    positions.append(points[-1].coordinates)
+    return positions
+
 
 class QVector(QtCore.QLineF):
     def __init__(self, *elt):
@@ -253,13 +399,35 @@ def makePolygons(tri):
 
 
 class Data0DWithHistory:
+    """Object to store scalar values and keep a history of a given length to them"""
     def __init__(self, Nsamples=200):
         super().__init__()
         self._datas = dict([])
-        self.Nsamples = Nsamples
+        self._Nsamples = Nsamples
         self._xaxis = None
         self._data_length = 0
 
+    @property
+    def size(self):
+        return self._data_length
+
+    @property
+    def length(self):
+        return self._Nsamples
+
+    @length.setter
+    def length(self, history_length: int):
+        if history_length > 0:
+            self._Nsamples = history_length
+
+    def __len__(self):
+        return self.length
+
+    @dispatch(data_mod.DataWithAxes)
+    def add_datas(self, data: data_mod.DataRaw):
+        datas = {data.labels[ind]: data.data[ind] for ind in range(len(data))}
+        self.add_datas(datas)
+
     @dispatch(list)
     def add_datas(self, datas: list):
         """
@@ -279,12 +447,12 @@ class Data0DWithHistory:
         ----------
         datas: (dict) dictionaary of floats or np.array(float)
         """
-        if len(datas) != len(self._datas):
+        if datas.keys() != self._datas.keys():
             self.clear_data()
 
         self._data_length += 1
 
-        if self._data_length > self.Nsamples:
+        if self._data_length > self._Nsamples:
             self._xaxis += 1
         else:
             self._xaxis = np.linspace(0, self._data_length, self._data_length, endpoint=False)
@@ -298,7 +466,7 @@ class Data0DWithHistory:
             else:
                 self._datas[data_key] = np.concatenate((self._datas[data_key], data))
 
-            if self._data_length > self.Nsamples:
+            if self._data_length > self._Nsamples:
                 self._datas[data_key] = self._datas[data_key][1:]
 
     @property
@@ -315,76 +483,20 @@ class Data0DWithHistory:
         self._xaxis = np.array([])
 
 
-class AxisInfosExtractor:
-
-    @staticmethod
-    @dispatch(np.ndarray)
-    def extract_axis_info(axis: np.ndarray):
-        label = ''
-        units = ''
-        data = axis
-
-        scaling = 1
-        offset = 0
-        if data is not None:
-            if len(data) > 1:
-                scaling = data[1] - data[0]
-                if scaling > 0:
-                    offset = np.min(data)
-                else:
-                    offset = np.max(data)
-
-        return scaling, offset, label, units
-
-    @staticmethod
-    @dispatch(utils.Axis)
-    def extract_axis_info(axis: utils.Axis):
-        data = None
-        if 'data' in axis:
-            data = axis['data']
-        label = axis['label']
-        units = axis['units']
-
-        scaling = 1
-        offset = 0
-        if data is not None:
-            if len(data) > 1:
-                scaling = data[1] - data[0]
-                if scaling > 0:
-                    offset = np.min(data)
-                else:
-                    offset = np.max(data)
-
-        return scaling, offset, label, units
-
-    @staticmethod
-    @dispatch(edict)
-    def extract_axis_info(axis: edict):
-        deprecation_msg('edict should not be used to store axis info, use daq_utils.Axis')
-        data = None
-        if 'data' in axis:
-            data = axis['data']
-        label = axis['label']
-        units = axis['units']
-
-        scaling = 1
-        offset = 0
-        if data is not None:
-            if len(data) > 1:
-                scaling = data[1] - data[0]
-                if scaling > 0:
-                    offset = np.min(data)
-                else:
-                    offset = np.max(data)
-
-        return scaling, offset, label, units
-
-    @staticmethod
-    @dispatch(AxisItem_Scaled)
-    def extract_axis_info(axis: AxisItem_Scaled):
-        label = axis.axis_label
-        units = axis.axis_units
-        scaling = axis.axis_scaling
-        offset = axis.axis_offset
-
-        return scaling, offset, label, units
+class View_cust(pg.ViewBox):
+    """Custom ViewBox used to enable other properties compared to parent class: pg.ViewBox
+
+    """
+    sig_double_clicked = QtCore.Signal(float, float)
+
+    def __init__(self, parent=None, border=None, lockAspect=False, enableMouse=True, invertY=False,
+                 enableMenu=True, name=None, invertX=False):
+        super().__init__(parent, border, lockAspect, enableMouse, invertY, enableMenu, name, invertX)
+
+    def mouseClickEvent(self, ev):
+        if ev.button() == QtCore.Qt.RightButton and self.menuEnabled():
+            ev.accept()
+            self.raiseContextMenu(ev)
+        if ev.double():
+            pos = self.mapToView(ev.pos())
+            self.sig_double_clicked.emit(pos.x(), pos.y())

pymodaq/{daq_utils → utils}/plotting/utils/signalND.py

@@ -10,7 +10,7 @@ import collections
 import copy
 
 import math
-from pymodaq.daq_utils import daq_utils as utils
+from pymodaq.utils import daq_utils as utils
 
 
 # %%
@@ -61,7 +61,7 @@ def isfloat(number):
 
 
 def iterable_not_string(thing):
-    return isinstance(thing, collections.Iterable) and not isinstance(thing, str)
+    return isinstance(thing, collections.abc.Iterable) and not isinstance(thing, str)
 
 
 class SpecialSlicers(object):
@@ -390,16 +390,6 @@ class DataAxis(object):
 
         return my_slice
 
-    @property
-    def index_in_array(self):
-        if self.axes_manager is not None:
-            return self.axes_manager._axes.index(self)
-        else:
-            raise AttributeError(
-                "This DataAxis does not belong to an AxesManager"
-                " and therefore its index_in_array attribute "
-                " is not defined")
-
     def value2index(self, value, rounding=round):
         """Return the closest index to the given value if between the limit.
 
@@ -741,7 +731,7 @@ class AxesManager(object):
 
 class Signal(FancySlicing):
 
-    def __init__(self, data, **kwds):
+    def __init__(self, data: np.ndarray, **kwds):
         """Create a Signal from a numpy array.
 
         Parameters
@@ -761,6 +751,20 @@ class Signal(FancySlicing):
         self.inav = SpecialSlicersSignal(self, True)
         self.isig = SpecialSlicersSignal(self, False)
 
+    def get_data_dimension(self):
+        dimension = "("
+        for ind, ax in enumerate(self.axes_manager.navigation_shape):
+            if ind != len(self.axes_manager.navigation_shape) - 1:
+                dimension += str(ax) + ','
+            else:
+                dimension += str(ax) + '|'
+        for ind, ax in enumerate(self.axes_manager.signal_shape):
+            if ind != len(self.axes_manager.signal_shape) - 1:
+                dimension += str(ax) + ','
+            else:
+                dimension += str(ax) + ')'
+        return dimension
+
     def _remove_axis(self, axes):
         am = self.axes_manager
         axes = am[axes]
@@ -789,6 +793,10 @@ class Signal(FancySlicing):
     def data(self, value):
         self._data = np.atleast_1d(np.asanyarray(value))
 
+    @property
+    def shape(self):
+        return self._data.shape
+
     def __repr__(self):
         unfolded = ""
         string = '<'

pymodaq/utils/plotting/widgets.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 04/11/2022
+
+@author: Sebastien Weber
+"""
+
+import pyqtgraph as pg
+from qtpy import QtWidgets
+
+from pymodaq.utils.plotting.utils.plot_utils import View_cust
+from pymodaq.utils.plotting.items.axis_scaled import AXIS_POSITIONS, AxisItem_Scaled
+
+
+class ImageWidget(pg.GraphicsLayoutWidget):
+    """this gives a layout to add imageitems.
+    """
+
+    def __init__(self, parent=None, *args_plotitem, **kwargs_plotitem):
+
+        super().__init__(parent)
+        self.setupUI(*args_plotitem, **kwargs_plotitem)
+
+    def setAspectLocked(self, lock=True, ratio=1):
+        """
+        Defines the aspect ratio of the view
+        Parameters
+        ----------
+        lock: (bool) if True aspect ratio is set to ratio, else the aspect ratio is varying when scaling the view
+        ratio: (int) aspect ratio between horizontal and vertical axis
+        """
+        self.plotitem.vb.setAspectLocked(lock=True, ratio=1)
+
+    def getAxis(self, position):
+        return self.plotitem.getAxis(position)
+
+    def setupUI(self, *args_plotitem, **kwargs_plotitem):
+        layout = QtWidgets.QGridLayout()
+        # set viewer area
+        self.scene_obj = self.scene()
+        self.view = View_cust()
+        self.plotitem = pg.PlotItem(viewBox=self.view, *args_plotitem, **kwargs_plotitem)
+        self.plotItem = self.plotitem  # for backcompatibility
+        self.setAspectLocked(lock=True, ratio=1)
+        self.setCentralItem(self.plotitem)
+
+    def add_scaled_axis(self, position):
+        """
+        Add a AxisItem_Scaled to the given position with respect with the plotitem
+        Parameters
+        ----------
+        position: (str) either 'top', 'bottom', 'right' or 'left'
+
+        Returns
+        -------
+
+        """
+        if position not in AXIS_POSITIONS:
+            raise ValueError(f'The Axis position {position} should be in {AXIS_POSITIONS}')
+        axis = AxisItem_Scaled(position)
+        self.plotitem.setAxisItems({position: axis})
+        return axis
+
+
+class PlotWidget(pg.PlotWidget):
+    def __init__(self, *args, **kwargs):
+        plot_item = pg.PlotItem(viewBox=View_cust())
+        super().__init__(*args, plotItem=plot_item, **kwargs)
+
+    @property
+    def view(self):
+        return self.getViewBox()
+
+    @property
+    def legend(self):
+        return self.plotItem.legend