pymodaq 5.1.6__py3-none-any.whl

pymodaq/utils/scanner/scanners/_2d_scanners.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from typing import List, Tuple, TYPE_CHECKING
+
+import numpy as np
+from pymodaq_data.data import Axis, DataDistribution
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import math_utils as mutils
+from pymodaq_utils import config as configmod
+from pymodaq.utils.scanner.scan_selector import Selector
+
+from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
+
+class Scan2DBase(ScannerBase):    
+    params = [{'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
+                'children':[]
+                }, 
+                {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
+                'children':[]
+                }, 
+                ]
+    axes = ('axis1','axis2')    
+    n_axes = 2
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+        self.axes_unique = []
+
+        
+@ScannerFactory.register()
+class Scan2DLinear(Scan2DBase):    
+    
+    params = [{'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
+               'children':[
+              {'title': 'Start Ax1:', 'name': 'start_axis1', 'type': 'float',
+               'value': 0.},
+              {'title': 'Stop Ax1:', 'name': 'stop_axis1', 'type': 'float',
+               'value': 1.},
+              {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
+               'value': 0.1},
+              ]}, 
+              {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
+               'children':[
+              {'title': 'Start Ax2:', 'name': 'start_axis2', 'type': 'float',
+               'value': 0.},
+              {'title': 'Stop Ax2:', 'name': 'stop_axis2', 'type': 'float',
+               'value': 1.},
+              {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
+               'value': 0.1},
+               ]},
+              ]    
+    n_axes = 2
+    distribution = DataDistribution['uniform']
+    scan_type = 'Scan2D'
+    scan_subtype = 'Linear'
+
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_units(self):
+        """ Update settings units depending on the scanner type and the display_units boolean"""
+        if len(self.actuators) > 0:
+            for child in self.settings.child('axis1').children():
+                child.setOpts(
+                    suffix='' if not self.display_units else self.actuators[0].units)
+        if len(self.actuators) > 1:
+            for child in self.settings.child('axis2').children():
+                child.setOpts(
+                    suffix='' if not self.display_units else self.actuators[1].units)
+
+    def get_pos(self):
+        starts = np.array([self.settings[ax, f'start_{ax}'] for ax in self.axes])
+        stops = np.array([self.settings[ax, f'stop_{ax}'] for ax in self.axes])
+        steps = np.array([self.settings[ax, f'step_{ax}'] for ax in self.axes])
+        return starts, stops, steps
+
+    def evaluate_steps(self) -> int:
+        starts, stops, steps = self.get_pos()
+        n_steps = 1
+        for ind in range(starts.size):
+            n_steps *= np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1
+        return int(n_steps)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        if np.any(np.abs(steps) < 1e-12) or \
+                np.any(np.sign(stops - starts) != np.sign(steps)) or \
+                np.any(starts == stops):
+
+            return np.array([starts])
+
+        else:
+            axis_1_unique = mutils.linspace_step(starts[0], stops[0], steps[0])
+            axis_2_unique = mutils.linspace_step(starts[1], stops[1], steps[1])
+
+            positions = []
+            for ind_x, pos1 in enumerate(axis_1_unique):
+                for ind_y, pos2 in enumerate(axis_2_unique):
+                    positions.append([pos1, pos2])
+
+        self.get_info_from_positions(np.array(positions))
+
+    def set_settings_titles(self):
+        if len(self.actuators) == 2:
+            for i,ax in enumerate(self.axes):            
+                title = self.actuators[i].title
+                self.settings.child(ax).setOpts(title=title)                
+                self.settings.child(ax, f'start_{ax}').setOpts(title=f'{title} start:')
+                self.settings.child(ax, f'stop_{ax}').setOpts(title=f'{title} stop:')
+                self.settings.child(ax, f'step_{ax}').setOpts(title=f'{title} step:')
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{act.title}',
+                     units=f'{act.units}',
+                     data=self.axes_unique[ind],
+                     index=ind) for ind, act in enumerate(self.actuators)]
+
+    def get_scan_shape(self) -> Tuple[int]:
+        return tuple([len(axis) for axis in self.axes_unique])
+
+    def get_indexes_from_scan_index(self, scan_index: int) -> Tuple[int]:
+        """To be reimplemented. Calculations of indexes within the scan"""
+        return tuple(self.axes_indexes[scan_index])
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        if coordinates.shape == (2, 2):
+            for i,ax in enumerate(self.axes):            
+                self.settings.child(ax,f'start_{ax}').setValue(coordinates[0, i])
+                self.settings.child(ax,f'stop_{ax}').setValue(coordinates[1, i])
+
+
+@ScannerFactory.register()
+class Scan2DLinearBF(Scan2DLinear):
+    scan_subtype = 'LinearBackForce'
+
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        if np.any(np.abs(steps) < 1e-12) or \
+                np.any(np.sign(stops - starts) != np.sign(steps)) or \
+                np.any(starts == stops):
+
+            return np.array([starts])
+
+        else:
+            axis_1_unique = mutils.linspace_step(starts[0], stops[0], steps[0])
+            axis_2_unique = mutils.linspace_step(starts[1], stops[1], steps[1])
+
+            positions = []
+            for ind_x, pos1 in enumerate(axis_1_unique):
+                for ind_y, pos2 in enumerate(axis_2_unique):
+                    if not mutils.odd_even(ind_x):
+                        positions.append([pos1, pos2])
+                    else:
+                        positions.append([pos1, axis_2_unique[len(axis_2_unique) - ind_y - 1]])
+
+        self.get_info_from_positions(np.array(positions))
+
+
+@ScannerFactory.register()
+class Scan2DRandom(Scan2DLinear):
+    scan_subtype = 'Random'
+
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_scan(self):
+        super().set_scan()
+        np.random.shuffle(self.positions)
+        self.get_info_from_positions(self.positions)
+
+
+@ScannerFactory.register()
+class Scan2DSpiral(Scan2DLinear):
+    scan_subtype = 'Spiral'
+    params = [{'title': 'Npts/axis', 'name': 'npts_by_axis', 'type': 'int', 'min': 1,
+               'value': 10},
+              {'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
+               'children': [
+                   {'title': 'Center Ax1:', 'name': 'center_axis1', 'type': 'float',
+                    'value': 0.},
+                   {'title': 'Rmax Ax1:', 'name': 'rmax_axis1', 'type': 'float',
+                    'value': 5.},
+                   {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
+                    'value': 0., 'readonly': True},
+               ]},
+              {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
+               'children': [
+                   {'title': 'Center Ax2:', 'name': 'center_axis2', 'type': 'float',
+                    'value': 0.},
+                   {'title': 'Rmax Ax2:', 'name': 'rmax_axis2', 'type': 'float',
+                    'value': 5.},
+                   {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
+                    'value': 0., 'readonly': True},
+               ]},
+              ]  
+   
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_settings_titles(self):
+        if len(self.actuators) == 2:
+            for i,ax in enumerate(self.axes):            
+                title = self.actuators[i].title
+                self.settings.child(ax).setOpts(title=title)                
+                self.settings.child(ax, f'center_{ax}').setOpts(title=f'{title} center:')
+                self.settings.child(ax, f'rmax_{ax}').setOpts(title=f'{title} rmax:')
+                self.settings.child(ax, f'step_{ax}').setOpts(title=f'{title} step:')
+
+    def value_changed(self, param):
+        starts, rmaxs, rsteps = self.get_pos()
+        for i,ax in enumerate(self.axes):            
+                self.settings.child(ax,f'step_{ax}').setValue(rsteps[i])
+        # self.settings.child('step_axis2').setValue(rsteps[1])
+
+    def get_pos(self):
+        """Get centers, radius and n steps from settings
+
+        Returns
+        ----------
+        centers: np.ndarray
+            containing the center positions of the scan
+        rmaxs: np.ndarray
+            containing the maximum radius (ellipse axes) in each direction
+        r_steps: np.ndarray
+            steps size in both directions
+        """
+        centers = np.array([self.settings[ax, f'center_{ax}'] for ax in self.axes])
+        rmaxs = np.array([self.settings[ax, f'rmax_{ax}'] for ax in self.axes])
+        r_steps = 2 * rmaxs / self.settings['npts_by_axis']
+        return centers, rmaxs, r_steps
+
+    def evaluate_steps(self) -> int:
+        return int(self.settings['npts_by_axis'] + 1) ** 2
+
+    def set_scan(self):
+        starts, rmaxs, rsteps = self.get_pos()
+
+        if np.any(np.array(rmaxs) == 0) or np.any(np.abs(rmaxs) < 1e-12) or np.any(np.abs(rsteps) < 1e-12):
+            positions = np.array([starts])
+
+        else:
+            Nlin = self.settings['npts_by_axis'] / 2
+            axis_1_indexes = [0]
+            axis_2_indexes = [0]
+            ind = 0
+            flag = True
+
+            while flag:
+                if mutils.odd_even(ind):
+                    step = 1
+                else:
+                    step = -1
+                if flag:
+
+                    for ind_step in range(ind):
+                        axis_1_indexes.append(axis_1_indexes[-1] + step)
+                        axis_2_indexes.append(axis_2_indexes[-1])
+                        if len(axis_1_indexes) >= (2 * Nlin + 1) ** 2:
+                            flag = False
+                            break
+                if flag:
+                    for ind_step in range(ind):
+                        axis_1_indexes.append(axis_1_indexes[-1])
+                        axis_2_indexes.append(axis_2_indexes[-1] + step)
+                        if len(axis_1_indexes) >= (2 * Nlin + 1) ** 2:
+                            flag = False
+                            break
+                ind += 1
+
+            positions = []
+            for ind in range(len(axis_1_indexes)):
+                positions.append(np.array([axis_1_indexes[ind] * rsteps[0] + starts[0],
+                                           axis_2_indexes[ind] * rsteps[1] + starts[1]]))
+
+        self.get_info_from_positions(np.array(positions))
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        if coordinates.shape == (2, 2):
+            for i,ax in enumerate(self.axes):            
+                self.settings.child(ax, f'center_{ax}').setValue(
+                    (coordinates[0, i] + coordinates[1, i]) / 2)
+                self.settings.child(ax, f'rmax_{ax}').setValue(
+                    (coordinates[0, i] - coordinates[1, i]) / 2)
+

pymodaq/utils/scanner/scanners/__init__.py

@@ -0,0 +1 @@
+

pymodaq/utils/scanner/scanners/sequential.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from typing import List, Tuple, TYPE_CHECKING, Iterable
+
+import numpy as np
+
+from qtpy import QtCore, QtWidgets
+from pymodaq_data.data import Axis, DataDistribution
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import math_utils as mutils
+from pymodaq_utils import config as configmod
+from pymodaq_data import Q_
+
+from pymodaq_gui import utils as gutils
+from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq.utils.scanner.scan_selector import Selector
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
+
+class TableModelSequential(gutils.TableModel):
+    """Table Model for the Model/View Qt framework dedicated to the Sequential scan mode"""
+    def __init__(self, data, **kwargs):
+        header = ['Actuator', 'Start', 'Stop', 'Step']
+        if 'header' in kwargs:
+            header = kwargs.pop('header')
+        editable = [False, True, True, True]
+        if 'editable' in kwargs:
+            editable = kwargs.pop('editable')
+        super().__init__(data, header, editable=editable, cast=str, **kwargs)
+
+    def __repr__(self):
+        return f'{self.__class__.__name__} from module {self.__class__.__module__}'
+
+    def validate_data(self, row, col, value):
+        """
+        make sure the values and signs of the start, stop and step values are "correct"
+        Parameters
+        ----------
+        row: (int) row within the table that is to be changed
+        col: (int) col within the table that is to be changed
+        value: (float) new value for the value defined by row and col
+
+        Returns
+        -------
+        bool: True is the new value is fine (change some other values if needed) otherwise False
+        """
+        start = Q_(self.data(self.index(row, 1), QtCore.Qt.DisplayRole))
+        stop = Q_(self.data(self.index(row, 2), QtCore.Qt.DisplayRole))
+        step = Q_(self.data(self.index(row, 3), QtCore.Qt.DisplayRole))
+        value = Q_(value)
+        isstep = False
+        if col == 1:  # the start
+            start = value
+        elif col == 2:  # the stop
+            stop = value
+        elif col == 3:  # the step
+            isstep = True
+            step = value
+        try:
+            if np.abs(step).magnitude < 1e-12 or start == stop:
+                return False
+            if np.sign(stop - start) != np.sign(step):
+                if isstep:
+                    self._data[row][2] = str(-stop)
+                else:
+                    self._data[row][3] = str(-step)
+        except (TypeError, ValueError):
+            return False
+        return True
+
+
+@ScannerFactory.register()
+class SequentialScanner(ScannerBase):
+    scan_type = 'Sequential'
+    scan_subtype = 'Linear'
+    save_settings = False  # not easy to save table content in a toml...
+    params = [
+        {'title': 'Sequences', 'name': 'seq_table', 'type': 'table_view',
+         'delegate': gutils.SpinBoxDelegate},
+              ]
+    distribution = DataDistribution['uniform']
+    n_axes = 1
+
+    def __init__(self, actuators: List['DAQ_Move'], display_units=True, **_ignored):
+
+        self.table_model: TableModelSequential = None
+        self.table_view: TableViewCustom = None
+        super().__init__(actuators, display_units=display_units)
+        self.delegates: Iterable[gutils.SpinBoxDelegate] = []
+        self.update_model()
+
+    def set_units(self):
+        pass
+
+    @property
+    def actuators(self):
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, actuators):
+        self._actuators = actuators
+        base_path = self.actuators_name + [self.scan_type, self.scan_subtype]
+        self.config_saver_loader.base_path = base_path
+        self.update_model()
+
+    def update_model(self, init_data=None):
+        if init_data is None:
+            if self.table_model is not None:
+                init_data = []
+                names = [row[0] for row in self.table_model.get_data_all()]
+                for act in self._actuators:
+                    if act.title in names:
+                        ind_row = names.index(act.title)
+                        init_data.append(self.table_model.get_data_all()[ind_row])
+                    else:
+                        if self.display_units:
+                            init_data = [[act.title, f'0. {act.units}', f'1. {act.units}', f'0.1 {act.units}'] for act in self._actuators]
+                        else:
+                            init_data.append([act.title, '0.', '1.', '0.1'])
+            else:
+                if self.display_units:
+                    init_data = [[act.title, f'0. {act.units}', f'1. {act.units}', f'0.1 {act.units}'] for act in self._actuators]
+                else:
+                    init_data = [[act.title, '0.', '1.', '0.1'] for act in self._actuators]
+        self.table_model = TableModelSequential(init_data, )
+        self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
+        self.settings.child('seq_table').setValue(self.table_model)
+        self.n_axes = len(self._actuators)
+        self.update_table_view()
+
+    def get_pos(self):
+        starts = [Q_(self.table_model.get_data(ind, 1))
+                           for ind in range(self.table_model.rowCount(None))]
+        stops = [Q_(self.table_model.get_data(ind, 2))
+                          for ind in range(self.table_model.rowCount(None))]
+        steps = [Q_(self.table_model.get_data(ind, 3))
+                          for ind in range(self.table_model.rowCount(None))]
+        return starts, stops, steps
+
+    def evaluate_steps(self) -> int:
+        starts, stops, steps = self.get_pos()
+        n_steps = 1
+        for ind in range(len(starts)):
+            n_steps *= (np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1).magnitude
+        return int(n_steps)
+
+    @staticmethod
+    def pos_above_stops(positions, steps, stops):
+        state = []
+        for pos, step, stop in zip(positions, steps, stops):
+            if step >= 0:
+                state.append(pos > stop)
+            else:
+                state.append(pos < stop)
+        return state
+
+    def update_table_view(self):
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
+        #self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        self.delegates = []  # ItemDelegates should have parents and be instance attribute to work with setItemDelegateForColumn
+        for ind_actuator, actuator in enumerate(self.actuators):
+
+            self.delegates.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForRow(
+                ind_actuator, self.delegates[-1])
+
+        self.table_view.setDragEnabled(True)
+        self.table_view.setDropIndicatorShown(True)
+        self.table_view.setAcceptDrops(True)
+        self.table_view.viewport().setAcceptDrops(True)
+        self.table_view.setDefaultDropAction(QtCore.Qt.MoveAction)
+        self.table_view.setDragDropMode(QtWidgets.QTableView.InternalMove)
+        self.table_view.setDragDropOverwriteMode(False)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        all_positions = [starts.copy()]
+        positions = starts.copy()
+        state = self.pos_above_stops(positions, steps, stops)
+        if len(state) != 0:
+            while not state[0]:
+                if not np.any(np.array(state)):
+                    positions[-1] += steps[-1]
+
+                else:
+                    indexes_true = np.where(np.array(state))
+                    positions[indexes_true[-1][0]] = starts[indexes_true[-1][0]]
+                    positions[indexes_true[-1][0] - 1] += steps[indexes_true[-1][0] - 1]
+
+                state = self.pos_above_stops(positions, steps, stops)
+                if not np.any(np.array(state)):
+                    all_positions.append(positions.copy())
+        all_positions = np.array([[elt.magnitude for elt in positions] for positions in all_positions])
+        self.get_info_from_positions(all_positions)
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{act.title}', units=act.units, data=self.axes_unique[ind], index=ind)
+                for ind, act in enumerate(self.actuators)]
+
+    def get_indexes_from_scan_index(self, scan_index: int) -> Tuple[int]:
+        """To be reimplemented. Calculations of indexes within the scan"""
+        return tuple(self.axes_indexes[scan_index])
+
+    def get_scan_shape(self) -> Tuple[int]:
+        return tuple([len(axis) for axis in self.axes_unique])
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        pass