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

pymodaq/daq_utils/plotting/scan_selector.py

@@ -1,289 +0,0 @@
-from qtpy import QtWidgets
-from qtpy.QtCore import QObject, Slot, QThread, Signal
-import sys
-from collections import OrderedDict
-from pyqtgraph import ROI, RectROI, PolyLineROI, Point
-
-from pyqtgraph.parametertree import Parameter, ParameterTree
-from pyqtgraph.dockarea import Dock
-from pymodaq.daq_utils.gui_utils import DockArea
-from pymodaq.daq_utils.plotting.utils.plot_utils import QVector
-from pymodaq.daq_utils import daq_utils as utils
-
-logger = utils.set_logger(utils.get_module_name(__file__))
-
-
-class PolyLineROI_custom(PolyLineROI):
-    def __init__(self, *args, **kwargs):
-        super(PolyLineROI_custom, self).__init__(*args, **kwargs)
-
-    def get_vertex(self):
-        return [h['item'].pos() for h in self.handles]
-
-    def get_vectors(self):
-        imgPts = self.get_vertex()
-        d = []
-        for i in range(len(imgPts) - 1):
-            d.append(QVector(imgPts[i], Point(imgPts[i + 1])))
-        return d
-
-    def getArrayIndexes(self, spacing=1, **kwds):
-        imgPts = self.get_vertex()
-        positions = []
-        for i in range(len(imgPts) - 1):
-            d = Point(imgPts[i + 1] - imgPts[i])
-            o = Point(imgPts[i])
-            vect = Point(d.norm())
-            Npts = 0
-            while Npts * spacing < d.length():
-                positions.append(((o + Npts * spacing * vect).x(), (o + Npts * spacing * vect).y()))
-                Npts += 1
-        # add_last point not taken into account
-        positions.append((imgPts[-1].x(), imgPts[-1].y()))
-        return positions
-
-
-class ScanSelector(QObject):
-    scan_select_signal = Signal(ROI)
-
-    params = [
-        {'title': 'Scan options', 'name': 'scan_options', 'type': 'group', 'children': [
-            {'title': 'Sources:', 'name': 'sources', 'type': 'list', },
-            {'title': 'Viewers:', 'name': 'viewers', 'type': 'list', },
-            {'title': 'Scan type:', 'name': 'scan_type', 'type': 'list', 'limits': ['Tabular', 'Scan2D'],
-             'value': 'Scan2D'},
-        ]},
-        {'title': 'Scan Area', 'name': 'scan_area', 'type': 'group', 'children': [
-            {'title': 'ROI select:', 'name': 'ROIselect', 'type': 'group', 'visible': True, 'children': [
-                {'title': 'x0:', 'name': 'x0', 'type': 'int', 'value': 0, 'min': 0},
-                {'title': 'y0:', 'name': 'y0', 'type': 'int', 'value': 0, 'min': 0},
-                {'title': 'width:', 'name': 'width', 'type': 'int', 'value': 10, 'min': 1},
-                {'title': 'height:', 'name': 'height', 'type': 'int', 'value': 10, 'min': 1},
-            ]},
-            {'title': 'Coordinates:', 'name': 'coordinates', 'type': 'itemselect', 'visible': True},
-        ]},
-    ]
-
-    def __init__(self, viewer_items=[], scan_type='Scan2D', positions=[]):
-        """
-
-        Parameters
-        ----------
-        viewer_items: dict where the keys are the titles of the sources while the values are dict with keys
-                        viewers: list of plotitems
-                        names: list of viewer titles
-        scan_type: (str) either 'Tabular' corresponding to a polyline ROI or 'Scan2D' for a rect Roi
-        positions: list
-                        in case of 'Tabular', should be a sequence of 2 floats sequence [(x1,y1),(x2,y2),(x3,y3),...]
-                        in case of 'Scan2D', should be a sequence of 4 floats (x, y , w, h)
-        """
-        super(ScanSelector, self).__init__()
-        self._viewers_items = viewer_items
-        self.sources_names = list(viewer_items.keys())
-        if len(viewer_items) != 0:
-            self.scan_selector_source = viewer_items[self.sources_names[0]]['viewers'][0]
-        else:
-            self.scan_selector_source = None
-        self.scan_selector = None
-        self.setupUI()
-        self.settings.child('scan_options', 'scan_type').setValue(scan_type)
-
-        self.remove_scan_selector()
-        if self.scan_selector_source is not None:
-            if len(viewer_items[self.sources_names[0]]['viewers']) == 1:
-                self.settings.child('scan_options', 'viewers').hide()
-        else:
-            self.settings.child('scan_options', 'viewers').hide()
-        self.update_scan_area_type()
-
-        if scan_type == "Scan1D" and positions != []:
-            self.scan_selector.setPoints(positions)
-        elif scan_type == 'Scan2D' and positions != []:
-            self.scan_selector.setPos(positions[:2])
-            self.scan_selector.setSize(positions[3:])
-
-    @property
-    def viewers_items(self):
-        return self._viewers_items
-
-    @viewers_items.setter
-    def viewers_items(self, items):
-        self._viewers_items = items
-        self.sources_names = list(items.keys())
-        self.scan_selector_source = items[self.sources_names[0]]['viewers'][0]
-        self.settings.child('scan_options', 'sources').setOpts(limits=self.sources_names)
-        viewer_names = self._viewers_items[self.sources_names[0]]['names']
-        self.settings.child('scan_options', 'viewers').setOpts(limits=viewer_names)
-
-    def show(self, visible=True):
-        self.show_scan_selector(visible)
-        if visible:
-            self.widget.show()
-        else:
-            self.widget.hide()
-
-    def hide(self):
-        self.show(False)
-
-    def setupUI(self):
-        self.widget = QtWidgets.QWidget()
-        layout = QtWidgets.QVBoxLayout()
-
-        self.settings_tree = ParameterTree()
-        layout.addWidget(self.settings_tree, 10)
-        self.settings_tree.setMinimumWidth(300)
-        self.settings = Parameter.create(name='Settings', type='group', children=self.params)
-        self.settings_tree.setParameters(self.settings, showTop=False)
-
-        self.settings.child('scan_options', 'sources').setOpts(limits=self.sources_names)
-        if len(self.viewers_items):
-            viewer_names = self._viewers_items[self.sources_names[0]]['names']
-        else:
-            viewer_names = []
-        self.settings.child('scan_options', 'viewers').setOpts(limits=viewer_names)
-
-        self.settings.sigTreeStateChanged.connect(self.source_changed)
-        self.widget.setLayout(layout)
-
-        # self.widget.show()
-        self.widget.setWindowTitle('Scan Selector')
-
-    def source_changed(self, param, changes):
-        for param, change, data in changes:
-            path = self.settings.childPath(param)
-            if path is not None:
-                childName = '.'.join(path)
-            else:
-                childName = param.name()
-            if change == 'childAdded':
-                pass
-
-            elif change == 'value':
-                if param.name() == 'sources' and param.value() is not None:
-                    viewer_names = self._viewers_items[param.value()]['names']
-                    self.settings.child('scan_options', 'viewers').setOpts(limits=viewer_names)
-                    if len(viewer_names) == 1:
-                        self.settings.child('scan_options', 'viewers').hide()
-
-                    self.remove_scan_selector()
-                    self.scan_selector_source = self._viewers_items[param.value()]['viewers'][0]
-                    self.update_scan_area_type()
-
-                if param.name() == 'scan_type':
-
-                    if param.value() == 'Tabular':
-                        self.settings.child('scan_area', 'ROIselect').hide()
-                        self.settings.child('scan_area', 'coordinates').show()
-                        self.remove_scan_selector()
-                        self.update_scan_area_type()
-                    else:
-                        self.settings.child('scan_area', 'ROIselect').show()
-                        self.settings.child('scan_area', 'coordinates').hide()
-                        self.remove_scan_selector()
-                        self.update_scan_area_type()
-                    self.scan_selector.sigRegionChangeFinished.emit(self.scan_selector)
-
-            elif change == 'parent':
-                pass
-
-    def remove_scan_selector(self):
-        if self.scan_selector_source is not None:
-            try:
-                self.scan_selector_source.image_widget.plotitem.removeItem(self.scan_selector)
-            except Exception as e:
-                logger.exception(str(e))
-                pass
-
-    Slot(str)
-
-    def update_scan_area_type(self):
-
-        if self.settings.child('scan_options', 'scan_type').value() == 'Tabular':
-            scan_area_type = 'PolyLines'
-        else:
-            scan_area_type = 'Rect'
-
-        self.remove_scan_selector()
-        if scan_area_type == 'Rect':
-            self.scan_selector = RectROI([0, 0], [10, 10])
-
-        elif scan_area_type == 'PolyLines':
-            self.scan_selector = PolyLineROI_custom([(0, 0), [10, 10]])
-        if self.scan_selector_source is not None:
-            self.scan_selector.sigRegionChangeFinished.connect(self.update_scan)
-            self.scan_selector_source.image_widget.plotitem.addItem(self.scan_selector)
-            self.show_scan_selector()
-
-            self.scan_selector.sigRegionChangeFinished.emit(self.scan_selector)
-
-    def show_scan_selector(self, visible=True):
-        self.scan_selector.setVisible(visible)
-
-    def update_scan(self, roi):
-        if self.scan_selector_source is not None:
-            if isinstance(roi, RectROI):
-                self.settings.child('scan_area', 'ROIselect', 'x0').setValue(roi.pos().x())
-                self.settings.child('scan_area', 'ROIselect', 'y0').setValue(roi.pos().y())
-                self.settings.child('scan_area', 'ROIselect', 'width').setValue(roi.size().x())
-                self.settings.child('scan_area', 'ROIselect', 'height').setValue(roi.size().y())
-            elif isinstance(roi, PolyLineROI_custom):
-                self.settings.child('scan_area', 'coordinates').setValue(
-                    dict(all_items=['({:.03f} , {:.03f})'.format(pt.x(),
-                                                                 pt.y()) for pt in roi.get_vertex()], selected=[]))
-
-            self.scan_select_signal.emit(roi)
-
-
-if __name__ == '__main__':
-    from pymodaq.daq_utils.plotting.data_viewers.viewer2D import Viewer2D
-    from pymodaq.daq_viewer.daq_viewer_main import DAQ_Viewer
-
-    class UI:
-        def __init__(self):
-            pass
-
-    class FakeDaqScan:
-
-        def __init__(self, area):
-            self.area = area
-            self.detector_modules = None
-            self.ui = UI()
-            self.dock = Dock('2D scan', size=(500, 300), closable=False)
-
-            form = QtWidgets.QWidget()
-            self.ui.scan2D_graph = Viewer2D(form)
-            self.dock.addWidget(form)
-            self.area.addDock(self.dock)
-
-    app = QtWidgets.QApplication(sys.argv)
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('pymodaq main')
-    fake = FakeDaqScan(area)
-
-    prog = DAQ_Viewer(area, title="Testing", DAQ_type='DAQ2D', parent_scan=fake)
-    prog.ui.IniDet_pb.click()
-    QThread.msleep(1000)
-    QtWidgets.QApplication.processEvents()
-    prog2 = DAQ_Viewer(area, title="Testing2", DAQ_type='DAQ2D', parent_scan=fake)
-    prog2.ui.IniDet_pb.click()
-    QThread.msleep(1000)
-    QtWidgets.QApplication.processEvents()
-
-    fake.detector_modules = [prog, prog2]
-    items = OrderedDict()
-    items[prog.title] = dict(viewers=[view for view in prog.ui.viewers],
-                             names=[view.title for view in prog.ui.viewers],
-                             )
-    items[prog2.title] = dict(viewers=[view for view in prog2.ui.viewers],
-                              names=[view.title for view in prog2.ui.viewers])
-    items["DaqScan"] = dict(viewers=[fake.ui.scan2D_graph],
-                            names=["DaqScan"])
-
-    selector = ScanSelector(items, scan_type='Tabular', positions=[(10, -10), (4, 4), (80, 50)])
-
-    win.show()
-    sys.exit(app.exec_())

pymodaq/daq_utils/plotting/utils/filter.py

@@ -1,236 +0,0 @@
-import numpy as np
-from qtpy.QtCore import QPointF, Slot
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.managers.roi_manager import ROIManager
-from pymodaq.daq_utils.plotting.items.crosshair import Crosshair
-from pymodaq.daq_utils.plotting.items.image import UniformImageItem
-
-
-class Filter:
-    def __init__(self):
-        self._is_active = False
-        self._slot_to_send_data = None
-
-    def register_activation_signal(self, activation_signal):
-        activation_signal.connect(lambda x: self.set_active(x))
-
-    def register_target_slot(self, slot):
-        self._slot_to_send_data = slot
-
-    @Slot(bool)
-    def set_active(self, activate=True):
-        self._is_active = activate
-
-    def filter_data(self, data: utils.DataFromPlugins):
-        if self._is_active:
-            filtered_data = self._filter_data(data)
-            if filtered_data is not None and self._slot_to_send_data is not None:
-                self._slot_to_send_data(filtered_data)
-
-    def _filter_data(self, data: utils.DataFromPlugins):
-        raise NotImplementedError
-
-
-class FilterFromCrosshair(Filter):
-    def __init__(self, crosshair: Crosshair, graph_items, image_keys):
-        """
-        Extract data along a crosshair using coordinates and data displayed in graph_items such as  imageItems
-        Parameters
-        ----------
-        crosshair : (Crosshair)
-        graph_items : (dict)
-        image_keys : (list) list of string identifier to link datas to their graph_items. This means that in
-            _filter_data, datas['data'][key] is plotted on graph_items[key] for key in image_keys
-        """
-        super().__init__()
-        self._graph_items = graph_items
-        self._image_keys = image_keys
-        self.crosshair = crosshair
-        self._x, self._y = 0., 0.
-
-    def _filter_data(self, datas: utils.DataFromPlugins):
-        data_dict = dict([])
-        if datas is not None:
-            self._x, self._y = self.crosshair.get_positions()
-            data_type = datas['distribution']
-            for data_index in range(len(self._image_keys)):
-                if data_index < len(datas['data']):
-                    data = datas['data'][data_index]
-                    image_type = self._image_keys[data_index]
-                    if data_type == 'uniform':
-                        data_dict[image_type] = self.get_data_from_uniform(image_type, data)
-                    elif data_type == 'spread':
-                        data_dict[image_type] = self.get_data_from_spread(image_type, data)
-        return data_dict
-
-    def get_data_from_uniform(self, data_key, data):
-        hor_axis, ver_axis = \
-            np.linspace(0, self._graph_items[data_key].width() - 1, self._graph_items[data_key].width()),\
-            np.linspace(0, self._graph_items[data_key].height() - 1, self._graph_items[data_key].height())
-
-        indx, indy = self.mapfromview(self._x, self._y, data_key)
-
-        data_H_index = slice(None, None, 1)
-        data_V_index = slice(None, None, 1)
-        H_indexes = (utils.rint(indy), data_H_index)
-        V_indexes = (data_V_index, utils.rint(indx))
-
-        out_of_bounds = False
-        if 0 <= H_indexes[0] < len(ver_axis):
-            hor_data = data[H_indexes]
-        else:
-            out_of_bounds = True
-            hor_data = np.zeros(hor_axis.shape)
-        if 0 <= V_indexes[1] < len(hor_axis):
-            ver_data = data[V_indexes]
-        else:
-            out_of_bounds = True
-            ver_data = np.zeros(ver_axis.shape)
-        if out_of_bounds:
-            ind_data = 0.
-        else:
-            ind_data = data[utils.rint(indy), utils.rint(indx)]
-        return LineoutData(hor_axis=hor_axis, ver_axis=ver_axis, hor_data=hor_data, ver_data=ver_data,
-                           int_data=ind_data)
-
-    def get_data_from_spread(self, data_key, data):
-        data_H_index = slice(None, None, 1)
-        data_V_index = slice(None, None, 1)
-        posx, posy = self.mapfromview(self._x, self._y, data_key)
-
-        points, data = self._graph_items[data_key].get_points_at(axis='y', val=posy)
-        x_sorted_indexes = np.argsort(points[:, 0])
-        hor_axis = points[x_sorted_indexes, 0][data_H_index]
-
-        hor_data = data[x_sorted_indexes][data_H_index]
-
-        points, data = self._graph_items[data_key].get_points_at(axis='x', val=posx)
-        y_sorted_indexes = np.argsort(points[:, 1])
-        ver_axis = points[y_sorted_indexes, 1][data_V_index]
-
-        ver_data = data[y_sorted_indexes][data_V_index]
-
-        return LineoutData(hor_axis=hor_axis, ver_axis=ver_axis, hor_data=hor_data, ver_data=ver_data,
-                           int_data=self._graph_items[data_key].get_val_at((posx, posy)))
-
-
-
-    def mapfromview(self, x, y, item_key='red'):
-        """
-        get item coordinates from view coordinates
-        Parameters
-        ----------
-        x: (float) x coordinate in the view reference frame
-        y: (float) y coordinate in the view refernece frame
-
-        Returns
-        -------
-        x: (float) coordinate in the item reference frame
-        y: (float) coordinate in the item reference frame
-        """
-        point = self._graph_items[item_key].mapFromView(QPointF(x, y))
-        return point.x(), point.y()
-
-
-class FilterFromRois(Filter):
-    def __init__(self, roi_manager: ROIManager, graph_item: UniformImageItem, image_keys):
-        """
-
-        Parameters
-        ----------
-        roi_manager
-        graph_item
-        image_keys : (list) list of string identifier to link datas to their graph_items. This means that in
-            _filter_data, datas['data'][key] is plotted on graph_items[key] for key in image_keys
-        """
-        super().__init__()
-        self._roi_settings = roi_manager.settings
-        self._image_keys = image_keys
-        self._graph_item = graph_item
-        self.axes = (0, 1)
-        self._ROIs = roi_manager.ROIs
-
-    def _filter_data(self, datas: utils.DataFromPlugins) -> dict:
-        data_dict = dict([])
-        if datas is not None:
-            for roi_key, roi in self._ROIs.items():
-                image_key = self._roi_settings.child('ROIs', roi_key, 'use_channel').value()
-                image_index = self._image_keys.index(image_key)
-
-                data_type = datas['distribution']
-                data = datas['data'][image_index]
-                data_dict[roi_key] = self.get_xydata_from_roi(data_type, roi, data)
-        return data_dict
-
-
-
-    def get_xydata_from_roi(self, data_type, roi, data):
-
-        if data is not None:
-            if data_type == 'spread':
-                xvals, yvals, data = self.get_xydata_spread(data, roi)
-                ind_xaxis = np.argsort(xvals)
-                ind_yaxis = np.argsort(yvals)
-                xvals = xvals[ind_xaxis]
-                yvals = yvals[ind_yaxis]
-                data_H = data[ind_xaxis]
-                data_V = data[ind_yaxis]
-                int_data = np.array([np.mean(data)])
-            else:
-                xvals, yvals, data = self.get_xydata(data, roi)
-                data_H = np.mean(data, axis=0)
-                data_V = np.mean(data, axis=1)
-                int_data = np.array([np.mean(data)])
-
-            return LineoutData(hor_axis=xvals, ver_axis=yvals, hor_data=data_H, ver_data=data_V, int_data=int_data)
-
-    def get_xydata(self, data, roi):
-        data, coords = self.data_from_roi(data, roi)
-
-        if data is not None:
-            xvals = np.linspace(np.min(np.min(coords[1, :, :])), np.max(np.max(coords[1, :, :])),
-                                data.shape[1])
-            yvals = np.linspace(np.min(np.min(coords[0, :, :])), np.max(np.max(coords[0, :, :])),
-                                data.shape[0])
-        else:
-            xvals = yvals = data = np.array([])
-        return xvals, yvals, data
-
-    def data_from_roi(self, data, roi):
-        data, coords = roi.getArrayRegion(data, self._graph_item, self.axes, returnMappedCoords=True)
-        return data, coords
-
-    def get_xydata_spread(self, data, roi):
-        xvals = []
-        yvals = []
-        data_out = []
-        for ind in range(data.shape[0]):
-            # invoke the QPainterpath of the ROI (from the shape method)
-            if roi.shape().contains(QPointF(data[ind, 0] - roi.pos().x(),
-                                            data[ind, 1] - roi.pos().y())):
-                xvals.append(data[ind, 0])
-                yvals.append(data[ind, 1])
-                data_out.append(data[ind, 2])
-        data_out = np.array(data_out)
-        xvals = np.array(xvals)
-        yvals = np.array(yvals)
-        return xvals, yvals, data_out
-
-
-class LineoutData:
-    def __init__(self, hor_axis=np.array([]), ver_axis=np.array([]), hor_data=np.array([]), ver_data=np.array([]),
-                 int_data=None):
-        super().__init__()
-        if len(hor_axis) != len(hor_data):
-            raise ValueError(f'Horizontal lineout data and axis must have the same size')
-        if len(ver_axis) != len(ver_data):
-            raise ValueError(f'Horizontal lineout data and axis must have the same size')
-
-        self.hor_axis = hor_axis
-        self.ver_axis = ver_axis
-        self.hor_data = hor_data
-        self.ver_data = ver_data
-        if int_data is None:
-            self.int_data = np.array([np.sum(self.ver_data)])
-        else:
-            self.int_data = int_data

pymodaq/daq_utils/plotting/viewer0D/viewer0D_main.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewer0D import Viewer0D
-
-deprecation_msg('Viewer0D should now be imported from pymodaq.daq_utils.plotting.data_viewers')

pymodaq/daq_utils/plotting/viewer1D/viewer1D_main.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewer1D import Viewer1D
-
-deprecation_msg('Viewer1D should now be imported from pymodaq.daq_utils.plotting.data_viewers')

pymodaq/daq_utils/plotting/viewer1D/viewer1Dbasic.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewer1D import Viewer1DBasic
-
-deprecation_msg('Viewer1DBasic should now be imported from pymodaq.daq_utils.plotting.data_viewers')

pymodaq/daq_utils/plotting/viewer2D/viewer_2D_basic.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewer2D_basic import Viewer2DBasic
-
-deprecation_msg('Viewer2DBasic should now be imported from pymodaq.daq_utils.plotting.data_viewers')

pymodaq/daq_utils/plotting/viewer2D/viewer_2D_main.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewer2D import Viewer2D
-
-deprecation_msg('Viewer2D should now be imported from pymodaq.daq_utils.plotting.data_viewers')

pymodaq/daq_utils/plotting/viewerND/viewerND_main.py

@@ -1,4 +0,0 @@
-from pymodaq.daq_utils.messenger import deprecation_msg
-from ..data_viewers.viewerND import ViewerND
-
-deprecation_msg('ViewerND should now be imported from pymodaq.daq_utils.plotting.data_viewers')