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

pymodaq/utils/managers/parameter_manager.py

@@ -0,0 +1,110 @@
+from pathlib import Path
+from typing import List, Union, Dict
+from pymodaq.utils.parameter import Parameter, ParameterTree, ioxml
+
+
+class ParameterManager:
+    """Class dealing with Parameter and ParameterTree
+
+    Attributes
+    ----------
+    params: list of dicts
+        Defining the Parameter tree like structure
+    settings_name: str
+        The particular name to give to the object parent Parameter (self.settings)
+    settings: Parameter
+        The higher level (parent) Parameter
+    settings_tree: ParameterTree
+    """
+    settings_name = 'custom_settings'
+    params = []
+
+    def __init__(self, settings_name: str = None):
+        if settings_name is None:
+            settings_name = self.settings_name
+        # create a settings tree to be shown eventually in a dock
+        self.settings_tree: ParameterTree = ParameterTree()
+        self.settings_tree.setMinimumWidth(150)
+        self.settings_tree.setMinimumHeight(300)
+
+        self.settings: Parameter = Parameter.create(name=settings_name, type='group', children=self.params)  # create a Parameter
+        # object containing the settings defined in the preamble
+
+    @property
+    def settings(self):
+        return self._settings
+
+    @settings.setter
+    def settings(self, settings: Union[Parameter, List[Dict[str, str]], Path]):
+        settings = self.create_parameter(settings)
+        self._settings = settings
+        self.settings_tree.setParameters(self._settings, showTop=False)  # load the tree with this parameter object
+        self._settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
+
+    @staticmethod
+    def create_parameter(settings: Union[Parameter, List[Dict[str, str]], Path]) -> Parameter:
+
+        if isinstance(settings, List):
+            _settings = Parameter.create(title='Settings', name='settings', type='group', children=settings)
+        elif isinstance(settings, Path) or isinstance(settings, str):
+            settings = Path(settings)
+            _settings = Parameter.create(title='Settings', name='settings',
+                                        type='group', children=ioxml.XML_file_to_parameter(str(settings)))
+        elif isinstance(settings, Parameter):
+            _settings = Parameter.create(title='Settings', name=settings.name(), type='group')
+            _settings.restoreState(settings.saveState())
+        else:
+            raise TypeError(f'Cannot create Parameter object from {settings}')
+        return _settings
+
+    def parameter_tree_changed(self, param, changes):
+        for param, change, data in changes:
+            path = self._settings.childPath(param)
+            if change == 'childAdded':
+                self.child_added(param, data)
+
+            elif change == 'value':
+                self.value_changed(param)
+
+            elif change == 'parent':
+                self.param_deleted(param)
+
+    def value_changed(self, param):
+        """Non-mandatory method  to be subclassed for actions to perform (methods to call) when one of the param's
+        value in self._settings is changed
+
+        Parameters
+        ----------
+        param: Parameter
+            the parameter whose value just changed
+
+        Examples
+        --------
+        >>> if param.name() == 'do_something':
+        >>>     if param.value():
+        >>>         print('Do something')
+        >>>         self.settings.child('main_settings', 'something_done').setValue(False)
+        """
+        ...
+
+    def child_added(self, param, data):
+        """Non-mandatory method to be subclassed for actions to perform when a param  has been added in self.settings
+
+        Parameters
+        ----------
+        param: Parameter
+            the parameter where child will be added
+        data: Parameter
+            the child parameter
+        """
+        pass
+
+    def param_deleted(self, param):
+        """Non-mandatory method to be subclassed for actions to perform when one of the param in self.settings has been deleted
+
+        Parameters
+        ----------
+        param: Parameter
+            the parameter that has been deleted
+        """
+        pass

pymodaq/{daq_utils → utils}/managers/preset_manager.py

@@ -1,23 +1,25 @@
-import pymodaq.daq_utils.config
-from pymodaq.daq_utils.gui_utils.file_io import select_file
+from pymodaq.extensions import get_models
+import pymodaq.utils.config
+from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
+from pymodaq.utils.gui_utils.file_io import select_file
 from qtpy import QtWidgets
 import sys
 import os
 from pyqtgraph.parametertree import Parameter, ParameterTree
-from pymodaq.daq_utils.parameter import ioxml
-from pymodaq.daq_utils import daq_utils as utils
+from pymodaq.utils.parameter import ioxml
+from pymodaq.utils import daq_utils as utils
 from pathlib import Path
-import pymodaq.daq_utils.managers.preset_manager_utils  # to register move and det types
+import pymodaq.utils.managers.preset_manager_utils  # to register move and det types
 
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 # check if preset_mode directory exists on the drive
-pid_path = pymodaq.daq_utils.config.get_set_pid_path()
-preset_path = pymodaq.daq_utils.config.get_set_preset_path()
-overshoot_path = pymodaq.daq_utils.config.get_set_overshoot_path()
-layout_path = pymodaq.daq_utils.config.get_set_layout_path()
+pid_path = pymodaq.utils.config.get_set_pid_path()
+preset_path = pymodaq.utils.config.get_set_preset_path()
+overshoot_path = pymodaq.utils.config.get_set_overshoot_path()
+layout_path = pymodaq.utils.config.get_set_layout_path()
 
-pid_models = [mod['name'] for mod in utils.get_models()]
+pid_models = [mod['name'] for mod in get_models()]
 
 
 class PresetManager:
@@ -67,7 +69,7 @@ class PresetManager:
 
     def get_set_pid_model_params(self, model_file):
         self.preset_params.child('model_settings').clearChildren()
-        model = utils.get_models(model_file)
+        model = get_models(model_file)
         if model is not None:
             params = model['class'].params
             self.preset_params.child('model_settings').addChildren(params)
@@ -117,7 +119,7 @@ class PresetManager:
         for param, change, data in changes:
             path = self.preset_params.childPath(param)
             if change == 'childAdded':
-                pass
+                data[0].child('params', 'main_settings', 'module_name').setValue(data[0].child('name').value())
 
             elif change == 'value':
 
@@ -126,6 +128,8 @@ class PresetManager:
                     self.preset_params.child('model_settings').show(param.value())
                 if param.name() == 'pid_models' and param.value() != '':
                     self.get_set_pid_model_params(param.value())
+                if param.name() == 'name':
+                    param.parent().child('params', 'main_settings', 'module_name').setValue(param.value())
 
             elif change == 'parent':
                 pass

pymodaq/{daq_utils → utils}/managers/preset_manager_utils.py

@@ -1,11 +1,13 @@
 import random
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_move.utility_classes import params as daq_move_params
-from pymodaq.daq_viewer.utility_classes import params as daq_viewer_params
+
+from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
+from pymodaq.utils import daq_utils as utils
+from pymodaq.control_modules.move_utility_classes import params as daq_move_params
+from pymodaq.control_modules.viewer_utility_classes import params as daq_viewer_params
 
 from pyqtgraph.parametertree.Parameter import registerParameterType
 from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 DAQ_Move_Stage_type = utils.get_plugins('daq_move')
 DAQ_0DViewer_Det_types = utils.get_plugins('daq_0Dviewer')
@@ -177,10 +179,9 @@ class PresetScalableGroupDet(GroupParameter):
 
             for main_child in params:
                 if main_child['name'] == 'detector_settings':
-                    while len(main_child['children']) != 1:
+                    while len(main_child['children']) > 0:
                         for child in main_child['children']:
-                            if child['name'] != 'ROIselect':
-                                main_child['children'].remove(child)
+                            main_child['children'].remove(child)
 
                     main_child['children'].extend(params_hardware)
 

pymodaq/{daq_utils → utils}/managers/remote_manager.py

@@ -1,18 +1,19 @@
 import os
 import sys
 
-import pymodaq.daq_utils.config
+import pymodaq.utils.config
 from qtpy.QtCore import QObject, Signal
 from qtpy import QtGui, QtWidgets
 
-from pymodaq.daq_utils.parameter import ioxml
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.gui_utils import select_file
+from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
+from pymodaq.utils.parameter import ioxml
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.gui_utils import select_file
 from pyqtgraph.parametertree import Parameter, ParameterTree, registerParameterType
 from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
 
-logger = utils.set_logger(utils.get_module_name(__file__))
-remote_path = pymodaq.daq_utils.config.get_set_remote_path()
+logger = set_logger(get_module_name(__file__))
+remote_path = pymodaq.utils.config.get_set_remote_path()
 remote_types = ['ShortCut', 'Joystick']
 
 actuator_actions = ['move_Rel', 'move_Rel_p', 'move_Rel_m']

pymodaq/{daq_utils → utils}/managers/roi_manager.py

@@ -1,32 +1,105 @@
 import os
 import sys
-
-import pymodaq.daq_utils
+from typing import List, TYPE_CHECKING
+import pymodaq.utils
 from qtpy import QtCore, QtGui, QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal, QPointF
 from qtpy.QtGui import QIcon, QPixmap
 from collections import OrderedDict
 
-from pymodaq.daq_utils.parameter import ioxml
-from pymodaq.daq_utils.parameter import utils as putils
+from pymodaq.utils.parameter import ioxml
+from pymodaq.utils.parameter import utils as putils
 from pyqtgraph.parametertree import Parameter, ParameterTree
 from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
-from pymodaq.daq_utils.parameter import pymodaq_ptypes
-from pymodaq.daq_utils.managers.action_manager import QAction
+from pymodaq.utils.parameter import pymodaq_ptypes
+from pymodaq.utils.managers.action_manager import QAction
 from pyqtgraph import ROI as pgROI
+from pyqtgraph import RectROI as pgRectROI
 from pyqtgraph import functions as fn
 from pyqtgraph import LinearRegionItem as pgLinearROI
-from pymodaq.daq_utils.daq_utils import plot_colors
-from pymodaq.daq_utils.config import get_set_roi_path
-from pymodaq.daq_utils.gui_utils import select_file
+from pymodaq.utils.daq_utils import plot_colors
+from pymodaq.utils.logger import get_module_name, set_logger
+from pymodaq.utils.config import get_set_roi_path
+from pymodaq.utils.gui_utils import select_file
 import numpy as np
 from pathlib import Path
+from pymodaq.post_treatment.process_to_scalar import DataProcessorFactory
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_viewer import DAQ_Viewer
 
+data_processors = DataProcessorFactory()
 
 roi_path = get_set_roi_path()
+logger = set_logger(get_module_name(__file__))
+
+
+class ROIPositionMapper(QtWidgets.QWidget):
+    """ Widget presenting a Tree structure representing a ROI positions.
+    """
+
+    def __init__(self, roi_pos, roi_size):
+        super().__init__()
+        self.roi_pos = roi_pos
+        self.roi_size = roi_size
+
+    def show_dialog(self):
+        self.params = [
+            {'name': 'position', 'type': 'group', 'children': [
+                {'name': 'x0', 'type': 'float', 'value': self.roi_pos[0] + self.roi_size[0] / 2, 'step': 1},
+                {'name': 'y0', 'type': 'float', 'value': self.roi_pos[1] + self.roi_size[1] / 2, 'step': 1}
+            ]},
+            {'name': 'size', 'type': 'group', 'children': [
+                {'name': 'width', 'type': 'float', 'value': self.roi_size[0], 'step': 1},
+                {'name': 'height', 'type': 'float', 'value': self.roi_size[1], 'step': 1}]
+             }]
+
+        dialog = QtWidgets.QDialog(self)
+        vlayout = QtWidgets.QVBoxLayout()
+        self.settings_tree = ParameterTree()
+        vlayout.addWidget(self.settings_tree, 10)
+        self.settings_tree.setMinimumWidth(300)
+        self.settings = Parameter.create(name='settings', type='group', children=self.params)
+        self.settings_tree.setParameters(self.settings, showTop=False)
+        dialog.setLayout(vlayout)
+
+        buttonBox = QtWidgets.QDialogButtonBox(parent=self);
+        buttonBox.addButton('Apply', buttonBox.AcceptRole)
+        buttonBox.accepted.connect(dialog.accept)
+        buttonBox.addButton('Cancel', buttonBox.RejectRole)
+        buttonBox.rejected.connect(dialog.reject)
+
+        vlayout.addWidget(buttonBox)
+        self.setWindowTitle('Set Precise positions for the ROI')
+        res = dialog.exec()
+
+        if res == dialog.Accepted:
+
+            return self.settings
+        else:
+            return None
 
 
-class ROIBrushable(pgROI):
+class ROI(pgROI):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._menu = QtWidgets.QMenu()
+        self._menu.addAction('Set ROI positions', self.set_positions)
+
+    def set_positions(self):
+        mapper = ROIPositionMapper(self.pos(), self.size())
+        settings = mapper.show_dialog()
+        if settings is not None:
+            self.setSize((settings['size', 'width'], settings['size', 'height']))
+            self.setPos((settings['position', 'x0'] - settings['size', 'width'] / 2,
+                         settings['position', 'y0'] - settings['size', 'height'] / 2))
+
+    def contextMenuEvent(self, event):
+        if self._menu is not None:
+            self._menu.exec(event.screenPos())
+
+
+class ROIBrushable(ROI):
     def __init__(self, brush=None, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -76,7 +149,7 @@ class LinearROI(pgLinearROI):
         self.index_signal.emit(self.index)
 
 
-class EllipseROI(pgROI):
+class EllipseROI(ROI):
     """
     Elliptical ROI subclass with one scale handle and one rotation handle.
 
@@ -156,7 +229,25 @@ class EllipseROI(pgROI):
         return self.size().x()
 
 
-class RectROI(pgROI):
+class SimpleRectROI(ROI):
+    r"""
+    Rectangular ROI subclass with a single scale handle at the top-right corner.
+    """
+
+    def __init__(self, pos=[0, 0], size=[10, 10], centered=False, sideScalers=False, **args):
+        super().__init__(pos, size, **args)
+        if centered:
+            center = [0.5, 0.5]
+        else:
+            center = [0, 0]
+
+        self.addScaleHandle([1, 1], center)
+        if sideScalers:
+            self.addScaleHandle([1, 0.5], [center[0], 0.5])
+            self.addScaleHandle([0.5, 1], [0.5, center[1]])
+
+
+class RectROI(ROI):
     index_signal = Signal(int)
 
     def __init__(self, index=0, pos=[0, 0], size=[10, 10]):
@@ -202,12 +293,13 @@ class ROIScalableGroup(GroupParameter):
             children.extend([{'title': 'ROI Type', 'name': 'roi_type', 'type': 'str', 'value': typ, 'readonly': True},
                              {'title': 'Use channel', 'name': 'use_channel', 'type': 'list',
                               'limits': ['red', 'green', 'blue', 'spread']}, ])
+            children.append({'title': 'Math type:', 'name': 'math_function', 'type': 'list',
+                             'limits': data_processors.functions_filtered('Data2D')})
         else:
             children.append({'title': 'Use channel', 'name': 'use_channel', 'type': 'list'})
+            children.append({'title': 'Math type:', 'name': 'math_function', 'type': 'list',
+                             'limits': data_processors.functions_filtered('Data1D')})
 
-        functions = ['Sum', 'Mean', 'half-life', 'expotime', 'fwhm', 'moment', 'fwhm_moment2']
-        children.append({'title': 'Math type:', 'name': 'math_function', 'type': 'list', 'limits': functions,
-                         'value': 'Sum', 'visible': self.roi_type == '1D'})
         children.extend([
             {'name': 'Color', 'type': 'color', 'value': list(np.roll(self.color_list, newindex)[0])}, ])
         if self.roi_type == '2D':
@@ -261,7 +353,10 @@ class ROIManager(QObject):
     def ROIs(self):
         return self._ROIs
 
-    def get_roi_from_index(self, index: int):
+    def __len__(self):
+        return len(self._ROIs)
+
+    def get_roi_from_index(self, index: int) -> ROI:
         return self.ROIs[self.roi_format(index)]
 
     def _set_roi_from_index(self, index: int, roi):
@@ -322,17 +417,17 @@ class ROIManager(QObject):
                 par = data[0]
                 newindex = int(par.name()[-2:])
 
-                if par.child(('type')).value() == '1D':
+                if par.child('type').value() == '1D':
                     roi_type = ''
 
                     pos = self.viewer_widget.plotItem.vb.viewRange()[0]
                     newroi = LinearROI(index=newindex, pos=pos)
                     newroi.setZValue(-10)
-                    newroi.setBrush(par.child(('Color')).value())
+                    newroi.setBrush(par.child('Color').value())
                     newroi.setOpacity(0.2)
 
-                elif par.child(('type')).value() == '2D':
-                    roi_type = par.child(('roi_type')).value()
+                elif par.child('type').value() == '2D':
+                    roi_type = par.child('roi_type').value()
                     xrange = self.viewer_widget.plotItem.vb.viewRange()[0]
                     yrange = self.viewer_widget.plotItem.vb.viewRange()[1]
                     width = np.max(((xrange[1] - xrange[0]) / 10, 2))
@@ -345,7 +440,7 @@ class ROIManager(QObject):
                     else:
                         newroi = EllipseROI(index=newindex, pos=pos,
                                             size=[width, height])
-                    newroi.setPen(par.child(('Color')).value())
+                    newroi.setPen(par['Color'])
 
                 newroi.sigRegionChanged.connect(lambda: self.ROI_changed.emit())
                 newroi.sigRegionChangeFinished.connect(lambda: self.ROI_changed_finished.emit())
@@ -363,7 +458,7 @@ class ROIManager(QObject):
                 self.update_roi_tree(newindex)
 
             elif change == 'value':
-                if param.name() in putils.iter_children(self.settings.child(('ROIs')), []):
+                if param.name() in putils.iter_children(self.settings.child('ROIs'), []):
                     parent_name = putils.get_param_path(param)[putils.get_param_path(param).index('ROIs')+1]
                     self.update_roi(parent_name, param)
                     self.roi_value_changed.emit(parent_name, (param, param.value()))
@@ -376,6 +471,13 @@ class ROIManager(QObject):
 
         self.ROI_changed_finished.emit()
 
+    def update_use_channel(self, channels: List[str]):
+        for ind in range(len(self)):
+            val = self.settings['ROIs', self.roi_format(ind), 'use_channel']
+            self.settings.child('ROIs', self.roi_format(ind), 'use_channel').setOpts(limits=channels)
+            if val not in channels:
+                self.settings.child('ROIs', self.roi_format(ind), 'use_channel').setValue(channels[0])
+
     def update_roi(self, roi_key, param):
         self._ROIs[roi_key].index_signal[int].disconnect()
         if param.name() == 'Color':
@@ -435,7 +537,7 @@ class ROIManager(QObject):
 
         try:
             data = ioxml.parameter_to_xml_string(self.settings.child(('ROIs')))
-            path = select_file(start_path=Path.home(), ext='xml')
+            path = select_file(start_path=Path.home(), ext='xml', save=True, force_save_extension=True)
 
             if path != '':
                 with open(path, 'wb') as f:
@@ -453,7 +555,7 @@ class ROIManager(QObject):
         try:
             if params is None:
                 if path is None:
-                    path = select_file(start_path=Path.home(), save=False, ext='xml')
+                    path = select_file(start_path=Path.home(), save=False, ext='xml', filter=['xml'])
                     if path != '':
                         params = Parameter.create(title='Settings', name='settings', type='group',
                                                   children=ioxml.XML_file_to_parameter(path))
@@ -464,21 +566,13 @@ class ROIManager(QObject):
 
                 for param in params:
                     if 'roi_type' in putils.iter_children(param, []):
-                        self.settings.child(('ROIs')).addNew(param.child(('roi_type')).value())
+                        self.settings.child('ROIs').addNew(param.child('roi_type').value())
                     else:
-                        self.settings.child(('ROIs')).addNew()
-                # self.settings.child(('ROIs')).addChildren(params)
+                        self.settings.child('ROIs').addNew()
                 QtWidgets.QApplication.processEvents()
-
-                # settings = Parameter.create(title='Settings', name='settings', type='group')
-                #
-                # for param in params:
-                #     settings.addChildren(custom_tree.XML_string_to_parameter(custom_tree.parameter_to_xml_string(param)))
-
-                self.set_roi(self.settings.child(('ROIs')).children(), params)
-
+                self.set_roi(self.settings.child('ROIs').children(), params)
         except Exception as e:
-            pass
+            logger.exception(str(e))
 
     def set_roi(self, roi_params, roi_params_new):
         for child, new_child in zip(roi_params, roi_params_new):
@@ -491,7 +585,7 @@ class ROIManager(QObject):
 
 if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)
-    from pymodaq.daq_utils.plotting.data_viewers.viewer2D_basic import ImageWidget
+    from pymodaq.utils.plotting.widgets import ImageWidget
     from pyqtgraph import PlotWidget
 
     im = ImageWidget()
@@ -516,7 +610,7 @@ class ROISaver:
 
         if msgbox:
             msgBox = QtWidgets.QMessageBox()
-            msgBox.setText("Overshoot Manager?")
+            msgBox.setText("ROI Manager?")
             msgBox.setInformativeText("What do you want to do?")
             cancel_button = msgBox.addButton(QtWidgets.QMessageBox.Cancel)
             modify_button = msgBox.addButton('Modify', QtWidgets.QMessageBox.AcceptRole)
@@ -535,26 +629,24 @@ class ROISaver:
 
         """
 
-        children = pymodaq.daq_utils.parameter.ioxml.XML_file_to_parameter(filename)
+        children = ioxml.XML_file_to_parameter(filename)
         self.roi_presets = Parameter.create(title='roi', name='rois', type='group', children=children)
 
         det_children = [child for child in self.roi_presets.children() if 'det' in child.opts['name']]
-        det_names = [child.child(('detname')).value() for child in self.roi_presets.children() if
+        det_names = [child.child('detname').value() for child in self.roi_presets.children() if
                      'det' in child.opts['name']]
         det_module_names = [det.title for det in self.detector_modules]
         for ind_det, det_roi in enumerate(det_children):
-            det_module = self.detector_modules[det_module_names.index(det_names[ind_det])]
+            det_module: DAQ_Viewer = self.detector_modules[det_module_names.index(det_names[ind_det])]
             viewer_children = [child for child in det_roi.children() if 'viewer' in child.opts['name']]
-            for ind_viewer, viewer in enumerate(det_module.ui.viewers):
+            for ind_viewer, viewer in enumerate(det_module.viewers):
                 rois_params = [child for child in viewer_children[ind_viewer].children() if 'ROI' in child.opts['name']]
-                if hasattr(viewer, 'roi_manager'):
-                    # if hasattr(viewer.ui, 'roiBtn'):
-                    #     viewer.ui.roiBtn.click()
-                    # elif hasattr(viewer.ui, 'Do_math_pb'):
-                    #     viewer.ui.Do_math_pb.click()
-
-                    viewer.roi_manager.load_ROI(params=rois_params)
-                    QtWidgets.QApplication.processEvents()
+                if len(rois_params) > 0:
+                    if hasattr(viewer, 'roi_manager'):
+                        if hasattr(viewer, 'activate_roi'):  # because for viewer 0D it is irrelevant
+                            viewer.activate_roi()
+                        viewer.roi_manager.load_ROI(params=rois_params)
+                        QtWidgets.QApplication.processEvents()
 
         if show:
             self.show_rois()
@@ -577,12 +669,12 @@ class ROISaver:
 
                 if hasattr(viewer, 'roi_manager'):
                     viewer_param.addChild({'title': 'ROI type:', 'name': 'roi_type', 'type': 'str',
-                                           'value': viewer.roi_manager.settings.child(('ROIs')).roi_type})
-                    viewer_param.addChildren(viewer.roi_manager.settings.child(('ROIs')).children())
+                                           'value': viewer.roi_manager.settings.child('ROIs').roi_type})
+                    viewer_param.addChildren(viewer.roi_manager.settings.child('ROIs').children())
                 det_param.addChild(viewer_param)
             self.roi_presets.addChild(det_param)
 
-        pymodaq.daq_utils.parameter.ioxml.parameter_to_xml_file(self.roi_presets, os.path.join(roi_path, file))
+        ioxml.parameter_to_xml_file(self.roi_presets, os.path.join(roi_path, file))
         self.show_rois()
 
     def show_rois(self):
@@ -613,7 +705,6 @@ class ROISaver:
             # save managers parameters in a xml file
             # start = os.path.split(os.path.split(os.path.realpath(__file__))[0])[0]
             # start = os.path.join("..",'daq_scan')
-            pymodaq.daq_utils.parameter.ioxml.parameter_to_xml_file(self.roi_presets, os.path.join(roi_path,
-                                                                                                   self.roi_presets.child(
-                                                                                                       (
-                                                                                                           'filename')).value()))
+            ioxml.parameter_to_xml_file(
+                self.roi_presets, os.path.join(roi_path, self.roi_presets.child('filename').value()))
+