pymodaq_plugins_beam_shaping 5.2.0__tar.gz → 5.3.0__tar.gz

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymodaq_plugins_beam_shaping
-Version: 5.2.0
+Version: 5.3.0
 Summary: PyMoDAQ's extension plugin to run optical shaping from various shapers (focusing on amplitude and phase shaping) and the image propagation
 Project-URL: Homepage, https://pymodaq.cnrs.fr
 Project-URL: Documentation , https://pymodaq.cnrs.fr
@@ -42,11 +42,13 @@ Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: opencv-python
 Requires-Dist: pyfftw
-Requires-Dist: pymodaq-gui>5.0.11
-Requires-Dist: pymodaq>5.2.8
+Requires-Dist: pymodaq-data<5.4,>=5.3.0
+Requires-Dist: pymodaq-gui<5.4,>=5.3.0
+Requires-Dist: pymodaq-utils<5.4,>=5.3.1
+Requires-Dist: pymodaq<5.4,>=5.3.2
 Requires-Dist: scikit-image
 Requires-Dist: zernpy
 Provides-Extra: pytorch
@@ -58,16 +60,16 @@ pymodaq_plugins_optical_2D_shaping
 
 .. the following must be adapted to your developped package, links to pypi, github  description...
 
-.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_optical_2D_shaping.svg
-   :target: https://pypi.org/project/pymodaq_plugins_optical_2D_shaping/
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_beam_shaping.svg
+   :target: https://pypi.org/project/pymodaq_plugins_beam_shaping/
    :alt: Latest Version
 
 .. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
    :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
    :alt: Documentation Status
 
-.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_optical_2D_shaping/workflows/Upload%20Python%20Package/badge.svg
-   :target: https://github.com/PyMoDAQ/pymodaq_plugins_optical_2D_shaping
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping/workflows/Upload%20Python%20Package/badge.svg
+   :target: https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping
    :alt: Publication Status
 
 PyMoDAQ's extension plugin to run optical shaping amplitude and/or phase algorithms and propagation algorithms

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/README.rst

@@ -3,16 +3,16 @@ pymodaq_plugins_optical_2D_shaping
 
 .. the following must be adapted to your developped package, links to pypi, github  description...
 
-.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_optical_2D_shaping.svg
-   :target: https://pypi.org/project/pymodaq_plugins_optical_2D_shaping/
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_beam_shaping.svg
+   :target: https://pypi.org/project/pymodaq_plugins_beam_shaping/
    :alt: Latest Version
 
 .. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
    :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
    :alt: Documentation Status
 
-.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_optical_2D_shaping/workflows/Upload%20Python%20Package/badge.svg
-   :target: https://github.com/PyMoDAQ/pymodaq_plugins_optical_2D_shaping
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping/workflows/Upload%20Python%20Package/badge.svg
+   :target: https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping
    :alt: Publication Status
 
 PyMoDAQ's extension plugin to run optical shaping amplitude and/or phase algorithms and propagation algorithms

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/pyproject.toml

@@ -12,11 +12,13 @@ package-url = 'https://github.com/IumiShaping/pymodaq_plugins_optical_2D_shaping
 name = "pymodaq_plugins_beam_shaping"
 description = "PyMoDAQ's extension plugin to run optical shaping from various shapers (focusing on amplitude and phase shaping) and the image propagation"
 dependencies = [
-    "pymodaq>5.2.8",
+    "pymodaq>=5.3.2,<5.4",
+    "pymodaq_utils>=5.3.1,<5.4",
+    "pymodaq_gui>=5.3.0,<5.4",
+    "pymodaq_data>=5.3.0,<5.4",
     'pyfftw',
     'scikit-image',
     'opencv-python',
-    'pymodaq_gui>5.0.11',
     'zernpy',
 ]
 
@@ -34,7 +36,7 @@ maintainers = [
 dynamic = ["version", "urls", "entry-points"]
 readme = "README.rst"
 license = { file="LICENSE" }
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -64,7 +66,7 @@ pytorch = [
 requires = [
     "hatchling>=1.9.0",
     "hatch-vcs", "toml",
-    "pymodaq_utils>=0.0.6",
+    "pymodaq_utils>=5.3.6",
 ]
 build-backend = "hatchling.build"
 

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/algorithms/algorithm_app.py

@@ -39,7 +39,7 @@ from pymodaq_plugins_beam_shaping import config as plugin_config
 from pymodaq_plugins_beam_shaping.algorithms.algo_config import AlgoConfig
 from pymodaq_plugins_beam_shaping.utilities.h5saving import ShapingSaver
 
-from pymodaq_plugins_beam_shaping.utilities import sizing
+from pymodaq_plugins_beam_shaping.utilities import sizing, regions
 
 algo_factory = AlgorithmFactory()
 phase_factory = PhaseFactory()
@@ -96,16 +96,14 @@ class AlgoApp(CustomApp):
             {'title': 'Apply Mask', 'name': 'apply_mask', 'type': 'bool', 'value': False},
             {'title': 'Mask Type', 'name': 'mask_type', 'type': 'list', 'value': str(MaskType.SQUARE),
              'limits': MaskType.names()},
-            {'title': 'Slices', 'name': 'slices', 'type': 'str',
-             'value': '(slice(277, 1770, None), slice(252, 1795, None))'},
+            {'title': 'Slices (um):', 'name': 'slices', 'type': 'str', 'value': ''},
         ]},
         {'title': 'Intermediate Masking', 'name': str(ApplyMaskTo.INTERMEDIATE), 'type': 'group',
          'visible': False, 'children': [
             {'title': 'Apply Mask', 'name': 'apply_mask', 'type': 'bool', 'value': False},
             {'title': 'Mask Type', 'name': 'mask_type', 'type': 'list', 'value': str(MaskType.ELLIPTICAL),
              'limits': MaskType.names()},
-            {'title': 'Slices', 'name': 'slices', 'type': 'str',
-             'value': '(slice(162, 882, None), slice(545, 1825, None))'},
+            {'title': 'Slices (um):', 'name': 'slices', 'type': 'str', 'value': ''},
         ]}
     ]
 
@@ -145,10 +143,18 @@ class AlgoApp(CustomApp):
                  'visible': self.settings['stopping', 'stopping_type'] == stop,
                  'children': stopping_factory.get_stop_class(stop).params})
 
-        self.module_and_data_saver: ShapingSaver = None
+        self._module_and_data_saver: ShapingSaver = None
         self._h5saver: H5Saver = None
 
 
+    @property
+    def module_and_data_saver(self) -> ShapingSaver:
+        return self._module_and_data_saver
+
+    @module_and_data_saver.setter
+    def module_and_data_saver(self, saver: ShapingSaver):
+        self._module_and_data_saver = saver
+
     @property
     def h5saver(self) -> H5Saver:
         if self._h5saver is None:
@@ -268,6 +274,7 @@ class AlgoApp(CustomApp):
             self._algorithm.set_target_field(field)
 
         self._target_field = field
+        self.check_slices()
 
     def set_input_field(self, field: Field):
 
@@ -328,7 +335,7 @@ class AlgoApp(CustomApp):
 
             self.config_saver_loader.base_path = [self._algorithm.ALGO_NAME]
             self.set_settings_values()
-            self.update_target_slices(eval(self.settings[str(ApplyMaskTo.TARGET), 'slices']))
+            self.check_slices()
 
             self.algo_changed.emit(self._algorithm)
 
@@ -357,7 +364,7 @@ class AlgoApp(CustomApp):
         if self.is_action_checked('ini_algo'):
             self.get_action('algorithms').widget.setEnabled(False)
             #self.set_action_enabled('ini_algo', False)
-            #self.set_algorithm()
+            self.set_algorithm()
 
             self.runner_thread = QtCore.QThread()
             runner = AlgoRunner(self._algorithm)
@@ -402,7 +409,7 @@ class AlgoApp(CustomApp):
         self.settings_widget = QtWidgets.QWidget()
         self.settings_widget.setLayout(QtWidgets.QVBoxLayout())
         self.settings_widget.layout().setContentsMargins(0, 0, 0, 0)
-        splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
         self.settings_widget.layout().addWidget(splitter)
         splitter.addWidget(self.settings_tree)
 
@@ -521,14 +528,27 @@ class AlgoApp(CustomApp):
     def apply_mask(self, apply_to: ApplyMaskTo) -> bool:
         return self.settings[str(apply_to), 'apply_mask']
 
+    def get_plane_pixel_sizes(self, apply_to: ApplyMaskTo) -> Union[None, tuple]:
+        """ Pixel sizes of the plane the mask applies to, None if not (yet) defined"""
+        try:
+            if str(apply_to) == str(ApplyMaskTo.INTERMEDIATE):
+                return self._algorithm.intermediate_pixel_sizes
+            return self._target_field.pixels_sizes
+        except (AttributeError, ValueError, TypeError):
+            return None
+
+    def get_mask_region(self, apply_to: ApplyMaskTo) -> Union[None, tuple[slice, slice]]:
+        """ Get the mask region as slices in real units (um), None if not defined"""
+        return regions.parse_slices(self.settings[str(apply_to), 'slices'])
+
     def get_mask_as_slices(self, apply_to: ApplyMaskTo) -> Union[None, tuple[slice, slice]]:
+        """ Get the mask region as slices of indexes to be used on the arrays of the corresponding plane"""
         if self.apply_mask(apply_to):
-            slices = eval(self.settings[str(apply_to), 'slices'])
-            if hasattr(slices, '__iter__'):
-                for _slice in slices:
-                    if not isinstance(_slice, slice):
-                        return None
-            return slices
+            region = self.get_mask_region(apply_to)
+            pixel_sizes = self.get_plane_pixel_sizes(apply_to)
+            if region is None or pixel_sizes is None:
+                return None
+            return regions.slices_to_indexes(region, pixel_sizes, sizing.get_effective_needed_field_size())
         else:
             return None
 
@@ -536,23 +556,31 @@ class AlgoApp(CustomApp):
         return MaskType[self.settings[str(apply_to), 'mask_type']]
 
     def update_intermediate_slices(self, slices: tuple[slice, slice]):
-        self.settings.child(str(ApplyMaskTo.INTERMEDIATE), 'slices').setValue(str(slices))
+        self.update_slices(ApplyMaskTo.INTERMEDIATE, slices)
 
     def update_target_slices(self, slices: tuple[slice, slice]):
-        slices = self.constrains_slices(slices)
-        self.settings.child(str(ApplyMaskTo.TARGET), 'slices').setValue(str(slices))
-
-    @staticmethod
-    def constrains_slices(slices: tuple[slice, slice]) -> tuple[slice, slice]:
-        position, size = sizing.get_effective_area_pos_size_in_pxls()
-        slices = (slice(int(max(slices[0].start, position[0])), int(min(slices[0].stop, position[0] + size[0]))),
-                  slice(int(max(slices[1].start, position[1])), int(min(slices[1].stop, position[1] + size[1])))
-                  )
-        return slices
+        self.update_slices(ApplyMaskTo.TARGET, slices)
+
+    def update_slices(self, apply_to: ApplyMaskTo, slices: tuple[slice, slice]):
+        """ Set the mask region (slices in m) constrained to the effective area of the plane"""
+        pixel_sizes = self.get_plane_pixel_sizes(apply_to)
+        if pixel_sizes is not None:
+            slices = regions.constrain_slices(slices, pixel_sizes)
+        self.settings.child(str(apply_to), 'slices').setValue(regions.slices_to_str(slices))
+
+    def check_slices(self):
+        """ Set the default region (2/3 of the effective area, centered) if the current one is not valid"""
+        for apply_to in (ApplyMaskTo.TARGET, ApplyMaskTo.INTERMEDIATE):
+            pixel_sizes = self.get_plane_pixel_sizes(apply_to)
+            if pixel_sizes is None:
+                continue
+            region = self.get_mask_region(apply_to)
+            if region is None or not regions.are_slices_in_area(region, pixel_sizes):
+                self.update_slices(apply_to, regions.default_slices(pixel_sizes))
 
     def value_changed(self, param: Parameter):
         for applied in ApplyMaskTo.values():
-            if applied in putils.get_param_path(param):
+            if applied in putils.get_param_path(param) and self._algorithm is not None:
                self._algorithm.update_mask = True
         if param.name() == 'ini_phase_factory':
             for param_child in self.settings.child('ini_phase_group', 'phase_params').children():

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/daq_move_plugins/daq_move_FocalLength.py

@@ -26,10 +26,10 @@ class DAQ_Move_FocalLength(DAQ_Move_base):
     is_multiaxes = False
     _axis_names: Union[List[str], Dict[str, int]] = ['Focal']
     _controller_units: Union[str, List[str]] = 'cm'
-    _epsilon: Union[float, List[float]] = 0.1
+    _epsilons: Union[float, List[float]] = 0.1
     data_actuator_type = DataActuatorType.DataActuator
 
-    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilon)
+    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilons)
 
     def ini_attributes(self):
         self.controller: 'Correction' = None
@@ -84,8 +84,8 @@ class DAQ_Move_FocalLength(DAQ_Move_base):
         ----------
         value: (float) value of the relative target positioning
         """
-        value = self.check_bound(self.current_position + value) - self.current_position
-        self.target_value = value + self.current_position
+        value = self.check_bound(self.current_value + value) - self.current_value
+        self.target_value = value + self.current_value
         value = self.set_position_relative_with_scaling(value)
 
         self.move_abs(self.target_value)

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/daq_move_plugins/daq_move_MockAutoFocus.py

@@ -25,10 +25,10 @@ class DAQ_Move_MockAutoFocus(DAQ_Move_base):
     is_multiaxes = False
     _axis_names: Union[List[str], Dict[str, int]] = ['Focus']
     _controller_units: Union[str, List[str]] = ''
-    _epsilon: Union[float, List[float]] = 0.1
+    _epsilons: Union[float, List[float]] = 0.1
     data_actuator_type = DataActuatorType.DataActuator
 
-    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilon)
+    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilons)
 
     def ini_attributes(self):
         self.controller: Optional[Autofocus] = None
@@ -86,8 +86,8 @@ class DAQ_Move_MockAutoFocus(DAQ_Move_base):
         ----------
         value: (float) value of the relative target positioning
         """
-        value = self.check_bound(self.current_position + value) - self.current_position
-        self.target_value = value + self.current_position
+        value = self.check_bound(self.current_value + value) - self.current_value
+        self.target_value = value + self.current_value
         value = self.set_position_relative_with_scaling(value)
 
         self.move_abs(self.target_value)

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/daq_move_plugins/daq_move_MockShaper.py

@@ -29,10 +29,10 @@ class DAQ_Move_MockShaper(DAQ_Move_base):
     is_multiaxes = False
     _axis_names: Union[List[str], Dict[str, int]] = ['']
     _controller_units: Union[str, List[str]] = ''
-    _epsilon: Union[float, List[float]] = 0.1
+    _epsilons: Union[float, List[float]] = 0.1
     data_actuator_type = DataActuatorType.DataActuator
 
-    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilon)
+    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilons)
 
 
     def ini_attributes(self):
@@ -116,8 +116,8 @@ class DAQ_Move_MockShaper(DAQ_Move_base):
         ----------
         value: (float) value of the relative target positioning
         """
-        value = self.check_bound(self.current_position + value) - self.current_position
-        self.target_value = value + self.current_position
+        value = self.check_bound(self.current_value + value) - self.current_value
+        self.target_value = value + self.current_value
         value = self.set_position_relative_with_scaling(value)
 
         self.move_abs(self.target_value)

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/daq_move_plugins/daq_move_Zernike.py

@@ -33,10 +33,10 @@ class DAQ_Move_Zernike(DAQ_Move_base):
         for m in range(-n, n+2, 2):
             _axis_names.append(f'{n}{m}')
     _controller_units: Union[str, List[str]] = ''
-    _epsilon: Union[float, List[float]] = 0.1
+    _epsilons: Union[float, List[float]] = 0.1
     data_actuator_type = DataActuatorType.DataActuator
 
-    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilon)
+    params = [] + comon_parameters_fun(is_multiaxes, axis_names=_axis_names, epsilon=_epsilons)
 
     def ini_attributes(self):
         self.controller: 'Correction' = None
@@ -94,8 +94,8 @@ class DAQ_Move_Zernike(DAQ_Move_base):
         ----------
         value: (float) value of the relative target positioning
         """
-        value = self.check_bound(self.current_position + value) - self.current_position
-        self.target_value = value + self.current_position
+        value = self.check_bound(self.current_value + value) - self.current_value
+        self.target_value = value + self.current_value
         value = self.set_position_relative_with_scaling(value)
 
         self.move_abs(self.target_value)

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/extensions/spatial_beam_shaping.py

@@ -19,7 +19,7 @@ from pymodaq_gui import utils as gutils
 from pymodaq_gui.utils.layout import save_layout_state, load_layout_state
 from pymodaq_gui.parameter.ioxml import  xml_string_to_parameter
 
-from pymodaq.extensions.custom_ext import CustomExt
+from pymodaq.utils.custom_ext import CustomExt
 from pymodaq.utils.gui_utils.loader_utils import create_extension
 from pymodaq.utils.data import DataToExport, DataCalculated, DataDim
 
@@ -30,6 +30,7 @@ from pymodaq_plugins_beam_shaping.utilities.corrections import Correction
 from pymodaq_plugins_beam_shaping.algorithms import AlgorithmFactory, AlgoBase
 from pymodaq_plugins_beam_shaping.utilities import sizing
 from pymodaq_plugins_beam_shaping.algorithms.utils import ApplyMaskTo, LensSetup
+from pymodaq_plugins_beam_shaping.utilities import regions
 from pymodaq_plugins_beam_shaping.utilities.calibrating import BeamShapingCalibration, Calibration
 from pymodaq_plugins_beam_shaping.utilities.data import DataShaper
 from pymodaq_plugins_beam_shaping.utilities.shaper import Shaper, ModulatorType, get_shaper
@@ -474,6 +475,7 @@ class BeamShaping(CustomExt):
 
     def update_ui_from_algo(self, algo: AlgoBase):
         self.set_action_visible('show_intermediate', algo.SETUP_TYPE == LensSetup.FourF)
+        self.show_set_target_roi_select()
 
     def plot_target(self, field: Field):
         self.target_viewers.show_data(DataToExport('Target', data=[
@@ -509,15 +511,16 @@ class BeamShaping(CustomExt):
         self._algorithm.modulator_field_signal.connect(self.update_modulator_field)
         self._input_field_loader.field_signal.connect(self._algorithm.set_input_field)
         self._target_field_loader.field_signal.connect(self._algorithm.set_target_field)
+        self._target_field_loader.field_signal.connect(lambda field: self.show_set_target_roi_select())
 
         self.set_menu(self._algorithm.menu)  #adds this to the menu dict (automatically added in the sharedUI)
 
         self.intermediate_viewer.roi_select_signal.connect(
-            lambda roi: self._algorithm.update_intermediate_slices(roi.to_slices()))
+            lambda roi: self._algorithm.update_intermediate_slices(regions.from_axis_units(roi.to_slices(as_integer=False))))
         self.show_set_target_roi_select()
 
         for viewer in (self._target_field_loader.amp_viewer, self._target_field_loader.phase_viewer):
-            viewer.roi_select_signal.connect(lambda roi: self._algorithm.update_target_slices(roi.to_slices()))
+            viewer.roi_select_signal.connect(lambda roi: self._algorithm.update_target_slices(regions.from_axis_units(roi.to_slices(as_integer=False))))
 
         if layout_path.joinpath('shaping.dock').is_file():
             try:
@@ -529,13 +532,15 @@ class BeamShaping(CustomExt):
 
 
     def show_set_target_roi_select(self):
-        slices = self._algorithm.constrains_slices(eval(self._algorithm.settings[ApplyMaskTo.TARGET, 'slices']))
-        self._target_field_loader.amp_viewer.view.set_action_checked('ROIselect', True)
-        pos = [slices[0].start, slices[1].start]
-        size = [slices[0].stop - slices[0].start, slices[1].stop - slices[0].start]
-        self._target_field_loader.amp_viewer.view.show_ROI_select(
-            size=size[::-1],
-            pos=pos[::-1])
+        slices = self._algorithm.get_mask_region(ApplyMaskTo.TARGET)
+        if slices is None:
+            return
+        slices = regions.to_axis_units(slices)  # the ROI is in the units of the axes
+        view = self._target_field_loader.amp_viewer.view
+        view.set_action_checked('ROIselect', True)
+        view.show_ROI_select()  # position and size are not taken into account by the viewer, set below
+        view.ROIselect.setPos((slices[1].start, slices[0].start))
+        view.ROIselect.setSize((slices[1].stop - slices[1].start, slices[0].stop - slices[0].start))
 
     def connect_things(self):
         logger.debug('connecting things')
@@ -662,24 +667,19 @@ class BeamShaping(CustomExt):
         QtWidgets.QApplication.processEvents()  # allows the dashboard modules to close properly
         return True
 
-    if not hasattr(CustomExt, '_quit_fun'):  # pymodaq < 5.3 only calls quit_fun, pymodaq >= 5.3 calls _quit_fun
-        def quit_fun(self):
-            self._quit_fun()
-            super().quit_fun()
-
 
 def main():
     import sys
     from pymodaq_gui.qt_utils import mkQApp
-    from pymodaq.dashboard import create_load_dashboard
+    from pymodaq.dashboard import load_dashboard_with_arguments
     from pymodaq.utils.gui_utils.loader_utils import create_extension
+
     app = mkQApp('BeamShaping')
 
-    win, dashboard = create_load_dashboard()
+    win, dashboard, _ = load_dashboard_with_arguments(show_dashboard=False, load_extension=False)
     win.mainwindow.setVisible(False)
 
-    win_ext, scan = create_extension(dashboard, BeamShaping)
-    win_ext.show()
+    win_ext, ext = create_extension(dashboard, BeamShaping, show_extension=True)
 
     sys.exit(app.exec())
 

{pymodaq_plugins_beam_shaping-5.2.0 → pymodaq_plugins_beam_shaping-5.3.0}/src/pymodaq_plugins_beam_shaping/field/field_loader_app.py

@@ -4,6 +4,9 @@ import numpy as np
 from qtpy import QtWidgets, QtCore
 from skimage.transform import rescale, resize
 from scipy.ndimage import gaussian_filter
+
+from pymodaq_gui.utils.shared_ui import SharedUI
+from pymodaq_gui.utils.widgets.window import make_window
 from pyqtgraph import ROI as pgROI
 
 from pymodaq_utils.config import GlobalConfig
@@ -23,6 +26,7 @@ from pymodaq_gui.utils.file_io import select_file
 from pymodaq_gui.parameter.ioxml import parameter_to_xml_string
 from pymodaq_plugins_beam_shaping import config as plugin_config
 from pymodaq_plugins_beam_shaping.field import Field, Q_, LoaderFactory, FieldLoader
+from pymodaq_plugins_beam_shaping.utilities import regions
 from pymodaq_plugins_beam_shaping.utilities.masking import MaskType
 
 from pymodaq_plugins_beam_shaping.utilities.sizing import (get_effective_needed_field_size,
@@ -93,8 +97,7 @@ class FieldLoaderApp(CustomApp):
             {'title': 'Masking', 'name': 'masking', 'type': 'group', 'children': [
                 {'title': 'Mask Type', 'name': 'mask_type', 'type': 'list', 'value': str(MaskType.SQUARE),
                  'limits': MaskType.names()},
-                {'title': 'Slices', 'name': 'slices', 'type': 'str',
-                 'value': '(slice(338, 757, None), slice(665, 1770, None))'},
+                {'title': 'Slices (um):', 'name': 'slices', 'type': 'str', 'value': ''},
                 {'title': 'Boundary', 'name': 'boundary', 'type': 'group', 'children': [
                     {'title': 'Apply', 'name': 'apply_boundary', 'type': 'bool', 'value': False},
                     {'title': 'Sharpness', 'name': 'sharpness', 'type': 'int', 'value': 3, }
@@ -147,21 +150,36 @@ class FieldLoaderApp(CustomApp):
         self.settings.child('needed_size', 'pixel_width').setValue(pixel_sizes[1].m_as('um'))
         self.load_field()
 
-    def get_mask_as_slices(self) -> Union[None, tuple[slice, slice]]:
+    def get_pixel_sizes(self) -> tuple[Q_, Q_]:
+        return (Q_(self.settings['needed_size', 'pixel_height'], 'um'),
+                Q_(self.settings['needed_size', 'pixel_width'], 'um'))
+
+    def get_mask_region(self) -> Union[None, tuple[slice, slice]]:
+        """ Get the mask region as slices in real units (um), None if not defined"""
+        return regions.parse_slices(self.settings['utils', 'masking', 'slices'])
 
-        slices = eval(self.settings['utils', 'masking', 'slices'])
-        if hasattr(slices, '__iter__'):
-            for _slice in slices:
-                if not isinstance(_slice, slice):
-                    return None
-        return slices
+    def get_mask_as_slices(self) -> Union[None, tuple[slice, slice]]:
+        """ Get the mask region as slices of indexes to be used on the array of the field"""
+        region = self.get_mask_region()
+        if region is None:
+            return None
+        shape = (self.settings['needed_size', 'height'], self.settings['needed_size', 'width'])
+        return regions.slices_to_indexes(region, self.get_pixel_sizes(), shape)
+
+    def check_mask_region(self):
+        """ Set the default region (2/3 of the effective area, centered) if the current one is not valid"""
+        region = self.get_mask_region()
+        if region is None or not regions.are_slices_in_area(region, self.get_pixel_sizes()):
+            self.settings.child('utils', 'masking', 'slices').setValue(
+                regions.slices_to_str(regions.default_slices(self.get_pixel_sizes())))
 
     def get_mask_type(self) -> MaskType:
         return MaskType[self.settings['utils', 'masking', 'mask_type']]
 
     def update_mask_slices(self):
         if self.mask is not None:
-            self.settings.child('utils', 'masking', 'slices').setValue(str(self.mask.to_info().to_slices()))
+            self.settings.child('utils', 'masking', 'slices').setValue(
+                regions.slices_to_str(regions.from_axis_units(self.mask.to_info().to_slices(as_integer=False))))
 
     def value_changed(self, param: Parameter):
         if param.name() == 'loader':
@@ -192,13 +210,18 @@ class FieldLoaderApp(CustomApp):
                 viewer = self.phase_viewer
             if param.value():
                 viewer.roi_manager.add_roi_programmatically('RectROI')
-                self.mask = viewer.roi_manager.get_roi_from_index(0)
+                roi_meta = viewer.roi_manager.get_roi_from_index(0)  # ROIMeta, the ROI itself is in its roi attribute
+                self.mask = roi_meta.roi
+                self.check_mask_region()
+                region = regions.to_axis_units(self.get_mask_region())  # the ROI is in the units of the axes
+                self.mask.setPos((region[1].start, region[0].start))
+                self.mask.setSize((region[1].stop - region[1].start, region[0].stop - region[0].start))
                 self.mask.sigRegionChangeFinished.connect(self.update_mask_slices)
                 self.update_mask_slices()
-            else:
-                viewer.roi_manager.remove_roi_programmatically(0)
-                self.mask.sigRegionChangeFinished.disconnect()
+            elif self.mask is not None:
+                self.mask.sigRegionChangeFinished.disconnect(self.update_mask_slices)
                 self.mask = None
+                viewer.roi_manager.remove_roi_programmatically(0)
 
         elif param.name() == 'save':
             if param.value():
@@ -258,7 +281,9 @@ class FieldLoaderApp(CustomApp):
 
         slices = (slice(max(0, center[0] - size[0] // 2), min(shape[0], center[0] + size[0] // 2)),
                   slice(max(0, center[1] - size[1] // 2), min(shape[1], center[1] + size[1] // 2)))
-        self.settings.child('utils', 'masking', 'slices').setValue(str(slices))
+        pixel_sizes = regions.pixel_sizes_in_um(self.get_pixel_sizes())
+        self.settings.child('utils', 'masking', 'slices').setValue(regions.slices_to_str(
+            tuple(slice(_slice.start * pxl, _slice.stop * pxl) for _slice, pxl in zip(slices, pixel_sizes))))
         self.settings.child('utils', 'masking', 'apply_mask').setValue(apply)
 
     def updated_slm(self, slm_default_name: str):
@@ -379,7 +404,7 @@ class FieldLoaderApp(CustomApp):
         self.normalise(self.field, NormaliseTo[self.settings['utils', 'normalisation']])
 
         if self.settings['utils', 'masking', 'apply_mask']:
-
+            self.check_mask_region()
             mask = self.get_mask_array()
             self.field.amplitude = self.field.amplitude * mask
             self.field.phase = self.field.phase * mask
@@ -468,12 +493,12 @@ class FieldLoaderApp(CustomApp):
                     **self.loader_kwargs
                 )
 
-            while True:
-                child = self._loader_settings_widget.layout().takeAt(0)
-                if not child:
-                    break
-                child.widget().deleteLater()
-                QtWidgets.QApplication.processEvents()
+            layout = self._loader_settings_widget.layout()
+            while layout.count():
+                widget = layout.takeAt(0).widget()
+                if widget is not None:
+                    widget.setParent(None)
+                    widget.deleteLater()
 
             self._loader_settings_widget.layout().addWidget(self._field_loader.settings_tree)
             self._field_loader.register_listener(self)
@@ -481,7 +506,7 @@ class FieldLoaderApp(CustomApp):
         except ValueError as e:
             pass
 
-    def setup_docks(self):
+    def setup_docks_and_widgets(self):
         self.docks['target'] = Dock('Target')
         self._main_widget = QtWidgets.QWidget()
         self._main_widget.setLayout(QtWidgets.QHBoxLayout())
@@ -493,7 +518,6 @@ class FieldLoaderApp(CustomApp):
 
         amp_widget = QtWidgets.QWidget()
         self.amp_viewer = Viewer2D(amp_widget)
-        self.amp_viewer.view.get_action('legend').trigger()
         self.slm_size_roi_amp = pgROI(pos=(0, 0), size=(20, 20), movable=False, rotatable=False, resizable=False,
                                       pen=(0, 255, 0))
         self.amp_viewer.view.plotitem.addItem(self.slm_size_roi_amp)
@@ -501,7 +525,6 @@ class FieldLoaderApp(CustomApp):
 
         phase_widget = QtWidgets.QWidget()
         self.phase_viewer = Viewer2D(phase_widget)
-        self.phase_viewer.view.get_action('legend').trigger()
         self.slm_size_roi_phase = pgROI(pos=(0, 0), size=(20, 20), movable=False, rotatable=False, resizable=False,
                                         pen=(0, 255, 0))
         self.phase_viewer.view.plotitem.addItem(self.slm_size_roi_phase)
@@ -544,16 +567,12 @@ def main():
     from pymodaq_gui.qt_utils import mkQApp
 
     app = mkQApp('Optical Shaping')
-
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-    win.show()
-
+    win, area = make_window(title='FieldLoaderApp')
+    shared_ui = SharedUI(win)
     optical_app = FieldLoaderApp(area)
 
+    shared_ui.affect_application(optical_app)
+
     app.exec()