pymodaq 5.0.5__py3-none-any.whl → 5.1.0a0__py3-none-any.whl

pymodaq/dashboard.py

@@ -8,7 +8,7 @@ import logging
 from pathlib import Path
 from importlib import import_module
 from packaging import version as version_mod
-from typing import Tuple, List, Any, TYPE_CHECKING
+from typing import Tuple, List, Any, TYPE_CHECKING, Sequence
 
 
 from qtpy import QtGui, QtWidgets, QtCore
@@ -46,7 +46,6 @@ from pymodaq.utils import config as config_mod_pymodaq
 from pymodaq.control_modules.daq_move import DAQ_Move
 from pymodaq.control_modules.daq_viewer import DAQ_Viewer
 from pymodaq_gui.utils.splash import get_splash_sc
-
 from pymodaq import extensions as extmod
 
 logger = set_logger(get_module_name(__file__))
@@ -72,6 +71,7 @@ class ManagerEnums(BaseEnum):
     overshoot = 2
     roi = 3
 
+
 class PymodaqUpdateTableWidget(QTableWidget):
     '''
         A class to represent PyMoDAQ and its subpackages'
@@ -113,10 +113,9 @@ class PymodaqUpdateTableWidget(QTableWidget):
         self.setItem(row, 2, QTableWidgetItem(str(current_version)))
         self.setItem(row, 3, QTableWidgetItem(str(available_version)))
 
-
     def get_checked_data(self):
-    	checked = list(map(lambda c : c.isChecked(), self._checkboxes))
-    	return list(np.array(self._package_versions)[checked])
+        checked = list(map(lambda c : c.isChecked(), self._checkboxes))
+        return list(np.array(self._package_versions)[checked])
 
     def sizeHint(self):
         self.resizeColumnsToContents()
@@ -133,6 +132,7 @@ class PymodaqUpdateTableWidget(QTableWidget):
 
         return QSize(width, height)
 
+
 class DashBoard(CustomApp):
     """
     Main class initializing a DashBoard interface to display det and move modules and logger """
@@ -336,9 +336,40 @@ class DashBoard(CustomApp):
         self.bayesian_window.setWindowTitle('Bayesian Optimiser')
         self.bayesian_module = extmod.BayesianOptimisation(dockarea=dockarea, dashboard=self)
         self.extensions['bayesian'] = self.bayesian_module
-        self.bayesian_window.show()
+
+        if self.bayesian_module.validate_config():
+            self.bayesian_window.show()
+        else:
+            messagebox(severity='critical', title="Bayesian Optimisation error",
+            text=f"""
+                <p>Saved Bayesian Optimisation configuration file is not compatible anymore.</p>
+                <p>Please delete the file at <b>{self.bayesian_module.config_path}</b>.</p>
+            """)
+            self.bayesian_module.quit()
         return self.bayesian_module
 
+    def load_adaptive(self, win=None):
+        if win is None:
+            self.adaptive_window = QtWidgets.QMainWindow()
+        else:
+            self.adaptive_window = win
+        dockarea = DockArea()
+        self.adaptive_window.setCentralWidget(dockarea)
+        self.adaptive_window.setWindowTitle('Adaptive Scan')
+        self.adaptive_module = extmod.AdaptiveOptimisation(dockarea=dockarea, dashboard=self)
+        self.extensions['adaptive'] = self.adaptive_module
+
+        if self.adaptive_module.validate_config():
+            self.adaptive_window.show()
+        else:
+            messagebox(severity='critical', title="Adaptive Optimisation error",
+                       text=f"""
+                    <p>Saved Adaptive Optimisation configuration file is not compatible anymore.</p>
+                    <p>Please delete the file at <b>{self.adaptive_module.config_path}</b>.</p>
+                """)
+            self.adaptive_module.quit()
+        return self.adaptive_module
+
     def load_extension_from_name(self, name: str) -> dict:
         return self.load_extensions_module(find_dict_in_list_from_key_val(extensions, 'name', name))
 
@@ -440,6 +471,7 @@ class DashBoard(CustomApp):
         self.add_action('do_pid', 'PID module', auto_toolbar=False)
         self.add_action('console', 'IPython Console', auto_toolbar=False)
         self.add_action('bayesian', 'Bayesian Optimisation', auto_toolbar=False)
+        self.add_action('adaptive', 'Adaptive Scan', auto_toolbar=False)
 
         self.add_action('about', 'About', 'information2')
         self.add_action('help', 'Help', 'help1')
@@ -517,6 +549,8 @@ class DashBoard(CustomApp):
         self.connect_action('do_pid', lambda: self.load_pid_module())
         self.connect_action('console', lambda: self.load_console())
         self.connect_action('bayesian', lambda: self.load_bayesian())
+        self.connect_action('adaptive', lambda: self.load_adaptive())
+
 
         self.connect_action('about', self.show_about)
         self.connect_action('help', self.show_help)
@@ -598,6 +632,7 @@ class DashBoard(CustomApp):
         self.extensions_menu.addAction(self.get_action('do_pid'))
         self.extensions_menu.addAction(self.get_action('console'))
         self.extensions_menu.addAction(self.get_action('bayesian'))
+        self.extensions_menu.addAction(self.get_action('adaptive'))
 
         # extensions from plugins
         extensions_actions = []
@@ -613,13 +648,15 @@ class DashBoard(CustomApp):
         help_menu.addAction(self.get_action('check_update'))
         help_menu.addAction(self.get_action('plugin_manager'))
 
-        self.overshoot_menu.setEnabled(False)
-        self.roi_menu.setEnabled(False)
-        self.remote_menu.setEnabled(False)
-        self.extensions_menu.setEnabled(False)
-        self.file_menu.setEnabled(True)
-        self.settings_menu.setEnabled(True)
-        self.preset_menu.setEnabled(True)
+        status = self.preset_file is None
+
+        self.overshoot_menu.setEnabled(not status)
+        self.roi_menu.setEnabled(not status)
+        self.remote_menu.setEnabled(not status)
+        self.extensions_menu.setEnabled(not status)
+        self.file_menu.setEnabled(status)
+        self.settings_menu.setEnabled(status)
+        self.preset_menu.setEnabled(status)
 
     def start_plugin_manager(self):
         self.win_plug_manager = QtWidgets.QMainWindow()
@@ -955,13 +992,33 @@ class DashBoard(CustomApp):
         detector_modules.append(det_mod_tmp)
         return det_mod_tmp
 
+    def override_det_from_extension(self, overriden_grabbers: Sequence[str] = None):
+        """ (Experimental) If an extension adding detectors within the Dashboard need to, it could call this
+        method.
+
+        Then if some other extension trigger a grab from it, the request of a grab won't be done twice
+
+        Parameters
+        ----------
+        overriden_grabbers: Sequence[str]
+            sequence of detector names whose corresponding modules should set their
+            attribute override_grab_from_extension to True.
+        """
+        if overriden_grabbers is not None:
+            for mod_name in overriden_grabbers:
+                mod = self.modules_manager.get_mod_from_name(mod_name, 'det')
+                if mod is not None:
+                    mod.override_grab_from_extension = True
+
     def add_det_from_extension(self, name: str, daq_type: str, instrument_name: str,
                                instrument_controller: Any):
+
         """ Specific method to add a DAQ_Viewer within the Dashboard. This Particular detector
         should be defined in the plugin of the extension and is used to mimic a grab while data
         are actually coming from the extension which loaded it
 
         For an exemple, see the pymodaq_plugins_datamixer plugin and its DataMixer extension
+        or the DAQ_PID extension
 
         Parameters
         ----------
@@ -992,7 +1049,8 @@ class DashBoard(CustomApp):
 
     def update_module_manager(self):
         if self.modules_manager is None:
-            self.modules_manager = ModulesManager(self.detector_modules, self.actuators_modules)
+            self.modules_manager = ModulesManager(self.detector_modules, self.actuators_modules,
+                                                  parent_name='Dashboard')
         else:
             self.modules_manager.actuators_all = self.actuators_modules
             self.modules_manager.detectors_all = self.detector_modules
@@ -1033,17 +1091,20 @@ class DashBoard(CustomApp):
                         self.preset_manager.preset_params.child('Moves').children()]
             plugins += [{'type': 'det', 'value': child} for child in
                         self.preset_manager.preset_params.child('Detectors').children()]
-
             for plug in plugins:
-                if plug["type"] == 'det':
-                    plug['ID'] = plug['value']['params', 'detector_settings', 'controller_ID']
-                    plug['status'] = plug['value']['params', 'detector_settings',
-                        'controller_status']
-                else:
-                    plug['ID'] = plug['value']['params', 'move_settings',
-                        'multiaxes', 'controller_ID']
-                    plug['status'] = plug['value'][
-                            'params', 'move_settings', 'multiaxes', 'multi_status']
+                    if plug["type"] == 'det':
+                        try:
+                            plug['ID'] = plug['value']['params', 'detector_settings', 'controller_ID']
+                            plug['status'] = plug['value']['params', 'detector_settings', 'controller_status']
+                        except KeyError as e:
+                            raise DetectorError
+                    else:
+                        try:
+                            plug['ID'] = plug['value']['params', 'move_settings','multiaxes', 'controller_ID']
+                            plug['status'] = plug['value']['params', 'move_settings', 'multiaxes', 'multi_status']
+                        except KeyError as e:
+                            raise ActuatorError
+
 
 
             IDs = list(set([plug['ID'] for plug in plugins]))
@@ -1421,8 +1482,11 @@ class DashBoard(CustomApp):
                 self.mainwindow.setVisible(True)
                 for area in self.dockarea.tempAreas:
                     area.window().setVisible(True)
-                messagebox(text=f'{str(error)}\nQuitting the application...',
-                           title='Incompatibility')
+                messagebox(severity='critical', title="Preset loading error",
+                         text=f"""
+                            <p>Saved preset file is not compatible anymore.</p>
+                            <p>Please recreate the preset at <b>{filename}</b>.</p>
+                 """)
                 logger.exception(str(error))
 
                 self.quit_fun()
@@ -1607,7 +1671,6 @@ class DashBoard(CustomApp):
             
             packages_data = np.array(list(zip(packages, current_versions, available_versions)))[new_versions]
 
-            #TODO: Remove `or True`
             if len(packages_data) > 0:
                 #Create a QDialog window and different graphical components
                 dialog = QtWidgets.QDialog()

pymodaq/examples/qt_less_standalone_module.py

@@ -13,11 +13,14 @@ For remote control, you need to start a Coordinator, as described for remote con
 
 import logging
 from time import sleep
-from typing import List, Union
+from typing import cast, List, Optional
 
 from pyleco.utils.listener import Listener
 
 
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.factory import SerializableFactory
+
 class QtLessModule:
     """Some module doing things without Qt.
     
@@ -33,6 +36,9 @@ class QtLessModule:
         self._fake_position = 0
         self.start_listen()
         self._stored = []
+        # register DataWithAxes for deserialization
+        cls = DataWithAxes
+        SerializableFactory().register_from_type(cls, cls.serialize, cls.deserialize)
 
     def start_listen(self) -> None:
         """Start to listen on incoming commands."""
@@ -45,8 +51,9 @@ class QtLessModule:
         register_rpc_method = self.communicator.register_rpc_method
         register_rpc_method(self.set_info)
         register_rpc_method(self.send_data)
-        register_rpc_method(self.move_abs)
-        register_rpc_method(self.move_rel)
+        # binary methods can accept additionally binary payload, like serialized pymodaq objects.
+        self.listener.register_binary_rpc_method(self.move_abs, accept_binary_input=True)
+        self.listener.register_binary_rpc_method(self.move_rel, accept_binary_input=True)
         register_rpc_method(self.move_home)
         register_rpc_method(self.get_actuator_value)
         register_rpc_method(self.stop_motion)
@@ -56,7 +63,17 @@ class QtLessModule:
         """Stop to listen on incoming commands."""
         self.listener.stop_listen()
 
-    # smethods for being remote controlled
+    @staticmethod
+    def extract_pymodaq_object(
+        value: Optional[float], additional_payload: Optional[List[bytes]]
+    ):
+        if value is None and additional_payload:
+            res = cast(DataWithAxes, SerializableFactory().get_apply_deserializer(additional_payload[0]))
+        else:
+            res = value
+        return res
+
+    # methods for being remote controlled
     # these methods are executed and cannot talk to the controlling module directly.
     # if you need to send a response (for example with a value) you have to store the information and
     # send it after these methods have been executed.
@@ -73,13 +90,33 @@ class QtLessModule:
         print("send_data")
 
     # actuator commands
-    def move_abs(self, position: Union[float, str]) -> None:
-        print("move_abs", position)
-        self._fake_position = float(position)
-
-    def move_rel(self, position: Union[float, str]) -> None:
-        print("move_rel", position)
-        self._fake_position += float(position)
+    def move_abs(
+        self,
+        position: Optional[float],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move to an absolute position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        print("move_abs", pos)
+        self._fake_position = float(pos)
+
+    def move_rel(
+        self,
+        position: Optional[float],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move by a relative position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        print("move_rel", pos)
+        self._fake_position += float(pos)
 
     def move_home(self) -> None:
         self._fake_position = 0

pymodaq/extensions/__init__.py

@@ -11,10 +11,14 @@ from .console import QtConsole
 from .daq_scan import DAQScan
 from .daq_logger.daq_logger import DAQ_Logger
 from .pid.pid_controller import DAQ_PID
-from .h5browser import H5Browser
+from .h5browser import H5Browser  #backcompat but should be loaded from pymodaq_gui!
+
+from .bayesian.bayesian_optimization import BayesianOptimization
+from .bayesian.utils import OptimizerModelDefault
+
+from .adaptive.adaptive_optimization import AdaptiveOptimisation
+
 
-from .bayesian.bayesian_optimisation import BayesianOptimisation
-from .bayesian.utils import BayesianModelDefault, BayesianModelGeneric
 
 
 

pymodaq/extensions/adaptive/__init__.py

@@ -0,0 +1,2 @@
+from . import adaptive_optimization
+from . import utils

pymodaq/extensions/adaptive/adaptive_optimization.py

@@ -0,0 +1,159 @@
+
+from pymodaq_utils import utils
+from pymodaq_utils import config as config_mod
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import ThreadCommand
+
+from pymodaq.extensions.optimizers_base.optimizer import (
+    GenericOptimization, OptimizationRunner, optimizer_params)
+from pymodaq.extensions.optimizers_base.utils import OptimizerModelDefault, find_key_in_nested_dict
+from pymodaq.extensions.optimizers_base.thread_commands import OptimizerToRunner
+
+from pymodaq.extensions.adaptive.loss_function import LossFunctionFactory,LossDim
+from pymodaq.extensions.adaptive.utils import AdaptiveAlgorithm, AdaptiveConfig
+
+
+logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
+
+
+EXTENSION_NAME = 'AdaptiveScan'
+CLASS_NAME = 'AdaptiveOptimization'
+
+STARTING_LOSS_DIM = LossDim.LOSS_1D
+
+PREDICTION_NAMES = list(LossFunctionFactory.keys(STARTING_LOSS_DIM))
+PREDICTION_PARAMS = (
+        [{'title': 'LossDim', 'name': 'lossdim', 'type': 'str',
+          'value': LossDim.LOSS_1D, 'readonly': True},
+         {'title': 'Kind', 'name': 'kind', 'type': 'list',
+          'value': PREDICTION_NAMES[0],
+          'limits': PREDICTION_NAMES}] +
+        LossFunctionFactory.get(STARTING_LOSS_DIM,
+                                PREDICTION_NAMES[0]).params)
+
+
+class AdaptiveOptimizationRunner(OptimizationRunner):
+
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def queue_command(self, command: ThreadCommand):
+        """
+        """
+        if command.command == OptimizerToRunner.PREDICTION:
+            utility_params = {k: v for k, v in command.attribute.items()
+                              if k not in ("kind", "tradeoff_actual", 'lossdim')}
+
+            self.optimization_algorithm.set_prediction_function(command.attribute['lossdim'],
+                                                                command.attribute['kind'],
+                                                                **utility_params)
+        else:
+            super().queue_command(command)
+
+
+class AdaptiveOptimisation(GenericOptimization):
+    """ PyMoDAQ extension of the DashBoard to perform the optimization of a target signal
+    taken form the detectors as a function of one or more parameters controlled by the actuators.
+    """
+
+    runner = AdaptiveOptimizationRunner
+    params = optimizer_params(PREDICTION_PARAMS)
+    config_saver = AdaptiveConfig
+
+    DISPLAY_BEST = False
+
+    def ini_custom_attributes(self):
+        """ Here you can reimplement specific attributes"""
+        self._base_name: str = 'Adaptive'
+        self.settings.child('main_settings', 'ini_random').hide()
+
+    def validate_config(self) -> bool:
+        utility = find_key_in_nested_dict(self.optimizer_config.to_dict(), 'prediction')
+        if utility:
+            try:
+                utility_params = { k : v for k, v in utility.items() \
+                                   if k not in ("kind", "tradeoff_actual", 'lossdim') }
+                LossFunctionFactory.create(utility['lossdim'],
+                                           utility['kind'], **utility_params)
+            except (ValueError, KeyError):
+                return False
+
+        return True
+
+    def value_changed(self, param):
+        """ to be subclassed for actions to perform when one of the param's value in self.settings is changed
+
+        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
+        """
+        super().value_changed(param)
+        if param.name() == 'lossdim':
+            self.settings.child('main_settings', 'prediction', 'kind').setLimits(
+                LossFunctionFactory.keys(param.value())
+            )
+
+        elif param.name() == 'kind':
+            utility_settings = self.settings.child('main_settings', 'prediction')
+            old_children = utility_settings.children()[2:]
+            for child in old_children:
+                utility_settings.removeChild(child)
+            try:
+                params = LossFunctionFactory.get(utility_settings['lossdim'],
+                                                 param.value()).params
+                utility_settings.addChildren(params)
+            except (KeyError, ValueError):
+                pass
+
+    def update_prediction_function(self):
+        utility_settings = self.settings.child('main_settings', 'prediction')
+        try:
+            uparams = {child.name() : child.value() for child in utility_settings.children()}
+            LossFunctionFactory.get(uparams['lossdim'], uparams['kind'])
+            self.command_runner.emit(
+                utils.ThreadCommand(OptimizerToRunner.PREDICTION, uparams))
+        except (KeyError, ValueError):
+            pass
+
+    def update_after_actuators_changed(self, actuators: list[str]):
+        """ Actions to do after the actuators have been updated
+        """
+        self.settings.child('main_settings', 'prediction',
+                            'lossdim').setValue(LossDim.get_enum_from_dim_as_int(len(actuators)))
+        self.update_prediction_function()
+
+    def adaptive_bounds(self):
+        return list(self.format_bounds().values())
+
+    def set_algorithm(self):
+        self.algorithm = AdaptiveAlgorithm(
+            ini_random=1,
+            bounds=self.adaptive_bounds(),
+            loss_type=LossDim(self.settings['main_settings', 'prediction', 'lossdim']),
+            kind=self.settings['main_settings', 'prediction', 'kind'])
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('Adaptive Optimiser')
+    preset_file_name = config('presets', f'default_preset_for_scan')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'AdaptiveScan')
+
+    app.exec()
+
+    return dashboard, extension, win
+
+if __name__ == '__main__':
+    main()
+

pymodaq/extensions/adaptive/loss_function/_1d_loss_functions.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Callable
+
+from .loss_factory import LossFunctionBase, LossFunctionFactory, LossDim
+
+from adaptive.learner.learner1D import (
+    curvature_loss_function,
+    default_loss,
+    uniform_loss,
+    resolution_loss_function,
+    abs_min_log_loss,
+    uses_nth_neighbors,
+
+)
+
+
+def default_loss_function(*args, **kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return default_loss
+
+
+def uniform_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return uniform_loss
+
+
+def abs_min_log_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return abs_min_log_loss
+
+
+
+@LossFunctionFactory.register()
+class DefaultLoss(LossFunctionBase):
+    _loss = staticmethod(default_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Default'
+    params = []
+
+
+@LossFunctionFactory.register()
+class UniformLoss(LossFunctionBase):
+    _loss = staticmethod(uniform_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Uniform'
+    params = []
+
+
+@LossFunctionFactory.register()
+class CurvatureLoss(LossFunctionBase):
+    _loss = staticmethod(curvature_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Curvature'
+    params = [
+        {'title': 'Area', 'name': 'area_factor', 'type': 'float', 'value': 1.},
+        {'title': 'Euclid', 'name': 'euclid_factor', 'type': 'float', 'value': 0.02},
+        {'title': 'Horizontal', 'name': 'horizontal_factor', 'type': 'float', 'value': 0.02}
+    ]
+
+
+@LossFunctionFactory.register()
+class ResolutionLoss(LossFunctionBase):
+    _loss = staticmethod(resolution_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Resolution'
+    params = [
+        {'title': 'Min:', 'name': 'min_length', 'type': 'float', 'value': 0., 'min': 0., 'max': 1.},
+        {'title': 'Max:', 'name': 'max_length', 'type': 'float', 'value': 1., 'min': 0., 'max': 1.},
+    ]
+
+
+@LossFunctionFactory.register()
+class AbsMinLogLoss(LossFunctionBase):
+    _loss = staticmethod(abs_min_log_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'AbsMinLog'
+    params = []

pymodaq/extensions/adaptive/loss_function/_2d_loss_functions.py

@@ -0,0 +1,86 @@
+from typing import TYPE_CHECKING, Callable
+
+from .loss_factory import LossFunctionBase, LossFunctionFactory, LossDim
+
+from adaptive.learner.learner2D import (
+    default_loss,
+    uniform_loss,
+    resolution_loss_function,
+    minimize_triangle_surface_loss,
+    thresholded_loss_function,
+    triangle_loss,
+
+)
+
+
+def default_loss_function(*args, **kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return default_loss
+
+
+def uniform_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return uniform_loss
+
+
+def triangle_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return triangle_loss
+
+
+def minimize_triangle_surface_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return minimize_triangle_surface_loss
+
+
+@LossFunctionFactory.register()
+class DefaultLoss(LossFunctionBase):
+    _loss = staticmethod(default_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Default'
+    params = []
+
+
+@LossFunctionFactory.register()
+class UniformLoss(LossFunctionBase):
+    _loss = staticmethod(uniform_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Uniform'
+    params = []
+
+
+
+@LossFunctionFactory.register()
+class ResolutionLoss(LossFunctionBase):
+    _loss = staticmethod(resolution_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Resolution'
+    params = [
+        {'title': 'Min:', 'name': 'min_distance', 'type': 'float', 'value': 0., 'min': 0., 'max': 1.},
+        {'title': 'Max:', 'name': 'max_distance', 'type': 'float', 'value': 1., 'min': 0., 'max': 1.},
+    ]
+
+
+@LossFunctionFactory.register()
+class MinTriangleLoss(LossFunctionBase):
+    _loss = staticmethod(minimize_triangle_surface_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'MinTriangle'
+    params = []
+
+
+
+@LossFunctionFactory.register()
+class ThresholdLoss(LossFunctionBase):
+    _loss = staticmethod(thresholded_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Threshold'
+    params = [
+        {'title': 'Lower:', 'name': 'lower_threshold', 'type': 'float', 'value': None,},
+        {'title': 'Upper:', 'name': 'upper_threshold', 'type': 'float', 'value': None,},
+        {'title': 'Priority factor:', 'name': 'priority_factor', 'type': 'float', 'value': 0.1,},
+    ]
+
+
+@LossFunctionFactory.register()
+class TriangleLoss(LossFunctionBase):
+    _loss = staticmethod(triangle_loss)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Triangle'
+    params = []

pymodaq/extensions/adaptive/loss_function/__init__.py

@@ -0,0 +1,3 @@
+from .loss_factory import LossFunctionFactory, LossDim
+from . import _1d_loss_functions  # to register inner class
+from . import _2d_loss_functions  # to register inner class