darfix 4.1.1__tar.gz → 4.2.0__tar.gz

{darfix-4.1.1 → darfix-4.2.0}/LICENSE

@@ -18,4 +18,6 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.
+
+This project uses joblib (https://github.com/joblib/joblib), licensed under the BSD 3-Clause License.

{darfix-4.1.1/src/darfix.egg-info → darfix-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: darfix
-Version: 4.1.1
+Version: 4.2.0
 Summary: Computer vision software for the interpretation of diffraction images
 Author-email: ESRF <dau-pydev@esrf.fr>
 License: The MIT license follows:
@@ -24,6 +24,9 @@ License: The MIT license follows:
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
+        
+        This project uses joblib (https://github.com/joblib/joblib), licensed under the BSD 3-Clause License.
+        
 Project-URL: Homepage, https://gitlab.esrf.fr/XRD/darfix/
 Project-URL: Documentation, http://www.edna-site.org/pub/doc/darfix/latest
 Project-URL: Repository, https://gitlab.esrf.fr/XRD/darfix/
@@ -46,6 +49,7 @@ Requires-Dist: packaging
 Requires-Dist: scikit-learn
 Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: joblib
 Requires-Dist: eval_type_backport
 Provides-Extra: full-noqt
 Requires-Dist: opencv-python-headless>=4.3.0.36; extra == "full-noqt"

{darfix-4.1.1 → darfix-4.2.0}/pyproject.toml

@@ -8,7 +8,7 @@ addopts = "--import-mode=importlib" # for all pytest versions, pytest-cov needs
 
 [project]
 name = "darfix"
-version = "4.1.1"
+version = "4.2.0"
 keywords = ["orange3 add-on","ewoks"]
 authors = [{name = "ESRF", email = "dau-pydev@esrf.fr"}]
 description = "Computer vision software for the interpretation of diffraction images"
@@ -31,6 +31,7 @@ dependencies = [
     "scikit-learn",
     "scipy",
     "tqdm",
+    "joblib",
     "eval_type_backport"
 ]
 

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/_config.py

@@ -1,3 +1,6 @@
+FWHM_VAL = 2.35482  # For numba
+
+
 class Config:
     """
     Class containing shared global configuration for the darfix project.
@@ -15,7 +18,7 @@ class Config:
     .. versionadded:: 0.3
     """
 
-    FWHM_VAL = 2.35482
+    FWHM_VAL = FWHM_VAL
 
     """Magic value that returns FWHM when multiplied by the standard deviation.
 

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/core/dataset.py

@@ -30,9 +30,7 @@ from darfix.core.mapping import compute_magnification
 from darfix.core.mapping import compute_moments
 from darfix.core.mapping import compute_rsm
 from darfix.core.positioners import Positioners
-from darfix.core.rocking_curves import fit_1d_data
-from darfix.core.rocking_curves import fit_2d_data
-from darfix.core.rocking_curves import fit_3d_data
+from darfix.core.rocking_curves import fit_rocking_curve_parallel
 from darfix.core.roi import apply_2D_ROI
 from darfix.core.roi import apply_3D_ROI
 from darfix.core.state_of_operation import Operation
@@ -729,61 +727,44 @@ class ImageDataset(ImageStack):
         """
         if not self.dims.ndim:
             raise NoDimensionsError("apply_fit")
+        if indices is None:
+            indices = Ellipsis
 
         new_dataset = self.copy(new_data=self.data.copy())
 
         with self.state_of_operations.run_context(Operation.FIT):
-            data = new_dataset.as_array3d(indices)
+            data = new_dataset.as_array3d()
             # Fit can only be done if rocking curves are at least of size 3
-            if len(data) < 3:
+            if len(self.data) < 3:
                 raise ValueError(
-                    f"Fit can only be done if rocking curves are at least of dimensionality 3. Got {len(data)}"
+                    f"Fit can only be done if dataset has not at least 3 dimensions. Got {len(data)}"
                 )
 
             if self.dims.ndim == 1:
                 dim0 = self.dims.get(0)
-                data[:], maps = fit_1d_data(
-                    data=data,
-                    values=self.get_metadata_values(dim0.name, indices),
-                    int_thresh=int_thresh,
-                    method=method,
-                )
-            elif self.dims.ndim == 2:
-                # TODO: `indices` seem to be handled differently here ??
-                dim0 = self.dims.get(0)
-                dim1 = self.dims.get(1)
-                values = [
-                    self.get_metadata_values(key=dim0.name),
-                    self.get_metadata_values(key=dim1.name),
+                motor_values = self.metadata_dict[dim0.name].ravel()[indices]
+            elif self.dims.ndim <= 3:
+
+                ndim = self.dims.ndim
+                dimension_names = [
+                    self.dims.get(dim_idx).name for dim_idx in range(ndim)
                 ]
-                data[:], maps = fit_2d_data(
-                    data=self.as_array3d(),
-                    values=values,
-                    shape=(dim0.size, dim1.size),
-                    int_thresh=int_thresh,
-                    indices=indices,
-                    method=method,
-                )
-            elif self.dims.ndim == 3:
-                # TODO: `indices` seem to be handled differently here ??
-                dim0 = self.dims.get(0)
-                dim1 = self.dims.get(1)
-                dim2 = self.dims.get(2)
-                data[:], maps = fit_3d_data(
-                    data=self.as_array3d(),
-                    motor_values=[
-                        self.get_metadata_values(key=dim0.name),
-                        self.get_metadata_values(key=dim1.name),
-                        self.get_metadata_values(key=dim2.name),
-                    ],
-                    shape=(dim0.size, dim1.size, dim2.size),
-                    int_thresh=int_thresh,
-                    indices=indices,
-                    method=method,
-                )
+
+                motor_values = [
+                    self.metadata_dict[dim_name].ravel()[indices]
+                    for dim_name in dimension_names
+                ]
+
             else:
                 raise TooManyDimensionsForRockingCurvesError()
 
+            data[indices], maps = fit_rocking_curve_parallel(
+                data=self.as_array3d(indices),
+                motor_values=motor_values,
+                thresh=int_thresh,
+                method=method,
+            )
+
         return (
             new_dataset,
             maps,

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/core/noiseremoval.py

@@ -71,36 +71,33 @@ def apply_noise_removal_operation(
         apply_mask_removal(image, **operation["parameters"])
 
 
-def create_background_substraction_operation(
+def add_background_data_into_operation(
     dataset: Dataset,
-    method: str | None = None,
-    background_type: BackgroundType | None = None,
+    operation: NoiseRemovalOperation,
 ) -> NoiseRemovalOperation:
     """Compute a background image and return a NoiseRemovalOperation with a background parameter"""
 
-    if method is None:
-        method = imageOperations.Method.MEDIAN
+    if operation["type"] is not Operation.BS:
+        raise ValueError("Operation type should be `Operation.BS`")
 
-    if background_type is not None:
-        background_type = BackgroundType(background_type)
+    method = operation["parameters"].get("method", imageOperations.Method.MEDIAN)
 
-    if background_type == BackgroundType.DARK_DATA:
+    background_type = BackgroundType(
+        operation["parameters"].get("background_type", BackgroundType.DATA.value)
+    )
+
+    if background_type is BackgroundType.DARK_DATA:
         bg = dataset.bg_dataset.as_array3d()
-    elif background_type == BackgroundType.UNUSED_DATA:
+    elif background_type is BackgroundType.UNUSED_DATA:
         bg = dataset.dataset.as_array3d(dataset.bg_indices)
-    elif background_type == BackgroundType.DATA:
+    elif background_type is BackgroundType.DATA:
         bg = dataset.dataset.as_array3d()
     else:
         raise NotImplementedError(
             f"Background type {background_type!r} not implemented yet."
         )
-    parameters = dict(method=method, background_type=background_type)
 
-    return NoiseRemovalOperation(
-        type=Operation.BS,
-        parameters=parameters,
-        background=imageOperations.compute_background(bg, method),
-    )
+    operation["background"] = imageOperations.compute_background(bg, method)
 
 
 def apply_background_substraction(

darfix-4.2.0/src/darfix/core/rocking_curves.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy
+import tqdm
+from joblib import Parallel
+from joblib import delayed
+
+from ..io.utils import create_nxdata_dict
+from ..processing.rocking_curves import FitMethod
+from ..processing.rocking_curves import fit_1d_rocking_curve
+from ..processing.rocking_curves import fit_2d_rocking_curve
+from ..processing.rocking_curves import fit_3d_rocking_curve
+from .rocking_curves_map import MAPS_1D
+from .rocking_curves_map import MAPS_2D
+from .rocking_curves_map import MAPS_3D
+from .rocking_curves_map import Maps_1D
+from .utils import NoDimensionsError
+from .utils import TooManyDimensionsForRockingCurvesError
+
+
+def _rocking_curves_per_px(data: numpy.ndarray):
+    """
+    Generator that returns the rocking curve for every pixel
+
+    :param ndarray data: data to analyse
+    """
+    for j in range(data.shape[1]):
+        for i in range(data.shape[2]):
+            yield data[:, j, i]
+
+
+def _wrap_fit_function(fit_function, motor_values, thresh, method, curve_per_px):
+    """
+    Just a wrapper to pack the result of the fit.
+
+    See `_fit_xd_data` for parameters details and typing
+    """
+
+    y_gauss, fit_result = fit_function(curve_per_px, motor_values, method, thresh)
+
+    return y_gauss, fit_result
+
+
+def fit_rocking_curve_parallel(
+    data: numpy.ndarray,
+    motor_values: Sequence[numpy.ndarray] | numpy.ndarray,
+    thresh: float | None,
+    method: FitMethod | None,
+) -> tuple[numpy.ndarray, numpy.ndarray]:
+    """
+    Fit the rocking curves using multiprocessing.
+
+    :param data: 3D data [N frames, height, width] array to fit.
+    :param motor_values: x values associated to axis 0 of the 3D data. Can be 2D [dims count, N frames] or 1D [N frames]
+    :param thresh: Optional threshold value for each rocking curve. If Peak-to-peak value is nelow this threshold, data is not fitted.
+    :param method: Method to use in `scipy.optimize.curve_fit`.
+
+    :return:
+    - Fitted 3D data array [N frames, height, width]
+    - A [len_maps, height, width] 3D array of the fit parameters.
+    """
+
+    motor_values = numpy.asarray(motor_values, numpy.float64)
+    height, width = data.shape[-2:]
+
+    if motor_values.ndim == 1:
+        fit_function = fit_1d_rocking_curve
+        len_maps = len(MAPS_1D)
+    elif motor_values.ndim == 2 and motor_values.shape[0] == 2:
+        fit_function = fit_2d_rocking_curve
+        len_maps = len(MAPS_2D)
+    elif motor_values.ndim == 2 and motor_values.shape[0] == 3:
+        fit_function = fit_3d_rocking_curve
+        len_maps = len(MAPS_3D)
+    else:
+        raise ValueError(f"motor_values has a bad shape : {motor_values.shape}")
+
+    output_data = numpy.zeros_like(data)
+    maps = numpy.full((len_maps,) + data.shape[-2:], numpy.nan)
+
+    with Parallel(n_jobs=-1, return_as="generator") as parallel_processing:
+        results = parallel_processing(
+            delayed(_wrap_fit_function)(
+                fit_function, motor_values, thresh, method, curve
+            )
+            for curve in _rocking_curves_per_px(data)
+        )
+
+        for idx, (y_gauss, maps_ji) in tqdm.tqdm(
+            enumerate(results), desc="Fit rocking curves", total=height * width
+        ):
+            j = idx // data.shape[2]
+            i = idx % data.shape[2]
+            output_data[:, j, i] = y_gauss
+            maps[:, j, i] = maps_ji
+
+    return output_data, maps
+
+
+def generate_rocking_curves_nxdict(
+    dataset,  # ImageDataset. Cannot type due to circular import
+    maps: numpy.ndarray,
+    residuals: numpy.ndarray | None,
+) -> dict:
+    if not dataset.dims.ndim:
+        raise NoDimensionsError("generate_rocking_curves_nxdict")
+    entry = "entry"
+
+    nx = {
+        entry: {"@NX_class": "NXentry"},
+        "@NX_class": "NXroot",
+        "@default": entry,
+    }
+
+    if dataset.transformation:
+        axes = [
+            dataset.transformation.yregular,
+            dataset.transformation.xregular,
+        ]
+        axes_names = ["y", "x"]
+        axes_long_names = [
+            dataset.transformation.label,
+            dataset.transformation.label,
+        ]
+    else:
+        axes = None
+        axes_names = None
+        axes_long_names = None
+
+    if dataset.dims.ndim == 1:
+        map_names = MAPS_1D
+    elif dataset.dims.ndim == 2:
+        map_names = MAPS_2D
+    elif dataset.dims.ndim == 3:
+        map_names = MAPS_3D
+    else:
+        raise TooManyDimensionsForRockingCurvesError()
+
+    for i, map_name in enumerate(map_names):
+        signal = maps[i]
+        nx[entry][map_name] = create_nxdata_dict(
+            signal, map_name, axes, axes_names, axes_long_names
+        )
+    if residuals is not None:
+        nx[entry]["Residuals"] = create_nxdata_dict(
+            residuals, "Residuals", axes, axes_names, axes_long_names
+        )
+    nx[entry]["@default"] = Maps_1D.AMPLITUDE.value
+
+    return nx
+
+
+def compute_residuals(
+    target_dataset,  # ImageDataset. Cannot type due to circular import
+    original_dataset,  # ImageDataset. Cannot type due to circular import
+    indices: numpy.ndarray | None,
+):
+    return numpy.sqrt(
+        (
+            numpy.subtract(
+                target_dataset.as_array3d(indices),
+                original_dataset.as_array3d(indices),
+            )
+            ** 2
+        ).sum(axis=(0))
+    )

darfix-4.2.0/src/darfix/core/rocking_curves_map.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from enum import Enum as _Enum
+
+
+class Maps_1D(_Enum):
+    """Names of the fitting parameters of the 1D fit result. Each result is a map of frame size."""
+
+    AMPLITUDE = "Amplitude"
+    FWHM = "FWHM"
+    PEAK = "Peak position"
+    BACKGROUND = "Background"
+
+
+class Maps_2D(_Enum):
+    """Names of the fitting parameters of the 2D fit result. Each result is a map of frame size."""
+
+    PEAK_X = "Peak position first motor"
+    PEAK_Y = "Peak position second motor"
+    FWHM_X = "FWHM first motor"
+    FWHM_Y = "FWHM second motor"
+    AMPLITUDE = "Amplitude"
+    CORRELATION = "Correlation"
+    BACKGROUND = "Background"
+
+
+class Maps_3D(_Enum):
+    """Names of the fitting parameters of the 3D fit result. Each result is a map of frame size."""
+
+    PEAK_X = "Peak position first motor"
+    PEAK_Y = "Peak position second motor"
+    PEAK_Z = "Peak position third motor"
+    FWHM_X = "FWHM first motor"
+    FWHM_Y = "FWHM second motor"
+    FWHM_Z = "FWHM third motor"
+    CORRELATION_XY = "Cross-correlation between first and second motors"
+    CORRELATION_XZ = "Cross-correlation between first and third motors"
+    CORRELATION_YZ = "Cross-correlation between second and third motors"
+    AMPLITUDE = "Amplitude"
+    BACKGROUND = "Background"
+
+
+MAPS_1D: tuple[Maps_1D] = tuple(member.value for member in Maps_1D)
+MAPS_2D: tuple[Maps_2D] = tuple(member.value for member in Maps_2D)
+MAPS_3D: tuple[Maps_3D] = tuple(member.value for member in Maps_3D)

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/gui/noiseremoval/noise_removal_widget.py

@@ -13,8 +13,9 @@ from darfix import config
 from darfix import dtypes
 from darfix.core.noiseremoval import BackgroundType
 from darfix.core.noiseremoval import NoiseRemovalOperation
+from darfix.core.noiseremoval import add_background_data_into_operation
 from darfix.core.noiseremoval import apply_noise_removal_operation
-from darfix.core.noiseremoval import create_background_substraction_operation
+from darfix.core.noiseremoval import operation_to_str
 from darfix.core.state_of_operation import Operation
 from darfix.gui.operationThread import OperationThread
 
@@ -132,10 +133,10 @@ class NoiseRemovalWidget(qt.QWidget):
     def setDataset(self, dataset: dtypes.Dataset):
         """Saves the dataset and updates the stack with the dataset data."""
 
-        self._operationList.clear()
         self._plot.clear()
 
         self._dataset = dataset
+
         if self._imgDataset.title != "":
             self._plot.setTitleCallback(lambda idx: self._imgDataset.title)
 
@@ -163,30 +164,50 @@ class NoiseRemovalWidget(qt.QWidget):
             )
         self._parametersWidget.bsBackgroundCB.addItem(BackgroundType.DATA.value)
 
+        opersations = self._operationList.getOperations()
+
+        if (
+            len(opersations) > 0
+            and qt.QMessageBox.question(
+                self,
+                "Keep operation list ?",
+                "Do you want to restore these operations ?\n\n - "
+                + "\n - ".join([operation_to_str(op) for op in opersations]),
+            )
+            == qt.QMessageBox.StandardButton.Yes
+        ):
+            for operation in opersations:
+                if operation["type"] is Operation.BS:
+                    self._computeBackgroundAsync(operation)
+        else:
+            self._operationList.clear()
+
     def _launchBackgroundSubtraction(self):
-        self._computeBackgroundAsync(
-            self._parametersWidget.bsBackgroundCB.currentText(),
-            self._parametersWidget.bsMethodsCB.currentText(),
+        operation = NoiseRemovalOperation(
+            type=Operation.BS,
+            parameters={
+                "method": self._parametersWidget.bsMethodsCB.currentText(),
+                "background_type": self._parametersWidget.bsBackgroundCB.currentText(),
+            },
         )
+        self._operationList.append(operation)
+        self._computeBackgroundAsync(operation)
 
-    def _computeBackgroundAsync(self, background_type: str, method: str):
+    def _computeBackgroundAsync(self, operation: NoiseRemovalOperation):
 
         assert (
             self._backgroundComputationThread is None
         ), "Computation thread is expected to be None."
 
         self._parametersWidget.setDisabled(True)
+        self._browser.setDisabled(True)
         self._parametersWidget.computeBS.setWaiting(True)
 
-        # Here the background image is computed.
+        # Here the background image data is computed.
         self._backgroundComputationThread = OperationThread(
-            self, create_background_substraction_operation
-        )
-        self._backgroundComputationThread.setArgs(
-            self._dataset,
-            method,
-            background_type,
+            self, add_background_data_into_operation
         )
+        self._backgroundComputationThread.setArgs(self._dataset, operation)
         self._backgroundComputationThread.finished.connect(
             self._onBackgroundComputationFinish
         )
@@ -194,19 +215,12 @@ class NoiseRemovalWidget(qt.QWidget):
 
     def _onBackgroundComputationFinish(self):
         self._parametersWidget.setEnabled(True)
+        self._browser.setEnabled(True)
         self._parametersWidget.computeBS.setWaiting(False)
 
-        if self._backgroundComputationThread.data is None:
-            raise RuntimeError("An exception occured during background computation.")
-
-        # Result of `create_background_substraction_operation` is a new operation that contains the pre-computed 2D background image
-        operation = self._backgroundComputationThread.data
-
         self._backgroundComputationThread = None
 
-        if operation is not None:
-            self._operationList.append(operation)
-            self.refreshPlot()
+        self.refreshPlot()
 
     def _launchHotPixelRemoval(self):
         size = self._parametersWidget.hpSizeCB.currentText()

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/gui/rocking_curves/fitComboBox.py

@@ -18,4 +18,4 @@ class FitComboBox(qt.QComboBox):
             "Unbounded Levenberg-Marquardt algorithm as implemented in MINPACK. Doesn’t handle bounds and sparse Jacobians. Usually the most efficient method for small unconstrained problems.",
         )
 
-        self.setCurrentText("lm")
+        self.setCurrentText("trf")  # The most stable

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/gui/rocking_curves/rockingCurvesPlot.py

@@ -234,28 +234,27 @@ class RockingCurvesPlot(qt.QWidget):
         origin = self._computeFitPlotOrigin(dim1, dim0)
         scale = self._computeFitPlotScale(dim1, dim0)
         self._fitPlot.remove(kind="curve")
+        x_values = numpy.stack(
+            [
+                dataset.get_metadata_values(key=dim0.name),
+                dataset.get_metadata_values(key=dim1.name),
+            ]
+        )
+
         try:
-            y_gauss, pars = fit_2d_rocking_curve(
-                (y_values, None),
-                x_values=[
-                    dataset.get_metadata_values(key=dim0.name),
-                    dataset.get_metadata_values(key=dim1.name),
-                ],
-                shape=(dim0.size, dim1.size),
-            )
-            if numpy.array_equal(y_gauss, y_values):
-                raise RuntimeError()
-            y_gauss = numpy.reshape(y_gauss, (dim1.size, dim0.size)).T
+            y_gauss, pars = fit_2d_rocking_curve(rocking_curve, x_values)
 
         except (TypeError, RuntimeError):
-            _logger.warning("Cannot fit")
+            _logger.warning("Cannot fit", exc_info=True)
+            y_gauss = numpy.full_like(rocking_curve, numpy.nan)
         else:
             self._lastFitParamsLabel.setText(
                 "PEAK_X:{:.3f} PEAK_Y:{:.3f} FWHM_X:{:.3f} FWHM_Y:{:.3f} AMP:{:.3f} CORR:{:.3f} BG:{:.3f}".format(
                     *pars
                 )
             )
-            image = numpy.reshape(y_values, (dim1.size, dim0.size)).T
+            image = numpy.reshape(rocking_curve, (dim1.size, dim0.size)).T
+            fit_image = numpy.reshape(y_gauss, (dim1.size, dim0.size)).T
             self._fitPlot.addImage(
                 image,
                 xlabel=dim1.name,
@@ -264,7 +263,7 @@ class RockingCurvesPlot(qt.QWidget):
                 scale=scale,
                 legend=FIT_IMAGE_LEGEND,
             )
-            contours = compute_contours(image)
+            contours = compute_contours(fit_image)
             self._addFitContours(contours)
 
         frameNumber = self._sv.getFrameNumber()
@@ -289,15 +288,13 @@ class RockingCurvesPlot(qt.QWidget):
         self._fitPlot.setGraphYLabel("Intensity")
         i = self._sv.getFrameNumber()
         try:
-            y_gauss, pars = fit_1d_rocking_curve(
-                (numpy.array(rocking_curve), None), x_values=x, num_points=1000
-            )
+            y_gauss, pars = fit_1d_rocking_curve(rocking_curve, x)
             self._lastFitParamsLabel.setText(
                 "AMP:{:.3f} PEAK:{:.3f} FWHM:{:.3f} BG:{:.3f}".format(*pars)
             )
-        except TypeError:
-            y_gauss = rocking_curve
-            _logger.warning("Cannot fit")
+        except (TypeError, RuntimeError):
+            _logger.warning("Cannot fit", exc_info=True)
+            y_gauss = numpy.full_like(rocking_curve, numpy.nan)
         else:
             x_gauss = numpy.linspace(x[0], x[-1], len(y_gauss))
             self._fitPlot.addCurve(x_gauss, y_gauss, legend="fit", color="r")

{darfix-4.1.1 → darfix-4.2.0}/src/darfix/gui/rocking_curves/rockingCurvesWidget.py

@@ -9,10 +9,10 @@ from silx.io.dictdump import dicttonx
 
 from ... import dtypes
 from ...core.dataset import Operation
-from ...core.rocking_curves import MAPS_1D
-from ...core.rocking_curves import MAPS_2D
-from ...core.rocking_curves import MAPS_3D
 from ...core.rocking_curves import generate_rocking_curves_nxdict
+from ...core.rocking_curves_map import MAPS_1D
+from ...core.rocking_curves_map import MAPS_2D
+from ...core.rocking_curves_map import MAPS_3D
 from ...core.utils import NoDimensionsError
 from ...core.utils import TooManyDimensionsForRockingCurvesError
 from ..utils.message import missing_dataset_msg