pymodaq 5.1.6__py3-none-any.whl

pymodaq/extensions/daq_scan_ui.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/12/2022
+
+@author: Sebastien Weber
+"""
+import sys
+from typing import List, TYPE_CHECKING
+
+from qtpy import QtWidgets, QtCore
+from qtpy.QtCore import Signal
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+
+from pymodaq_gui.utils import CustomApp
+from pymodaq_gui.utils import DockArea, Dock
+from pymodaq_gui.utils.widgets.spinbox import QSpinBox_ro
+from pymodaq_gui.utils.widgets import QLED
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
+from pymodaq_gui.plotting.data_viewers import ViewersEnum
+
+
+if TYPE_CHECKING:
+    from pymodaq.utils.parameter import ParameterTree
+
+config = Config()
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQScanUI(CustomApp, ViewerDispatcher):
+    """
+
+    """
+    command_sig = Signal(ThreadCommand)
+
+    def __init__(self, parent):
+        CustomApp.__init__(self, parent)
+        self.setup_docks()
+        ViewerDispatcher.__init__(self, self.dockarea, title='Scanner',
+                                  next_to_dock=self.dock_command)
+
+        self.setup_menu(self._menubar)
+        self.setup_actions()
+        self.connect_things()
+
+    def setup_actions(self):
+        self.add_action('quit', 'Quit the module', 'close2', menu=self.file_menu)
+        self.add_action('ini_positions', 'Init Positions', '', menu=self.action_menu)
+        self.add_action('start', 'Start Scan', 'run2', "Start the scan", menu=self.action_menu)
+        self.add_action('start_batch', 'Start ScanBatches', 'run_all', "Start the batch of scans", menu=self.action_menu)
+        self.add_action('stop', 'Stop Scan', 'stop', "Stop the scan", menu=self.action_menu)
+        self.add_action('move_at', 'Move at doubleClicked', 'move_contour',
+                        "Move to positions where you double clicked", checkable=True, menu=self.action_menu)
+        self.add_action('log', 'Show Log file', 'information2', menu=self.file_menu)
+
+        self.add_action('load', 'Load File', 'Open', menu=self.file_menu, auto_toolbar=False)
+        self.file_menu.addSeparator()
+        self.add_action('save', 'Save file as', 'SaveAs', menu=self.file_menu, auto_toolbar=False)
+        self.add_action('show_file', 'Show file content', '', menu=self.file_menu, auto_toolbar=False)
+
+        self.add_action('navigator', 'Show Navigator', '', menu=self._extensions_menu, auto_toolbar=False)
+        self.add_action('batch', 'Show Batch Scanner', '', menu=self._extensions_menu, auto_toolbar=False)
+        self.set_action_visible('start_batch', False)
+
+    def enable_start_stop(self, enable=True):
+        """If True enable main buttons to launch/stop scan"""
+        self.set_action_enabled('start', enable)
+        self.set_action_enabled('stop', enable)
+
+    def connect_things(self):
+        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand('quit')))
+        self.connect_action('ini_positions', lambda: self.command_sig.emit(ThreadCommand('ini_positions')))
+        self.connect_action('start', lambda: self.command_sig.emit(ThreadCommand('start')))
+        self.connect_action('start_batch', lambda: self.command_sig.emit(ThreadCommand('start_batch')))
+        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand('stop')))
+        self.connect_action('move_at', lambda: self.command_sig.emit(ThreadCommand('move_at')))
+        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand('show_log', )))
+
+        self.connect_action('load', lambda: self.command_sig.emit(ThreadCommand('load')))
+        self.connect_action('save', lambda: self.command_sig.emit(ThreadCommand('save')))
+        self.connect_action('show_file', lambda: self.command_sig.emit(ThreadCommand('show_file')))
+        self.connect_action('navigator', lambda: self.command_sig.emit(ThreadCommand('navigator')))
+        self.connect_action('batch', lambda: self.command_sig.emit(ThreadCommand('batch')))
+
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
+        self.file_menu = menubar.addMenu('File')
+        self._extensions_menu = menubar.addMenu('Extensions')
+        self.action_menu = menubar.addMenu('Actions')
+
+    def setup_docks(self):
+        self.dock_command = Dock('Scan Command')
+        self.dockarea.addDock(self.dock_command)
+
+        widget_command = QtWidgets.QWidget()
+        widget_command.setLayout(QtWidgets.QVBoxLayout())
+        self.dock_command.addWidget(widget_command)
+        widget_command.layout().addWidget(self._toolbar)
+
+        splitter_widget = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
+        splitter_v_widget = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        widget_command.layout().addWidget(splitter_widget)
+        splitter_widget.addWidget(splitter_v_widget)
+        self.module_widget = QtWidgets.QWidget()
+        self.module_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.module_widget.setMinimumWidth(220)
+        self.module_widget.setMaximumWidth(400)
+
+        self.plotting_widget = QtWidgets.QWidget()
+        self.plotting_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.plotting_widget.setMinimumWidth(220)
+        self.plotting_widget.setMaximumWidth(400)
+
+        settings_widget = QtWidgets.QWidget()
+        settings_widget.setLayout(QtWidgets.QVBoxLayout())
+        settings_widget.setMinimumWidth(220)
+
+        splitter_v_widget.addWidget(self.module_widget)
+        splitter_v_widget.addWidget(self.plotting_widget)
+
+        splitter_v_widget.setSizes([400, 400])
+        splitter_widget.addWidget(settings_widget)
+
+
+        self._statusbar = QtWidgets.QStatusBar()
+        self.mainwindow.setStatusBar(self._statusbar)
+        self.populate_status_bar()
+
+        self.settings_toolbox = QtWidgets.QToolBox()
+        settings_widget.layout().addWidget(self.settings_toolbox)
+        self.scanner_widget = QtWidgets.QWidget()
+        self.scanner_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.settings_toolbox.addItem(self.scanner_widget, 'Scanner Settings')
+
+    def add_settings_toolbox_widget(self, widget: QtWidgets.QWidget, name: str):
+        """Add a widget, usaually a ParameterTree to the SettingsToolbox"""
+        self.settings_toolbox.addItem(widget, name)
+
+    def add_scanner_settings(self, tree: 'ParameterTree'):
+        """Adds a  ParameterTree to the Scanner settings widget"""
+        self.scanner_widget.layout().addWidget(tree)
+
+    def populate_toolbox_widget(self, widgets: List[QtWidgets.QWidget], names: List[str]):
+        for widget, name in zip(widgets, names):
+            self.settings_toolbox.addItem(widget, name)
+
+    def set_scanner_settings(self, settings_tree: QtWidgets.QWidget):
+        while True:
+            child = self.scanner_widget.layout().takeAt(0)
+            if not child:
+                break
+            child.widget().deleteLater()
+            QtWidgets.QApplication.processEvents()
+
+        self.scanner_widget.layout().addWidget(settings_tree)
+
+    def set_modules_settings(self, settings_widget):
+        self.module_widget.layout().addWidget(settings_widget)
+
+    def set_plotting_settings(self, settings_plotting):
+        self.plotting_widget.layout().addWidget(settings_plotting)
+
+    def populate_status_bar(self):
+        self._status_message_label = QtWidgets.QLabel('Initializing')
+        self._n_scan_steps_sb = QSpinBox_ro()
+        self._n_scan_steps_sb.setToolTip('Total number of steps')
+        self._indice_scan_sb = QSpinBox_ro()
+        self._indice_scan_sb.setToolTip('Current step value')
+        self._indice_average_sb = QSpinBox_ro()
+        self._indice_average_sb.setToolTip('Current average value')
+        
+        self._scan_done_LED = QLED()
+        self._scan_done_LED.set_as_false()
+        self._scan_done_LED.clickable = False
+        self._scan_done_LED.setToolTip('Scan done state')
+        self._statusbar.addPermanentWidget(self._status_message_label)
+
+        self._statusbar.addPermanentWidget(self._n_scan_steps_sb)
+        self._statusbar.addPermanentWidget(self._indice_scan_sb)
+        self._statusbar.addPermanentWidget(self._indice_average_sb)
+        self._indice_average_sb.setVisible(False)
+        self._statusbar.addPermanentWidget(self._scan_done_LED)
+
+    @property
+    def n_scan_steps(self):
+        return self._n_scan_steps_sb.value()
+
+    @n_scan_steps.setter
+    def n_scan_steps(self, nsteps: int):
+        self._n_scan_steps_sb.setValue(nsteps)
+
+    def display_status(self, status: str, wait_time=1000):
+        self._statusbar.showMessage(status, wait_time)
+        
+    def set_permanent_status(self, status: str):
+        self._status_message_label.setText(status)
+
+    def set_scan_step(self, step_ind: int):
+        self._indice_scan_sb.setValue(step_ind)
+
+    def show_average_step(self, show: bool = True):
+        self._indice_average_sb.setVisible(show)
+
+    def set_scan_step_average(self, step_ind: int):
+        self._indice_average_sb.setValue(step_ind)
+
+    def set_scan_done(self, done=True):
+        self._scan_done_LED.set_as(done)
+
+    def update_viewers(self, viewers_type: List[ViewersEnum], viewers_name: List[str] = None, force=False):
+        super().update_viewers(viewers_type, viewers_name, force)
+        self.command_sig.emit(ThreadCommand('viewers_changed', attribute=dict(viewer_types=self.viewer_types,
+                                                                              viewers=self.viewers)))
+
+def main():
+
+    app = QtWidgets.QApplication(sys.argv)
+
+    win = QtWidgets.QMainWindow()
+    dockarea = DockArea()
+    win.setCentralWidget(dockarea)
+    win.resize(1000, 500)
+    win.setWindowTitle('DAQScan Extension')
+
+    prog = DAQScanUI(dockarea)
+    win.show()
+
+
+    def print_command_sig(cmd_sig):
+        print(cmd_sig)
+        prog.display_status(str(cmd_sig))
+
+    prog.command_sig.connect(print_command_sig)
+    prog.update_viewers([ViewersEnum['Viewer0D'], ViewersEnum['Viewer1D'], ViewersEnum['Viewer2D']])
+
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

pymodaq/extensions/data_mixer/daq_0Dviewer_DataMixer.py

@@ -0,0 +1,97 @@
+from typing import TYPE_CHECKING
+import numpy as np
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_data.data import DataToExport
+from pymodaq_gui.parameter import Parameter
+
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+from pymodaq.utils.data import DataFromPlugins
+
+if TYPE_CHECKING:
+    from pymodaq.extensions.data_mixer import DataMixer
+
+
+class DAQ_0DViewer_DataMixer(DAQ_Viewer_base):
+    """ Instrument plugin class for a OD viewer.
+    
+    This object inherits all functionalities to communicate with PyMoDAQ’s DAQ_Viewer module through inheritance via
+    DAQ_Viewer_base. It makes a bridge between the DAQ_Viewer module and the Python wrapper of a particular instrument.
+
+    Attributes:
+    -----------
+    controller: object
+        The particular object that allow the communication with the hardware, in general a python wrapper around the
+         hardware library.
+
+    """
+    params = (comon_parameters+
+              [
+                  {'title': 'Related Detectors', 'name': 'overridden_detectors', 'type': 'list',
+                   'readonly': True}  # mandatory to know what detectors are related to the DataMixer
+              ])
+
+    def ini_attributes(self):
+        self.controller: DataMixer = None
+
+    def commit_settings(self, param: Parameter):
+        """Apply the consequences of a change of value in the detector settings
+
+        Parameters
+        ----------
+        param: Parameter
+            A given parameter (within detector_settings) whose value has been changed by the user
+        """
+        pass
+
+    def ini_detector(self, controller=None):
+        """Detector communication initialization
+
+        Parameters
+        ----------
+        controller: (object)
+            custom object of a PyMoDAQ plugin (Slave case). None if only one actuator/detector by controller
+            (Master case)
+
+        Returns
+        -------
+        info: str
+        initialized: bool
+            False if initialization failed otherwise True
+        """
+
+        self.controller: DataMixer = controller
+        if self.controller is not None:
+            self.controller.dte_computed_signal.connect(self.grab_done)
+
+        info = "DataMixer Detector Initialized"
+        initialized = True
+        return info, initialized
+
+    def close(self):
+        """Terminate the communication protocol"""
+        pass
+
+    def grab_done(self, dte: DataToExport):
+        self.dte_signal.emit(dte)
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """Start a grab from the detector
+
+        Parameters
+        ----------
+        Naverage: int
+            Number of hardware averaging (if hardware averaging is possible, self.hardware_averaging should be set to
+            True in class preamble and you should code this implementation)
+        kwargs: dict
+            others optionals arguments
+        """
+        self.controller.snap()
+
+    def stop(self):
+        """Stop the current grab hardware wise if necessary"""
+        return ''
+
+
+if __name__ == '__main__':
+    main(__file__)

pymodaq/extensions/data_mixer/data_mixer.py

@@ -0,0 +1,262 @@
+from qtpy import QtWidgets, QtCore
+import numpy as np
+from pathlib import Path
+
+from typing import Optional
+
+from pymodaq_gui import utils as gutils
+from pymodaq_utils.config import Config, ConfigError
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import find_dict_in_list_from_key_val
+from pymodaq_data.data import DataToExport, DataWithAxes
+
+from pymodaq.utils.config import Config as PyMoConfig
+from pymodaq.extensions.utils import CustomExt
+
+
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
+from pymodaq_gui.utils.widgets.qled import QLED
+from pymodaq_gui.parameter import utils as putils
+
+
+from pymodaq.extensions.data_mixer.model import get_models, DataMixerModel
+from pymodaq.extensions.data_mixer.utils import DataMixerConfig, find_key_in_nested_dict
+
+logger = set_logger(get_module_name(__file__))
+
+config_utils = Config()
+config_pymodaq = PyMoConfig()
+
+EXTENSION_NAME = 'Data Mixer'  # the name that will be displayed in the extension list in the
+# dashboard
+CLASS_NAME = 'DataMixer'  # this should be the name of your class defined below
+
+
+class DataMixer(CustomExt):
+    settings_name = 'DataMixerSettings'
+    models = get_models()
+    params = [
+        {'title': 'Models', 'name': 'models', 'type': 'group', 'expanded': True, 'visible': True,
+         'children': [
+             {'title': 'Models class:', 'name': 'model_class', 'type': 'list',
+              'limits': [d['name'] for d in models]},
+             {'title': 'Ini Model', 'name': 'ini_model', 'type': 'action', },
+             {'title': 'Model params:', 'name': 'model_params', 'type': 'group', 'children': []},
+
+         ]}]
+
+    dte_computed_signal = QtCore.Signal(DataToExport)
+
+    def __init__(self, parent: gutils.DockArea, dashboard):
+        super().__init__(parent, dashboard)
+
+        self.model_class: Optional[DataMixerModel] = None
+        self.datamixer_config = DataMixerConfig()
+        self.setup_ui()
+
+        self.settings.child('models', 'ini_model').sigActivated.connect(
+            self.get_action('ini_model').trigger)
+
+    def get_set_model_params(self, model_name):
+        self.settings.child('models', 'model_params').clearChildren()
+        if len(self.models) > 0:
+            model_class = find_dict_in_list_from_key_val(self.models, 'name', model_name)['class']
+            params = getattr(model_class, 'params')
+            self.settings.child('models', 'model_params').addChildren(params)
+
+
+    def setup_docks(self):
+        """Mandatory method to be subclassed to setup the docks layout
+
+        """
+        self.docks['settings'] = gutils.Dock('Settings')
+        self.dockarea.addDock(self.docks['settings'])
+        splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        self.docks['settings'].addWidget(splitter)
+        splitter.addWidget(self.modules_manager.settings_tree)
+        self.modules_manager.tree.header().setVisible(False)
+        self.modules_manager.settings.child('modules', 'actuators').hide()
+        self.modules_manager.settings.child('move_done').hide()
+        self.modules_manager.settings.child('det_done').hide()
+        self.modules_manager.settings.child('data_dimensions',
+                                            'det_data_list0D').setOpts(height=150)
+        self.modules_manager.settings.child('data_dimensions').hide()
+        self.modules_manager.settings.child('actuators_positions').hide()
+
+        splitter.addWidget(self.settings_tree)
+
+        self.docks['computed'] = gutils.Dock('Computed data')
+        self.dockarea.addDock(self.docks['computed'], 'right')
+
+        self.area_computed = gutils.DockArea()
+        self.docks['computed'].addWidget(self.area_computed)
+
+        self.dte_computed_viewer = ViewerDispatcher(self.area_computed)
+
+        if len(self.models) != 0:
+            self.get_set_model_params(self.models[0]['name'])
+
+    @property
+    def config_path(self) -> Path:
+        return self.datamixer_config.config_path
+
+    def validate_config(self) -> bool:
+        """ Read eventually saved settings from self.datamixer_config
+
+        Example
+        -------
+        utility = find_key_in_nested_dict(self.datamixer_config.to_dict(), 'prediction')
+
+        """
+        return True
+
+    def setup_actions(self):
+        """Method where to create actions to be subclassed. Mandatory
+
+        """
+        self.add_action('quit', 'Quit', 'close2', "Quit program")
+        combo_model = QtWidgets.QComboBox()
+        combo_model.addItems([model['name'] for  model in self.models])
+        self.add_widget('models', combo_model, tip='List of available models')
+        self.add_action('ini_model', 'Init Model', 'ini')
+        self.add_widget('model_led', QLED, toolbar=self.toolbar)
+        self.add_action('snap', 'Snap Detectors', 'snap',
+                        'Snap all selected detectors')
+        self.add_action('create_computed_detectors', 'Create Computed Detectors', 'Add_Step',
+                        tip='Create a DAQ_Viewer Control Module')
+
+    def connect_things(self):
+        """Connect actions and/or other widgets signal to methods"""
+        self.connect_action('quit', self.quit_fun)
+        self.connect_action('models', self.update_model_settings_from_action, signal_name='currentTextChanged')
+        self.connect_action('ini_model', self.ini_model)
+        self.modules_manager.det_done_signal.connect(self.process_data)
+        self.dte_computed_signal.connect(self.plot_computed_results)
+        self.connect_action('snap', self.snap)
+        self.modules_manager.detectors_changed.connect(self.update_connect_detectors)
+        self.connect_action('create_computed_detectors', self.create_computed_detectors)
+
+    def update_model_settings_from_action(self, model: str):
+        self.settings.child('models', 'model_class').setValue(model)
+
+    def process_data(self, dte: DataToExport):
+        if self.model_class is not None:
+            dte_computed = self.model_class.process_dte(dte)
+            self.dte_computed_signal.emit(dte_computed)
+
+    def snap(self):
+        self.modules_manager.grab_data(check_do_override=False)
+
+    def create_computed_detectors(self):
+        try:
+            self.dashboard.add_det_from_extension('DataMixer', 'DAQ0D', 'DataMixer', self)
+            self.dashboard.modules_manager.get_mod_from_name(
+                'DataMixer', 'det').settings.child('detector_settings', 'overridden_detectors').setOpts(
+                limits=self.modules_manager.selected_detectors_name)
+            self.set_action_enabled('create_computed_detectors', False)
+            #self.dashboard.override_det_from_extension(self.modules_manager.selected_detectors_name)
+        except Exception as e:
+            logger.exception(str(e))
+            pass
+
+    def update_connect_detectors(self):
+        try:
+            self.connect_detectors(False)
+        except :
+            pass
+        self.connect_detectors()
+
+    def connect_detectors(self, connect=True):
+        """Connect detectors to DAQ_Logging do_save_continuous method
+
+        Parameters
+        ----------
+        connect: bool
+            If True make the connection else disconnect
+        """
+        self.modules_manager.connect_detectors(connect=connect)
+
+    def plot_computed_results(self, dte):
+        self.dte_computed_viewer.show_data(dte)
+
+    def ini_model(self):
+        if self.model_class is None:
+            self.set_model()
+
+        self.get_action('model_led').set_as_true()
+        self.set_action_enabled('ini_model', False)
+        self.settings.child('models', 'ini_model').setValue(True)
+        self.set_action_enabled('models', False)
+        self.settings.child('models', 'model_class').setOpts(enabled=False)
+        self.modules_manager.settings_tree.setEnabled(False)
+
+        self.update_connect_detectors()
+
+    def set_model(self):
+        model_name = self.settings['models', 'model_class']
+        self.model_class = find_dict_in_list_from_key_val(
+            self.models, 'name', model_name)['class'](self)
+        self.model_class.ini_model_base()
+
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
+        """Non mandatory method to be subclassed in order to create a menubar
+
+        create menu for actions contained into the self._actions, for instance:
+
+        Examples
+        --------
+        >>>file_menu = self.mainwindow.menuBar().addMenu('File')
+        >>>self.affect_to('load', file_menu)
+        >>>self.affect_to('save', file_menu)
+
+        >>>file_menu.addSeparator()
+        >>>self.affect_to('quit', file_menu)
+
+        See Also
+        --------
+        pymodaq.utils.managers.action_manager.ActionManager
+        """
+        # todo create and populate menu using actions defined above in self.setup_actions
+        pass
+
+    def value_changed(self, param):
+        """ Actions to perform when one of the param's value in self.settings is changed from the
+        user interface
+
+        For instance:
+        if param.name() == 'do_something':
+            if param.value():
+                print('Do something')
+                self.settings.child('main_settings', 'something_done').setValue(False)
+
+        Parameters
+        ----------
+        param: (Parameter) the parameter whose value just changed
+        """
+        if param.name() == 'model_class':
+            self.get_set_model_params(param.value())
+            self.get_action('models').setCurrentText(param.value())
+        elif param.name() in putils.iter_children(self.settings.child('models', 'model_params'), []):
+            if self.model_class is not None:
+                self.model_class.update_settings(param)
+
+    def quit_fun(self):
+        self.mainwindow.close()
+        self.dashboard.remove_modules(['DataMixer'])
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('DataMixer')
+
+    preset_file_name = config_pymodaq('presets', 'default_preset_for_datamixer')
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, EXTENSION_NAME)
+    app.exec()
+
+    return dashboard, extension, win
+
+
+if __name__ == '__main__':
+    main()