pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/post_treatment/daq_measurement/daq_measurement_main.py

@@ -1,391 +0,0 @@
-from qtpy import QtWidgets
-from qtpy.QtCore import Qt, QObject, Slot, Signal
-
-import sys
-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
-import numpy as np
-from pymodaq.utils.enums import BaseEnum
-
-
-class Measurement_type(BaseEnum):
-    Cursor_Integration = 0
-    Max = 1
-    Min = 2
-    Gaussian_Fit = 3
-    Lorentzian_Fit = 4
-    Exponential_Decay_Fit = 5
-    Sinus = 6
-
-    @classmethod
-    def update_measurement_subtype(cls, mtype):
-        measurement_gaussian_subitems = ["amp", "dx", "x0", "offset"]
-        measurement_laurentzian_subitems = ["alpha", "gamma", "x0", "offset"]
-        measurement_decay_subitems = ["N0", "gamma", 'x0', "offset"]
-        measurement_cursor_subitems = ["sum", "mean", "std"]
-        measurement_sinus_subtitems = ['A', 'dx', 'phi', 'offset']
-        variables = ", "
-        formula = ""
-        subitems = []
-        if mtype == 'Cursor_Integration':  # "Cursor integration":
-            subitems = measurement_cursor_subitems
-
-        if mtype == 'Gaussian_Fit':  # "Gaussian Fit":
-            subitems = measurement_gaussian_subitems
-            formula = "amp*np.exp(-2*np.log(2)*(x-x0)**2/dx**2)+offset"
-            variables = variables.join(measurement_gaussian_subitems)
-
-        elif mtype == 'Lorentzian_Fit':  # "Lorentzian Fit":
-            subitems = measurement_laurentzian_subitems
-            variables = variables.join(measurement_laurentzian_subitems)
-            formula = "alpha/np.pi*gamma/2/((x-x0)**2+(gamma/2)**2)+offset"
-
-        elif mtype == 'Exponential_Decay_Fit':  # "Exponential Decay Fit":
-            subitems = measurement_decay_subitems
-            variables = variables.join(measurement_decay_subitems)
-            formula = "N0*np.exp(-(x-x0)/gamma)+offset"
-
-        elif mtype == 'Sinus':
-            subitems = measurement_sinus_subtitems
-            variables = variables.join(measurement_sinus_subtitems)
-            formula = "A*np.sin(2*np.pi*x/dx-phi)+offset"
-
-        return [variables, formula, subitems]
-
-    def gaussian_func(self, x, amp, dx, x0, offset):
-        return amp * np.exp(-2 * np.log(2) * (x - x0) ** 2 / dx ** 2) + offset
-
-    def laurentzian_func(self, x, alpha, gamma, x0, offset):
-        return alpha / np.pi * 1 / 2 * gamma / ((x - x0) ** 2 + (1 / 2 * gamma) ** 2) + offset
-
-    def decaying_func(self, x, N0, gamma, x0, offset):
-        return N0 * np.exp(-(x - x0) / gamma) + offset
-
-    def sinus_func(self, x, A, dx, phi, offset):
-        return A * np.sin(2 * np.pi * x / dx - phi) + offset
-
-
-class DAQ_Measurement(Ui_Form, QObject):
-    """
-        =================== ================================== =======================================
-        **Attributes**       **Type**                          **Description**
-
-
-        *ui*                 QObject                           The local instance of User Interface
-        *wait_time*          int                               The default delay of showing
-        *parent*             QObject                           The QObject initializing the UI
-        *xdata*              1D numpy array                    The x axis data
-        *ydata*              1D numpy array                    The y axis data
-        *measurement_types*  instance of daq_utils.DAQ_enums   The type of the measurement, between:
-                                                                    * 'Cursor_Integration'
-                                                                    * 'Max'
-                                                                    * 'Min'
-                                                                    * 'Gaussian_Fit'
-                                                                    * 'Lorentzian_Fit'
-                                                                    * 'Exponential_Decay_Fit'
-        =================== ================================== =======================================
-
-        References
-        ----------
-        Ui_Form, QObject, qtpy, pyqtgraph
-    """
-    measurement_signal = Signal(list)
-
-    def __init__(self, parent):
-        
-        super(Ui_Form, self).__init__()
-        self.ui = Ui_Form()
-        self.ui.setupUi(parent)
-
-        self.widg = QtWidgets.QWidget()
-        self.fourierfilt = FourierFilterer(self.widg)
-        self.ui.splitter_2.addWidget(self.widg)
-        self.ui.graph1D = self.fourierfilt.viewer1D.plotwidget
-        QtWidgets.QApplication.processEvents()
-
-        self.ui.splitter.setSizes([200, 400])
-        self.ui.statusbar = QtWidgets.QStatusBar(parent)
-        self.ui.statusbar.setMaximumHeight(15)
-        self.ui.StatusBarLayout.addWidget(self.ui.statusbar)
-        self.wait_time = 1000
-        self.parent = parent
-        self.xdata = None
-        self.ydata = None
-
-        self.measurement_types = Measurement_type.names()
-        self.measurement_type = Measurement_type(0)
-        self.ui.measurement_type_combo.clear()
-        self.ui.measurement_type_combo.addItems(self.measurement_types)
-
-        self.ui.fit_curve = self.fourierfilt.viewer1D.plotwidget.plot()
-        self.ui.fit_curve.setPen("y")
-        self.ui.fit_curve.setVisible(False)
-
-        self.ui.selected_region = self.fourierfilt.viewer1D.ROI
-        self.ui.selected_region.setZValue(-10)
-        self.ui.selected_region.setBrush('b')
-        self.ui.selected_region.setOpacity(0.2)
-        self.ui.selected_region.setVisible(True)
-        self.fourierfilt.viewer1D.plotwidget.addItem(self.ui.selected_region)
-
-        # Connecting buttons:
-        self.ui.Quit_pb.clicked.connect(self.Quit_fun, type=Qt.QueuedConnection)
-        self.ui.measurement_type_combo.currentTextChanged[str].connect(self.update_measurement_subtype)
-        self.ui.measure_subtype_combo.currentTextChanged[str].connect(self.update_measurement)
-        self.update_measurement_subtype(self.ui.measurement_type_combo.currentText(), update=False)
-        self.ui.selected_region.sigRegionChanged.connect(self.update_measurement)
-        self.ui.result_sb.valueChanged.connect(self.ui.result_lcd.display)
-
-    @Slot(dict)
-    def update_fft_filter(self, d):
-        self.frequency = d['frequency']
-        self.phase = d['phase']
-        self.update_measurement()
-
-    def Quit_fun(self):
-        """
-            close the current instance of daq_measurement.
-
-        """
-        # insert anything that needs to be closed before leaving
-        self.parent.close()
-
-    def update_status(self, txt, wait_time=0):
-        """
-            Update the statut bar showing the given text message with a delay of wait_time ms (0s by default).
-
-            =============== ========= ===========================
-            **Parameters**
-
-            *txt*             string   the text message to show
-
-            *wait_time*       int      the delay time of waiting
-            =============== ========= ===========================
-
-        """
-        self.ui.statusbar.showMessage(txt, wait_time)
-
-    @Slot(str)
-    def update_measurement_subtype(self, mtype, update=True):
-        """
-            | Update the ui-measure_subtype_combo from subitems and formula attributes, if specified by update parameter.
-            | Linked with the update_measurement method
-
-            ================ ========== =====================================================================================
-            **Parameters**    **Type**   **Description**
-
-            mtype             string      the Measurement_type index of the Measurement_type array (imported from daq_utils)
-
-            update            boolean     the update boolean link with the update_measurement method
-            ================ ========== =====================================================================================
-
-            See Also
-            --------
-            update_measurement_subtype, update_measurement, update_status
-
-        """
-        self.measurement_type = Measurement_type[mtype]
-        [variables, self.formula, self.subitems] = Measurement_type.update_measurement_subtype(mtype)
-
-        try:
-            self.ui.measure_subtype_combo.clear()
-            self.ui.measure_subtype_combo.addItems(self.subitems)
-            self.ui.formula_edit.setPlainText(self.formula)
-
-            if update:
-                self.update_measurement()
-        except Exception as e:
-            self.update_status(str(e), wait_time=self.wait_time)
-
-    def update_measurement(self):
-        """
-            Update :
-             * the measurement results from the update_measurements method
-             * the statut bar on cascade (if needed)
-             * the User Interface function curve state and data (if needed).
-
-            Emit the measurement_signal corresponding.
-
-            See Also
-            --------
-            update_measurement, update_status
-
-        """
-        try:
-            xlimits = self.ui.selected_region.getRegion()
-            mtype = self.ui.measurement_type_combo.currentText()
-            msubtype = self.ui.measure_subtype_combo.currentText()
-            if mtype == 'Sinus':
-
-                # boundaries = utils.find_index(self.xdata, [xlimits[0], xlimits[1]])
-                # sub_xaxis = self.xdata[boundaries[0][0]:boundaries[1][0]]
-                # sub_data = self.ydata[boundaries[0][0]:boundaries[1][0]]
-                # self.fourierfilt.parent.setVisible(True)
-                self.fourierfilt.show_data(dict(data=self.ydata, xaxis=self.xdata))
-            else:
-                # self.fourierfilt.parent.setVisible(False)
-                pass
-
-            measurement_results = self.do_measurement(xlimits[0], xlimits[1], self.xdata, self.ydata, mtype, msubtype)
-            if measurement_results['status'] is not None:
-                self.update_status(measurement_results['status'], wait_time=self.wait_time)
-                return
-            self.ui.result_sb.setValue(measurement_results['value'])
-            self.measurement_signal.emit([measurement_results['value']])
-            if measurement_results['datafit'] is not None:
-                self.ui.fit_curve.setVisible(True)
-                self.ui.fit_curve.setData(measurement_results['xaxis'], measurement_results['datafit'])
-            else:
-                self.ui.fit_curve.setVisible(False)
-        except Exception as e:
-            self.update_status(str(e), wait_time=self.wait_time)
-
-    def eval_func(self, x, *args):
-        dic = dict(zip(self.subitems, args))
-        dic.update(dict(np=np, x=x))
-        return eval(self.formula, dic)
-
-    def do_measurement(self, xmin, xmax, xaxis, data1D, mtype, msubtype):
-        try:
-            boundaries = utils.find_index(xaxis, [xmin, xmax])
-            sub_xaxis = xaxis[boundaries[0][0]:boundaries[1][0]]
-            sub_data = data1D[boundaries[0][0]:boundaries[1][0]]
-            mtypes = Measurement_type.names()
-            if msubtype in self.subitems:
-                msub_ind = self.subitems.index(msubtype)
-
-            measurement_results = dict(status=None, value=0, xaxis=np.array([]), datafit=np.array([]))
-
-            if mtype == 'Cursor_Integration':  # "Cursor Intensity Integration":
-                if msubtype == "sum":
-                    result_measurement = np.sum(sub_data)
-                elif msubtype == "mean":
-                    result_measurement = np.mean(sub_data)
-                elif msubtype == "std":
-                    result_measurement = np.std(sub_data)
-                else:
-                    result_measurement = 0
-
-            elif mtype == 'Max':  # "Max":
-                result_measurement = np.max(sub_data)
-
-            elif mtype == 'Min':  # "Min":
-                result_measurement = np.min(sub_data)
-
-            elif mtype == 'Gaussian_Fit':  # "Gaussian Fit":
-                measurement_results['xaxis'] = sub_xaxis
-                offset = np.min(sub_data)
-                amp = np.max(sub_data) - np.min(sub_data)
-                m = utils.my_moment(sub_xaxis, sub_data)
-                p0 = [amp, m[1], m[0], offset]
-                popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0)
-                measurement_results['datafit'] = self.eval_func(sub_xaxis, *popt)
-                result_measurement = popt[msub_ind]
-
-            elif mtype == 'Lorentzian_Fit':  # "Lorentzian Fit":
-                measurement_results['xaxis'] = sub_xaxis
-                offset = np.min(sub_data)
-                amp = np.max(sub_data) - np.min(sub_data)
-                m = utils.my_moment(sub_xaxis, sub_data)
-                p0 = [amp, m[1], m[0], offset]
-                popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0)
-                measurement_results['datafit'] = self.eval_func(sub_xaxis, *popt)
-                if msub_ind == 4:  # amplitude
-                    result_measurement = popt[0] * 2 / (np.pi * popt[1])  # 2*alpha/(pi*gamma)
-                else:
-                    result_measurement = popt[msub_ind]
-
-            elif mtype == 'Exponential_Decay_Fit':  # "Exponential Decay Fit":
-                ind_x0 = utils.find_index(sub_data, np.max(sub_data))[0][0]
-                x0 = sub_xaxis[ind_x0]
-                sub_xaxis = sub_xaxis[ind_x0:]
-                sub_data = sub_data[ind_x0:]
-                offset = min([sub_data[0], sub_data[-1]])
-                measurement_results['xaxis'] = sub_xaxis
-                N0 = np.max(sub_data) - offset
-                t37 = sub_xaxis[utils.find_index(sub_data - offset, 0.37 * N0)[0][0]] - x0
-                # polynome = np.polyfit(sub_xaxis, -np.log((sub_data - 0.99 * offset) / N0), 1)
-                p0 = [N0, t37, x0, offset]
-                popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0)
-                measurement_results['datafit'] = self.eval_func(sub_xaxis, *popt)
-                result_measurement = popt[msub_ind]
-
-            elif mtype == 'Sinus':  #
-                offset = np.mean(sub_data)
-                A = (np.max(sub_data) - np.min(sub_data)) / 2
-                phi = self.fourierfilt.phase
-                dx = 1 / self.fourierfilt.frequency
-                measurement_results['xaxis'] = sub_xaxis
-                p0 = [A, dx, phi, offset]
-                popt, pcov = curve_fit(self.eval_func, sub_xaxis, sub_data, p0=p0)
-                measurement_results['datafit'] = self.eval_func(sub_xaxis, *popt)
-                result_measurement = popt[msub_ind]
-
-            # elif mtype=="Custom Formula":
-            #    #offset=np.min(sub_data)
-            #    #amp=np.max(sub_data)-np.min(sub_data)
-            #    #m=utils.my_moment(sub_xaxis,sub_data)
-            #    #p0=[amp,m[1],m[0],offset]
-            #    popt, pcov = curve_fit(self.custom_func, sub_xaxis, sub_data,p0=[140,750,50,15])
-            #    self.curve_fitting_sig.emit([sub_xaxis,self.gaussian_func(sub_xaxis,*popt)])
-            #    result_measurement=popt[msub_ind]
-            else:
-                result_measurement = 0
-
-            measurement_results['value'] = result_measurement
-
-            return measurement_results
-        except Exception as e:
-            result_measurement = 0
-            measurement_results['status'] = str(e)
-            return measurement_results
-
-    def update_data(self, xdata=None, ydata=None):
-        """
-            | Update xdata attribute with the numpy linspcae regular distribution (if param is none) and update the User Interface curve data.
-            | Call the update_measurement method synchronously to keep same values.
-
-            =============== ============   ======================
-            **Parameters**   **Type**       **Description**
-
-            *xdata*          float list    the x axis data
-            *ydata*          float list    the y axis data
-            =============== ============   ======================
-
-            See Also
-            --------
-            update_measurement
-
-        """
-        if xdata is None:
-            self.xdata = np.linspace(0, len(ydata) - 1, len(ydata))
-        else:
-            self.xdata = xdata
-        self.ydata = ydata
-        self.fourierfilt.show_data(dict(data=self.ydata, xaxis=self.xdata))
-        self.update_measurement()
-
-
-if __name__ == '__main__':
-    app = QtWidgets.QApplication(sys.argv)
-    Form = QtWidgets.QWidget()
-    from pymodaq.utils.daq_utils import gauss1D
-
-    prog = DAQ_Measurement(Form)
-    xdata = np.linspace(0, 400, 401)
-    x0 = 50
-    dx = 20
-    tau = 27
-    tau2 = 100
-    ydata_gauss = 10 * gauss1D(xdata, x0, dx) + np.random.rand(len(xdata))
-    ydata_expodec = np.zeros((len(xdata)))
-    ydata_expodec[:50] = 10 * gauss1D(xdata[:50], x0, dx, 2)
-    ydata_expodec[50:] = 10 * np.exp(-(xdata[50:] - x0) / tau)  # +10*np.exp(-(xdata[50:]-x0)/tau2)
-    ydata_expodec += 2 * np.random.rand(len(xdata))
-    ydata_sin = 10 + 2 * np.sin(2 * np.pi * xdata / 21 - np.deg2rad(55)) + 2 * np.random.rand(len(xdata))
-    prog.update_data(xdata, ydata_sin)
-    Form.show()
-
-    sys.exit(app.exec_())

pymodaq/post_treatment/daq_measurement/process_from_QtDesigner_DAQ_Measurement_GUI.bat

@@ -1,2 +0,0 @@
-cd "C:\DAQ\Python\PyMoDAQ_Git\pymodaq\pymodaq\daq_measurement"
-C:\WPy-3710\python-3.7.1.amd64\Scripts\pyuic5.bat -x DAQ_Measurement_GUI.ui -o DAQ_Measurement_GUI.py

pymodaq/post_treatment/process_to_scalar.py

@@ -1,263 +0,0 @@
-# -*- 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 DataWithAxes.
-
-    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)