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

pymodaq/{daq_analysis → post_treatment/daq_analysis}/daq_analysis_main.py

@@ -1,21 +1,21 @@
-import pymodaq.daq_utils.gui_utils.file_io
+import pymodaq.utils.gui_utils.file_io
 from qtpy import QtGui, QtWidgets
 from qtpy.QtCore import Qt, QObject, Signal, QByteArray
 
 import sys
 import pymodaq
-import pymodaq.daq_utils.parameter.ioxml
-from pymodaq.daq_utils.plotting.data_viewers.viewer1D import Viewer1D
-from pymodaq.daq_utils.plotting.data_viewers.viewer2D import Viewer2D
+import pymodaq.utils.parameter.ioxml
+from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
+from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
 
 from collections import OrderedDict
 import numpy as np
 
 from pyqtgraph.parametertree import Parameter, ParameterTree
-import pymodaq.daq_utils.parameter.pymodaq_ptypes as pymodaq_ptypes
-from pymodaq.daq_utils.tree_layout.tree_layout_main import Tree_layout
-import pymodaq.daq_utils.daq_utils as utils
-from pymodaq.daq_utils import gui_utils as gutils
+import pymodaq.utils.parameter.pymodaq_ptypes as pymodaq_ptypes
+from pymodaq.utils.tree_layout.tree_layout_main import TreeLayout
+import pymodaq.utils.daq_utils as utils
+from pymodaq.utils import gui_utils as gutils
 from easydict import EasyDict as edict
 from pyqtgraph.dockarea import DockArea, Dock
 import tables
@@ -90,7 +90,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
     def set_GUI(self):
         """
             Create the graphic interface of the h5 file analyser, including:
-                * *h5 file dock* : QtreeWidget (custom instance of Tree_layout) showing the contents of the h5 file
+                * *h5 file dock* : QtreeWidget (custom instance of TreeLayout) showing the contents of the h5 file
                 * *status bar* : the top_down information bar
                 * *tree_dock* : The QTree viewer
                 * *1D viewer dock* : the preview window of 1D data
@@ -103,7 +103,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
         H_splitter = QtWidgets.QSplitter(Qt.Horizontal)
 
         Form = QtWidgets.QWidget()
-        self.ui.h5file_tree = Tree_layout(Form, col_counts=2, labels=["Node", 'Pixmap'])
+        self.ui.h5file_tree = TreeLayout(Form, col_counts=2, labels=["Node", 'Pixmap'])
         self.ui.h5file_tree.ui.Tree.setMinimumWidth(250)
         self.ui.h5file_tree.ui.Tree.itemClicked.connect(self.show_h5_attributes)
         self.ui.h5file_tree.ui.Tree.itemDoubleClicked.connect(self.show_h5_data)
@@ -210,7 +210,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
             do_load, close_h5, quit_fun
         """
         file_menu = menubar.addMenu('File')
-        open_action = file_menu.addAction("Open DAQ_Scan file")
+        open_action = file_menu.addAction("Open DAQScan file")
         open_action.triggered.connect(self.do_load)
         close_action = file_menu.addAction("close h5 file")
         close_action.triggered.connect(self.close_h5)
@@ -260,7 +260,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
             open_h5_file, update_status, daq_utils.select_file
         """
         try:
-            filename = pymodaq.daq_utils.gui_utils.file_io.select_file(start_path=path, save=False, ext='h5')
+            filename = pymodaq.utils.gui_utils.file_io.select_file(start_path=path, save=False, ext='h5')
             if filename != "":
                 self.open_h5_file(filename)
         except Exception as e:
@@ -344,7 +344,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
             ================= ====================== ====================================
             **Parameters**      **Type**              **Description**
 
-             *item*           tables Group instance   contain the root node of the tree
+             *item*           tables GROUP instance   contain the root node of the tree
 
              *col*                                    not used
             ================= ====================== ====================================
@@ -363,10 +363,10 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
                 for child in self.settings.children():
                     child.remove()
                 QtWidgets.QApplication.processEvents()  # so that the tree associated with settings updates
-                params = pymodaq.daq_utils.parameter.ioxml.XML_string_to_parameter(attrs.settings.decode())
+                params = pymodaq.utils.parameter.ioxml.XML_string_to_parameter(attrs.settings.decode())
                 self.settings.addChildren(params)
                 if hasattr(attrs, 'scan_settings'):
-                    params = pymodaq.daq_utils.parameter.ioxml.XML_string_to_parameter(attrs.scan_settings.decode())
+                    params = pymodaq.utils.parameter.ioxml.XML_string_to_parameter(attrs.scan_settings.decode())
                     self.settings.addChildren(params)
         except Exception as e:
             self.update_status(str(e), wait_time=self.wait_time)
@@ -382,7 +382,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
             =============== ====================== ===================================
             **Parameters**   **Type**               **Description**
 
-             *item*          tables Group instance  contain the root node of the tree
+             *item*          tables GROUP instance  contain the root node of the tree
              *col*                                  not used
             =============== ====================== ===================================
 
@@ -521,7 +521,7 @@ class DAQ_Analysis(QtWidgets.QWidget, QObject):
             ================ ======================= ==========================================
             **Parameters**     **Type**                **Description**
 
-             *node*           tables Group instance   the root node of the local treated tree
+             *node*           tables GROUP instance   the root node of the local treated tree
             ================ ======================= ==========================================
 
             Returns

pymodaq/{daq_measurement → post_treatment/daq_measurement}/daq_measurement_main.py

@@ -1,18 +1,16 @@
-from qtpy import QtGui, QtWidgets
-from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal, QLocale, QSize
+from qtpy import QtWidgets
+from qtpy.QtCore import Qt, QObject, Slot, Signal
 
 import sys
-from pymodaq.daq_measurement.daq_measurement_GUI import Ui_Form
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.math_utils import FourierFilterer
+from pymodaq.post_treatment.daq_measurement.daq_measurement_GUI import Ui_Form
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.plotting.utils.filter import FourierFilterer
 from scipy.optimize import curve_fit
-from scipy.signal import find_peaks
-import pyqtgraph as pg
 import numpy as np
-from enum import Enum
+from pymodaq.utils.enums import BaseEnum
 
 
-class Measurement_type(Enum):
+class Measurement_type(BaseEnum):
     Cursor_Integration = 0
     Max = 1
     Min = 2
@@ -21,10 +19,6 @@ class Measurement_type(Enum):
     Exponential_Decay_Fit = 5
     Sinus = 6
 
-    @classmethod
-    def names(cls):
-        return [name for name, member in cls.__members__.items()]
-
     @classmethod
     def update_measurement_subtype(cls, mtype):
         measurement_gaussian_subitems = ["amp", "dx", "x0", "offset"]
@@ -377,7 +371,7 @@ class DAQ_Measurement(Ui_Form, QObject):
 if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)
     Form = QtWidgets.QWidget()
-    from pymodaq.daq_utils.daq_utils import gauss1D
+    from pymodaq.utils.daq_utils import gauss1D
 
     prog = DAQ_Measurement(Form)
     xdata = np.linspace(0, 400, 401)

pymodaq/post_treatment/load_and_plot.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 22/01/2023
+
+@author: Sebastien Weber
+"""
+import os
+import sys
+from typing import List, Union, Callable, Iterable
+
+from qtpy import QtWidgets, QtCore
+
+from pymodaq.utils.data import DataToExport, DataFromPlugins, DataDim, enum_checker
+from pymodaq.utils.h5modules.data_saving import DataLoader
+from pymodaq.utils.h5modules.saving import H5Saver
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase, ViewersEnum, ViewerDispatcher
+from pymodaq.utils.gui_utils import Dock, DockArea
+
+
+class LoaderPlotter:
+
+    grouped_data1D_fullname = 'Grouped/Data1D'
+
+    def __init__(self, dockarea):
+        self.dockarea = dockarea
+        self.dispatcher = ViewerDispatcher(dockarea, title='ViewerDispatcher')
+        self._viewers: dict[str, ViewerBase] = None
+        self._viewer_docks: dict[str, ViewerBase] = None
+        self._viewer_types: List[ViewersEnum] = None
+        self._h5saver: H5Saver = None
+        self._data: DataToExport = None
+        self.dataloader: DataLoader = None
+
+    @property
+    def viewers(self) -> List[ViewerBase]:
+        return self.dispatcher.viewers
+
+    def connect_double_clicked(self, slot: Callable):
+        for viewer in self.viewers:
+            viewer.sig_double_clicked.connect(slot)
+
+    def disconnect(self, slot: Callable):
+        for viewer in self.viewers:
+            viewer.sig_double_clicked.disconnect(slot)
+
+    def clear_viewers(self):
+        self.dispatcher.remove_viewers(0)
+
+    @property
+    def h5saver(self):
+        return self._h5saver
+
+    @h5saver.setter
+    def h5saver(self, h5saver: H5Saver):
+        self._h5saver = h5saver
+        self.dataloader = DataLoader(h5saver)
+
+    @property
+    def data(self) -> DataToExport:
+        return self._data
+
+    def load_data(self, filter_dims: List[Union[DataDim, str]] = None, filter_full_names: List[str] = None,
+                  remove_navigation: bool = True, group_1D=False, average_axis=None, average_index: int = 0):
+        self._data = DataToExport('All')
+        self.dataloader.load_all('/', self._data)
+
+        if average_axis is not None:
+            for ind, data in enumerate(self._data):
+                current_data = data.inav[average_index, ...]
+                if average_index == 0:
+                    data_to_append = data.inav[0:average_index + 1, ...]
+                else:
+                    data_to_append = data.inav[0:average_index+1, ...].mean(axis=average_axis)
+                data_to_append.labels = [f'{label}_averaged' for label in data_to_append.labels]
+                current_data.append(data_to_append)
+                self._data[ind] = current_data
+
+        if remove_navigation:
+            for data in self._data:
+                data.nav_indexes = ()
+                data.transpose()  # because usual ND data should be plotted here as 2D with the nav axes as the minor
+                # (horizontal)
+
+        if filter_dims is not None:
+            filter_dims[:] = [enum_checker(DataDim, dim) for dim in filter_dims]
+            self._data.data[:] = [data for data in self._data if data.dim in filter_dims]
+
+        if filter_full_names is not None:
+            self._data.data[:] = [data for data in self._data if data.get_full_name() in filter_full_names]
+
+        if group_1D:
+            data = self._data.get_data_from_dim('Data1D')
+            if len(data) > 0:
+                data1D_arrays = []
+                labels = []
+                for dwa in data:
+                    data1D_arrays.extend(dwa.data)
+                    labels.extend([f'{dwa.get_full_name()}/{label}' for label in dwa.labels])
+                    self._data.remove(dwa)
+
+                data1D = DataFromPlugins(self.grouped_data1D_fullname.split('/')[1],
+                                         data=data1D_arrays, labels=labels,
+                                         origin=self.grouped_data1D_fullname.split('/')[0],
+                                         axes=dwa.axes)
+                self._data.append(data1D)
+
+        return self._data
+
+    def load_plot_data(self, **kwargs):
+        """Load and plot all data from the current H5Saver
+
+        See Also
+        -----
+        load_data
+        """
+        if 'target_at' in kwargs:
+            target_at = kwargs.pop('target_at')
+        self.load_data(**kwargs)
+        self.show_data(target_at=target_at)
+
+    def show_data(self, **kwargs):
+        """Send data to their dedicated viewers
+        """
+        #self._init_show_data(self._data)
+        self.set_data_to_viewers(self._data, **kwargs)
+
+    def _init_show_data(self, data: DataToExport):
+        """Processing before showing data
+        """
+        self._viewer_types = [ViewersEnum(data.dim.name) for data in data]
+        self.prepare_viewers(self._viewer_types)
+
+    def prepare_viewers(self, viewers_enum: List[ViewersEnum], viewers_name: List[str] = None):
+        if self._viewers is not None:
+            while len(self._viewers) > 0:
+                self._viewers.pop(list(self._viewers.keys())[0])
+                self._viewer_docks.pop(list(self._viewer_docks.keys())[0])
+
+        self._viewer_types = [enum_checker(ViewersEnum, viewer_enum) for viewer_enum in viewers_enum]
+        if viewers_name is None or len(viewers_enum) != len(viewers_name):
+            viewers_name = [f'DataPlot{ind:02d}' for ind in range(len(self._viewer_types))]
+
+        if self.dispatcher.viewer_types != self._viewer_types:
+            self.dispatcher.update_viewers(self._viewer_types)
+
+        self._viewers = dict(zip(viewers_name, self.dispatcher.viewers))
+        self._viewer_docks = dict(zip(viewers_name, self.dispatcher.viewer_docks))
+
+    def set_data_to_viewers(self, data: DataToExport, temp=False, target_at: Iterable[float] = None):
+        """Process data dimensionality and send appropriate data to their data viewers
+
+        Parameters
+        ----------
+        data: list of DataFromPlugins
+        temp: bool
+            if True notify the data viewers to display data as temporary (meaning not exporting processed data from roi)
+        target_at: Iterable[float]
+            if specified show and plot the roi_target of each viewer at the given position
+        See Also
+        --------
+        ViewerBase, Viewer0D, Viewer1D, Viewer2D
+        """
+        for ind, _data in enumerate(data.data):
+            viewer = self._viewers[_data.get_full_name()]
+            self._viewer_docks[_data.get_full_name()].setTitle(_data.name)
+
+            # viewer = self.viewers[ind]
+            # self.dispatcher.viewer_docks[ind].setTitle(_data.name)
+
+            viewer.title = _data.name
+            if temp:
+                viewer.show_data_temp(_data)
+            else:
+                viewer.show_data(_data)
+            if target_at is not None:
+                viewer.show_roi_target(True)
+                if _data.dim == 'Data1D':
+                    viewer.move_roi_target(target_at)
+                elif _data.dim == 'Data2D' and _data.distribution == 'uniform':
+                    _target_at = target_at.copy()
+
+                    size = [_data.get_axis_from_index(1)[0].scaling]
+                    if len(_target_at) == 1:  # means concatenation of 1D data
+                        axis = _data.get_axis_from_index(0)[0]
+                        size.append(axis.scaling * axis.size)
+                        _target_at = list(_target_at) + [axis.offset]
+                    else:
+                        size.append(_data.get_axis_from_index(0)[0].scaling)
+                    viewer.move_roi_target(_target_at, size)
+
+def main(init_qt=True):
+    if init_qt:  # used for the test suite
+        app = QtWidgets.QApplication(sys.argv)
+
+    path = r'C:\Users\weber\Downloads\temp_data.h5'
+
+    h5saver = H5Saver()
+    h5saver.open_file(path)
+
+    win = QtWidgets.QMainWindow()
+    area = DockArea()
+    win.setCentralWidget(area)
+    win.resize(1000, 500)
+    win.setWindowTitle('PyMoDAQ Viewer')
+    win.show()
+
+    loader = LoaderPlotter(area)
+    loader.h5saver = h5saver
+    data = loader.load_data(filter_dims=['Data2D', 'Data1D'], group_1D=True)
+    loader._init_show_data(data)
+    loader.show_data()
+
+    if init_qt:
+        sys.exit(app.exec_())
+    return loader, win
+
+
+if __name__ == '__main__':
+    main()

pymodaq/post_treatment/process_to_scalar.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 04/11/2022
+
+@author: Sebastien Weber
+"""
+import numpy as np
+from numbers import Number
+from typing import List, Tuple
+from abc import ABCMeta, abstractmethod, abstractproperty
+
+from pymodaq.utils.factory import ObjectFactory
+from pymodaq.utils import math_utils as mutils
+from pymodaq.utils.data import DataWithAxes, Axis, DataRaw, DataBase, DataDim, DataCalculated
+
+
+config_processors = {
+}
+
+
+class DataProcessorBase(metaclass=ABCMeta):
+    """Apply processing functions to signal data. This function should return a scalar.
+
+    Attributes
+    ----------
+    apply_to: DataDim
+        Specify on which type of data dimensionality this processor can be applied to, if only 1D:
+        apply_to = DataDim['Data1D']
+
+    """
+
+    apply_to: DataDim = abstractproperty
+
+    def process(self, data: DataWithAxes) -> DataWithAxes:
+        return self.operate(data)
+
+    @abstractmethod
+    def operate(self, sub_data: DataWithAxes):
+        pass
+
+    @staticmethod
+    def flatten_signal_dim(sub_data: DataWithAxes) -> Tuple[Tuple, np.ndarray]:
+        """flattens data's ndarrays along the signal dimensions"""
+        data_arrays = []
+        new_shape = [sub_data.shape[ind] for ind in sub_data.nav_indexes]
+        new_shape.append(np.prod([sub_data.shape[ind] for ind in sub_data.sig_indexes]))
+
+        # for each data in subdata, apply the function, here argmax, along the flattened dimension. Then unravel the
+        # possible multiple indexes (1 for 1D, 2 for 2D)
+        for ind, data in enumerate(sub_data):
+            data_arrays.append(data.reshape(new_shape))
+        return new_shape, data_arrays
+
+    def __call__(self, **kwargs):
+        return self(**kwargs)
+
+
+class DataProcessorFactory(ObjectFactory):
+    def get(self, processor_name, **kwargs) -> DataProcessorBase:
+        return self.create(processor_name, **kwargs)
+
+    @property
+    def functions(self):
+        """Get the list of processor functions"""
+        return self.keys_function(do_sort=False)
+
+    def functions_filtered(self, dim: DataDim):
+        """Get the list of processor functions that could be applied to data having a given dimensionality"""
+        return [key for key in self.functions if self.get(key).apply_to >= dim]
+
+
+@DataProcessorFactory.register('mean')
+class MeanProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.mean(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('std')
+class StdProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.std(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('sum')
+class SumProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.sum(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('max')
+class MaxProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.max(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('min')
+class MinProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.min(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('argmax')
+class ArgMaxProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal axis values of the maximum position of the data
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+
+        for dat in flattened_arrays:
+            indexes = np.unravel_index(np.nanargmax(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
+            # from the unraveled index, retrieve the corresponding axis value
+            for ind in range(len(indexes)):
+                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
+                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
+                              distribution=sub_data.distribution)
+
+
+@DataProcessorFactory.register('argmin')
+class ArgMinProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal axis values of the minimum position of the data
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+
+        for dat in flattened_arrays:
+            indexes = np.unravel_index(np.nanargmin(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
+            # from the unraveled index, retrieve the corresponding axis value
+            for ind in range(len(indexes)):
+                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
+                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
+                              distribution=sub_data.distribution)
+
+
+@DataProcessorFactory.register('argmean')
+class ArgMeanProcessor(DataProcessorBase):
+    apply_to = DataDim['Data1D']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal mean axis values
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
+        for dat in flattened_arrays:
+            weights = dat
+            new_data_arrays.append(np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights)))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
+
+
+@DataProcessorFactory.register('argstd')
+class ArgStdProcessor(DataProcessorBase):
+    apply_to = DataDim['Data1D']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal mean axis values
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
+        for dat in flattened_arrays:
+            weights = dat
+            w_avg = np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights))
+            new_data_arrays.append(np.atleast_1d(np.sqrt(
+                np.sum(weights * (values - w_avg) ** 2, axis=len(new_shape) - 1) /
+                np.sum(weights, axis=len(new_shape) - 1))))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
+
+
+if __name__ == '__main__':
+    import copy
+    processors = DataProcessorFactory()
+    print('Builders:\n'
+          f'{processors.builders}')
+
+    print('Math functions:\n'
+          f'{processors.functions}')
+
+    # test 2D signals
+    Nsigx = 200
+    Nsigy = 100
+    Nnav = 10
+    x = np.linspace(-Nsigx / 2, Nsigx / 2 - 1, Nsigx)
+    y = np.linspace(-Nsigy / 2, Nsigy / 2 - 1, Nsigy)
+
+    dat = np.zeros((Nnav, Nsigy, Nsigx))
+    for ind in range(Nnav):
+        dat[ind] = ind * mutils.gauss2D(x, 10 * (ind - Nnav / 2), 25 / np.sqrt(2),
+                                        y, 2 * (ind - Nnav / 2), 10 / np.sqrt(2))
+
+    data = DataRaw('mydata', data=[dat], nav_indexes=(0,),
+                   axes=[Axis('nav', data=np.linspace(0, Nnav-1, Nnav), index=0),
+                         Axis('sigy', data=y, index=1),
+                         Axis('sigx', data=x, index=2)])
+    new_data = processors.get('sum', **config_processors).operate(data.isig[25:75, 75:125])
+    print(new_data)
+    print(new_data.data)

pymodaq/resources/QtDesigner_Ressources/QtDesigner_ressources.bat

@@ -1,2 +1,2 @@
 cd "C:\Users\Weber\Labo\Programmes Python\PyMoDAQ_Git\pymodaq\src\pymodaq\resources\QtDesigner_Ressources"
-C:\Miniconda3\envs\pyqt5tools\Scripts\pyrcc5 QtDesigner_ressources.qrc > QtDesigner_ressources_rc.py
+C:\Miniconda3\envs\qt5tools\Scripts\pyrcc5 QtDesigner_ressources.qrc > QtDesigner_ressources_rc.py

pymodaq/resources/QtDesigner_Ressources/QtDesigner_ressources.qrc

@@ -1,5 +1,6 @@
 <RCC>
   <qresource prefix="icons">
+	<file>Icon_Library/stop_all.png</file>
 	<file>Icon_Library/load_ROI.png</file>
 	<file>Icon_Library/Open_1D.png</file>
 	<file>Icon_Library/Open_2D.png</file>