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

pymodaq/utils/scanner/scanners/tabular.py

@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from typing import List, Tuple
+
+import numpy as np
+
+from qtpy import QtCore, QtWidgets
+from pymodaq.utils.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 import gui_utils as gutils
+from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
+from pymodaq.utils.parameter import utils as putils
+from pymodaq.utils.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq.utils.plotting.scan_selector import Selector
+from pymodaq.utils.plotting.utils.plot_utils import Point, get_sub_segmented_positions
+
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+class TableModelTabular(gutils.TableModel):
+    """Table Model for the Model/View Qt framework dedicated to the Tabular scan mode"""
+    def __init__(self, data, axes_name=None, **kwargs):
+        if axes_name is None:
+            if 'header' in kwargs:  # when saved as XML the header will be saved and restored here
+                axes_name = [h for h in kwargs['header']]
+                kwargs.pop('header')
+            else:
+                raise Exception('Invalid header')
+
+        header = [name for name in axes_name]
+        editable = [True for name in axes_name]
+        super().__init__(data, header, editable=editable, **kwargs)
+
+    def __len__(self):
+        return len(self._data)
+
+    def add_data(self, row, data=None):
+        if data is not None:
+            self.insert_data(row, [float(d) for d in data])
+        else:
+            self.insert_data(row, [0. for name in self.header])
+
+    def remove_data(self, row):
+        self.remove_row(row)
+
+    def load_txt(self):
+        fname = gutils.select_file(start_path=None, save=False, ext='*')
+        if fname is not None and fname != '':
+            while self.rowCount(self.index(-1, -1)) > 0:
+                self.remove_row(0)
+
+            data = np.loadtxt(fname)
+            if len(data.shape) == 1:
+                data = data.reshape((data.size, 1))
+            self.set_data_all(data)
+
+    def save_txt(self):
+        fname = gutils.select_file(start_path=None, save=True, ext='dat')
+        if fname is not None and fname != '':
+            np.savetxt(fname, self.get_data_all(), delimiter='\t')
+
+    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
+        """
+
+        return True
+
+
+class TableModelTabularReadOnly(TableModelTabular):
+    def setData(self, index, value, role):
+        return False
+
+
+@ScannerFactory.register('Tabular', 'Linear')
+class TabularScanner(ScannerBase):
+    params = [
+        {'title': 'Positions', 'name': 'tabular_table', 'type': 'table_view', 'delegate': gutils.SpinBoxDelegate,
+         'menu': True},
+              ]
+    distribution = DataDistribution['spread']
+
+    def __init__(self, actuators: List[str]):
+        self.table_model: TableModelTabular = None
+        self.table_view: TableViewCustom = None
+        super().__init__(actuators=actuators)
+        self.update_model()
+
+    @property
+    def actuators(self):
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, actuators_name):
+        self._actuators = actuators_name
+        self.update_model()
+
+    def update_model(self, init_data=None):
+        if init_data is None:
+            init_data = [[0. for _ in self._actuators]]
+
+        self.table_model = TableModelTabular(init_data, [act.title for act in self._actuators])
+        self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
+        self.settings.child('tabular_table').setValue(self.table_model)
+        self.n_axes = len(self._actuators)
+        self.update_table_view()
+
+    def update_table_view(self):
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        styledItemDelegate = QtWidgets.QStyledItemDelegate()
+        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
+        self.table_view.setItemDelegate(styledItemDelegate)
+
+        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)
+
+        self.table_view.add_data_signal[int].connect(self.table_model.add_data)
+        self.table_view.remove_row_signal[int].connect(self.table_model.remove_data)
+        self.table_view.load_data_signal.connect(self.table_model.load_txt)
+        self.table_view.save_data_signal.connect(self.table_model.save_txt)
+
+    def evaluate_steps(self):
+        return len(self.table_model)
+
+    def set_scan(self):
+        positions = np.array(self.table_model.get_data_all())
+        self.get_info_from_positions(positions)
+
+    def update_tabular_positions(self, positions: np.ndarray = None):
+        """Convenience function to write positions directly into the tabular table
+
+        Parameters
+        ----------
+        positions: ndarray
+            a 2D ndarray with as many columns as selected actuators
+        """
+        try:
+            if positions is None:
+                if self.settings.child('tabular_settings',
+                                       'tabular_selection').value() == 'Polylines':  # from ROI
+                    viewer = self.scan_selector.selector_source
+
+                    if self.settings.child('tabular_settings', 'tabular_subtype').value() == 'Linear':
+                        positions = self.scan_selector.scan_selector.getArrayIndexes(
+                            spacing=self.settings.child('tabular_settings', 'tabular_step').value())
+                    elif self.settings.child('tabular_settings',
+                                             'tabular_subtype').value() == 'Adaptive':
+                        positions = self.scan_selector.scan_selector.get_vertex()
+
+                    steps_x, steps_y = zip(*positions)
+                    steps_x, steps_y = viewer.scale_axis(np.array(steps_x), np.array(steps_y))
+                    positions = np.transpose(np.array([steps_x, steps_y]))
+                    self.update_model(init_data=positions)
+                else:
+                    self.update_model()
+            elif isinstance(positions, np.ndarray):
+                self.update_model(init_data=positions)
+            else:
+                pass
+        except Exception as e:
+            logger.exception(str(e))
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{act.title}', units=act.units, data=self.positions[:, ind], index=0,
+                     spread_order=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 scan_index,
+
+    def get_scan_shape(self) -> Tuple[int]:
+        return len(self.table_model),
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        self.update_model(init_data=coordinates)
+
+
+@ScannerFactory.register('Tabular', 'Subsegmented')
+class TabularScannerSubsegmented(TabularScanner):
+
+    params = [{'title': 'Step:', 'name': 'tabular_step', 'type': 'float', 'value': 0.1},
+              {'title': 'Points', 'name': 'tabular_points', 'type': 'table_view', 'delegate': gutils.SpinBoxDelegate,
+               'menu': True},
+             ] + TabularScanner.params
+
+    def __init__(self, actuators: List[str]):
+        self.table_model: TableModelTabularReadOnly = None
+        self.table_view: TableViewCustom = None
+        self.table_model_points: TableModelTabular = None
+        self.table_view_points: TableViewCustom = None
+        super().__init__(actuators=actuators)
+        self.update_model()
+        self.update_model_points()
+
+    @property
+    def actuators(self):
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, actuators_name):
+        self._actuators = actuators_name
+        self.update_model()
+        self.update_model_points()
+
+    def update_model(self, init_data=None):
+        if init_data is None:
+            init_data = [[0. for _ in self._actuators]]
+
+        self.table_model = TableModelTabularReadOnly(init_data, [act.title for act in self._actuators])
+        self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[1]
+        self.settings.child('tabular_table').setValue(self.table_model)
+        self.n_axes = len(self._actuators)
+        self.update_table_view()
+
+    def update_model_points(self, init_data=None):
+        if init_data is None:
+            init_data = [[0. for _ in self._actuators]]
+
+        self.table_model_points = TableModelTabular(init_data, [act.title for act in self._actuators])
+        self.table_view_points = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
+        self.settings.child('tabular_points').setValue(self.table_model_points)
+        self.update_table_view_points()
+
+    def update_table_view(self):
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        # self.table_view.setEnabled(False)
+
+    def update_table_view_points(self):
+        self.table_view_points.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.table_view_points.horizontalHeader().setStretchLastSection(True)
+        self.table_view_points.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view_points.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        styledItemDelegate = QtWidgets.QStyledItemDelegate()
+        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
+        self.table_view.setItemDelegate(styledItemDelegate)
+
+        self.table_view_points.setDragEnabled(True)
+        self.table_view_points.setDropIndicatorShown(True)
+        self.table_view_points.setAcceptDrops(True)
+        self.table_view_points.viewport().setAcceptDrops(True)
+        self.table_view_points.setDefaultDropAction(QtCore.Qt.MoveAction)
+        self.table_view_points.setDragDropMode(QtWidgets.QTableView.InternalMove)
+        self.table_view_points.setDragDropOverwriteMode(False)
+
+        self.table_view_points.add_data_signal[int].connect(self.table_model_points.add_data)
+        self.table_view_points.remove_row_signal[int].connect(self.table_model_points.remove_data)
+        self.table_view_points.load_data_signal.connect(self.table_model_points.load_txt)
+        self.table_view_points.save_data_signal.connect(self.table_model_points.save_txt)
+
+    def set_scan(self):
+        points = [Point(coordinates) for coordinates in self.table_model_points.get_data_all()]
+        positions = get_sub_segmented_positions(self.settings['tabular_step'], points)
+
+        self.table_model.set_data_all(positions)
+        positions = np.array(self.table_model.get_data_all())
+        self.get_info_from_positions(positions)
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        self.update_model_points(init_data=coordinates)
+        self.set_scan()

pymodaq/utils/scanner/utils.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+
+
+import numpy as np
+from qtpy import QtCore
+from qtpy.QtCore import Slot
+
+from pymodaq.utils.plotting.utils.plot_utils import QVector
+import pymodaq.utils.math_utils as mutils
+from pymodaq.utils import gui_utils as gutils
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.config import Config
+from pymodaq.utils.scanner.scan_factory import ScannerFactory
+from pymodaq.utils.enums import BaseEnum
+
+logger = set_logger(get_module_name(__file__))
+config = Config()
+
+scanner_factory = ScannerFactory()
+ScanType = BaseEnum('ScanType', ['NoScan'] + scanner_factory.scan_types())
+
+
+class ScannerException(Exception):
+    """Raised when there is an error related to the Scanner class (see pymodaq.da_utils.scanner)"""
+    pass
+
+
+class ScanInfo:
+    """Container class for a given scan details
+
+    It includes the number of steps and all the positions for the selected actuators. It also contains these positions
+    as scan axes for easier use.
+
+    Parameters
+    ----------
+
+    Nsteps: int
+        Number of steps of the scan
+    positions: ndarray
+        multidimensional array. the first dimension has a length of Nsteps and each element is an actuator position
+    positions_indexes: ndarray
+        multidimensional array of Nsteps 0th dimension length where each element is the index
+        of the corresponding positions within the axis_unique
+    axes_unique: list of ndarray
+        list of sorted (and with unique values) 1D arrays of unique positions of each defined axes
+    selected_actuators: List[str]
+        The actuators to be used for this scan
+    kwargs: dict of other named parameters to be saved as attributes
+
+    Attributes
+    ----------
+    Nsteps: int
+        Number of steps of the scan
+    positions: ndarray
+        multidimensional array. the first dimension has a length of Nsteps and each element is an actuator position
+    positions_indexes: ndarray
+        multidimensional array of Nsteps 0th dimension length where each element is the index
+        of the corresponding positions within the axis_unique
+    axes_unique: list of ndarray
+        list of sorted (and with unique values) 1D arrays of unique positions of each defined axes
+    kwargs: dict of other named attributes
+    """
+    def __init__(self, Nsteps=0, positions=None, axes_indexes=None, axes_unique=None, selected_actuators=[],
+                 **kwargs):
+        self.Nsteps = Nsteps
+        self.positions = positions
+        self.axes_indexes = axes_indexes
+        self.axes_unique = axes_unique
+        self.selected_actuators = selected_actuators
+        for k in kwargs:
+            setattr(self, k, kwargs[k])
+
+    def __repr__(self):
+        return f'Scan of {self.selected_actuators} with {self.Nsteps} positions'
+
+
+
+

pymodaq/utils/slicing.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 07/11/2022
+
+@author: Sebastien Weber
+"""
+import numpy as np
+
+
+class SpecialSlicers(object):
+    """make it elegant to apply a slice to navigation or signal dimensions"""
+    def __init__(self, obj, is_navigation):
+        self.is_navigation = is_navigation
+        self.obj = obj
+
+    def __getitem__(self, slices):
+        return self.obj._slicer(slices, self.is_navigation)
+
+
+class SpecialSlicersData(SpecialSlicers):
+
+    def __setitem__(self, i, j):
+        """x.__setitem__(i, y) <==> x[i]=y
+        """
+        raise NotImplementedError
+        if hasattr(j, 'data'):
+            j = j.data
+        array_slices = self.obj._get_array_slices(i, self.is_navigation)
+        self.obj.data[array_slices] = j
+
+    def __len__(self):
+        return self.obj.axes_manager.sig_shape[0]
+
+
+if __name__ == '__main__':
+    from pymodaq.utils.data import DataWithAxes, DataRaw, Axis
+    shape = (4, 10, 5, 7)
+    dat = np.arange(np.prod(shape))
+    dat = dat.reshape(shape)
+    data = DataRaw('mydata', data=[dat], nav_indexes=(0, 1, 2),
+                   axes=[Axis(f'axis_{ind:02d}',
+                              data=np.linspace(0, shape[ind]-1, shape[ind]),
+                              index=ind) for ind in range(len(shape))])
+    subdata_sig = data.inav[2, 2, 3].data
+    subdata_nav = data.isig[3].data
+    data.isig[:]
+    pass

pymodaq/utils/svg/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/01/2023
+
+@author: Sebastien Weber
+"""

pymodaq/utils/svg/svg_renderer.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/01/2023
+
+@author: Sebastien Weber
+"""
+import sys
+
+from qtpy import QtSvg, QtWidgets
+from qtpy.QtSvg import QSvgWidget
+
+
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+
+    widget = QSvgWidget()
+    widget.show()
+    widget.load(r'C:\Users\weber\Labo\Projet-Dossier candidature\Technical project\GDSII\wafer.svg')
+
+    sys.exit(app.exec_())

pymodaq/utils/svg/svg_view.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/01/2023
+
+@author: Sebastien Weber
+"""
+
+import sys
+from qtpy import QtWidgets, QtCore, QtSvg
+from pyqtgraph.widgets.GraphicsView import GraphicsView
+
+
+class SVGView:
+
+    def __init__(self, parent: QtWidgets.QWidget = None):
+        if parent is None:
+            parent = QtWidgets.QWidget()
+        self.parent_widget = parent
+        self.parent_widget.setLayout(QtWidgets.QHBoxLayout())
+        self.graphicsView = GraphicsView()
+        self.parent_widget.layout().addWidget(self.graphicsView)
+
+        svg_item = QtSvg.QGraphicsSvgItem(r'C:\Users\weber\Labo\Projet-Dossier candidature\Technical project\GDSII\wafer.svg')
+
+        self.graphicsView.sceneObj.addItem(svg_item)
+
+
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+
+    widget = QtWidgets.QWidget()
+    prog = SVGView(widget)
+    widget.show()
+
+    sys.exit(app.exec_())

pymodaq/utils/svg/svg_viewer2D.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/01/2023
+
+@author: Sebastien Weber
+"""
+import sys
+
+import numpy as np
+
+from qtpy import QtWidgets, QtCore, QtSvg
+from pyqtgraph.widgets.GraphicsView import GraphicsView
+from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
+from pymodaq.utils.data import Axis, DataToExport, DataFromRoi, DataFromPlugins, DataRaw
+
+
+def main():
+    app = QtWidgets.QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+
+    Nx = 100
+    Ny = 200
+    data_random = np.random.normal(size=(Ny, Nx))
+    x = np.linspace(-Nx/2, Nx/2 - 1, Nx)
+    y = 0.2 * np.linspace(-Ny/2, Ny/2 - 1, Ny)
+
+    from pymodaq.utils.math_utils import gauss2D
+
+    data_red = 3 * np.sin(x/5)**2 * gauss2D(x, 5, Nx / 10,
+                                            y, -1, Ny / 10, 1, 90) \
+               + 0.1 * data_random
+    data_green = 10 * gauss2D(x, -20, Nx / 10,
+                              y, -10, Ny / 20, 1, 0)
+    data_green[70:80, 7:12] = np.nan
+
+
+    prog = Viewer2D(widget)
+    widget.show()
+    prog.show_data(DataFromPlugins(name='mydata', distribution='uniform', data=[data_red, data_green],
+                                   axes=[Axis('xaxis', units='xpxl', data=x, index=1),
+                                         Axis('yaxis', units='ypxl', data=y, index=0),]))
+
+    prog.view.show_roi_target(True)
+    prog.view.move_scale_roi_target((50, 40), (20, 20))
+
+    QtWidgets.QApplication.processEvents()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':  # pragma: no cover
+    main()