pymodaq 5.1.6__py3-none-any.whl

pymodaq/utils/scanner/scanners/tabular.py

@@ -0,0 +1,319 @@
+# -*- 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_data import Q_
+from pymodaq_gui.utils import SpinBoxDelegate
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_utils import config as configmod
+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
+from pymodaq_gui.plotting.utils.plot_utils import Point, get_sub_segmented_positions
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
+
+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, cast=str, **kwargs)
+
+    def __len__(self):
+        return len(self._data)
+
+    def add_data(self, row, data=None):
+        if data is not None:
+            self.insert_data(row, [f'{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()
+class TabularScanner(ScannerBase):
+    scan_type = 'Tabular'
+    scan_subtype = 'Linear'
+    save_settings = False  # not easy to save table content in a toml...
+    params = [
+        {'title': 'Positions', 'name': 'tabular_table', 'type': 'table_view', 'delegate': gutils.SpinBoxDelegate,
+         'menu': True},
+              ]
+    distribution = DataDistribution['spread']
+
+    def __init__(self, actuators: List['DAQ_Move'], display_units=True, **kwargs):
+        self.table_model: TableModelTabular = None
+        self.table_view: TableViewCustom = None
+        super().__init__(actuators=actuators, display_units=display_units)
+        self.delegates: Iterable[SpinBoxDelegate] = []
+
+    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.display_units:
+                init_data = [[f'0. {act.units}' for act in self._actuators]]
+            else:
+                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.ResizeMode.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.setItemDelegateForColumn(
+                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)
+
+        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([[Q_(elt).magnitude for elt in line] for line in 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()
+class TabularScannerSubSegmented(TabularScanner):
+
+    scan_subtype = 'SubSegmented'
+    save_settings = False
+    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['DAQ_Move'], display_units=True):
+        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, display_units=display_units)
+
+    @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.ResizeMode.Stretch)
+        self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        self.delegates = []
+        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.setItemDelegateForColumn(
+                ind_actuator, self.delegates[-1])
+
+    def update_table_view_points(self):
+        self.table_view_points.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
+        self.table_view_points.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view_points.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        self.delegates_points = []
+        for ind_actuator, actuator in enumerate(self.actuators):
+            self.delegates_points.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForColumn(
+                ind_actuator, self.delegates_points[-1])
+
+        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([[Q_(elt).magnitude for elt in line] for line in 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,110 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from importlib import import_module
+from pathlib import Path
+
+
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+from pymodaq_utils.utils import get_entrypoints
+from pymodaq_utils.enums import BaseEnum
+
+from pymodaq.utils.scanner.scan_factory import ScannerFactory
+
+
+logger = set_logger(get_module_name(__file__))
+config = Config()
+
+
+def register_scanner(parent_module_name: str = 'pymodaq.utils.scanner'):
+    scanners = []
+    try:
+        scanner_module = import_module(f'{parent_module_name}.scanners')
+
+        scanner_path = Path(scanner_module.__path__[0])
+
+        for file in scanner_path.iterdir():
+            if file.is_file() and 'py' in file.suffix and file.stem != '__init__':
+                try:
+                    scanners.append(import_module(f'.{file.stem}', scanner_module.__name__))
+                except (ModuleNotFoundError, Exception) as e:
+                    pass
+    except ModuleNotFoundError:
+        pass
+    finally:
+        return scanners
+
+
+def register_scanners() -> list:
+    scanners = register_scanner('pymodaq.utils.scanner')
+    discovered_scanners_plugins = get_entrypoints('pymodaq.scanners')
+    for entry in discovered_scanners_plugins:
+        scanners.extend(register_scanner(entry.value))
+    return scanners
+
+
+register_scanners()
+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/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,50 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/01/2023
+
+@author: Sebastien Weber
+"""
+import sys
+
+import numpy as np
+
+from qtpy import QtWidgets
+from pymodaq_gui.plotting.data_viewers.viewer2D import Viewer2D
+from pymodaq.utils.data import Axis, DataFromRoi, DataFromPlugins
+
+
+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()

pymodaq/utils/tcp_ip/__init__.py

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

pymodaq/utils/tcp_ip/mysocket.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 26/10/2023
+
+@author: Sebastien Weber
+"""
+from pymodaq_data.serialize.mysocket import Socket
+
+from pymodaq_utils.utils import deprecation_msg
+
+deprecation_msg('Importing Socket from pymodaq is deprecated in PyMoDAQ >= 5,'
+                'import it from pymodaq_data.serialize.mysocket')

pymodaq/utils/tcp_ip/serializer.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 20/10/2023
+
+@author: Sebastien Weber
+"""
+
+from pymodaq_utils.utils import deprecation_msg
+
+from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SocketString, Socket
+
+deprecation_msg('Importing Serializer, DeSerializer from pymodaq is deprecated in PyMoDAQ >= 5,'
+                'import them from pymodaq_data.serialize.serializer')