darfix 4.2.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

darfix/gui/{grainplot/mosaicityWidget.py → grain_plot/mosaicity_widget.py}

@@ -6,12 +6,11 @@ from silx.gui.colors import Colormap
 from silx.gui.plot.items import ImageBase
 from silx.image.marchingsquares import find_contours
 
-from darfix.gui.grainplot.dimensionRangeSlider2D import DimensionRangeSlider2D
+from darfix.gui.grain_plot.dimension_range_slider_2d import DimensionRangeSlider2D
 
+from ...core.grainplot import GrainPlotData
 from ...core.grainplot import GrainPlotMaps
 from ...core.grainplot import MultiDimMomentType
-from ...core.grainplot import OrientationDistData
-from ...core.grainplot import compute_mosaicity
 from ...core.moment_types import MomentType
 from .flashlight import PlotWithFlashlight
 from .oridist_toolbar import OriDistButtonIds
@@ -27,8 +26,7 @@ class MosaicityWidget(qt.QWidget):
         super().__init__(parent)
 
         self._grainPlotMaps: GrainPlotMaps | None = None
-        self._orientation_dist_data: OrientationDistData | None = None
-        self._mosaicity: numpy.ndarray | None = None
+        self._orientation_dist_data: GrainPlotData | None = None
         self.contours = {}
 
         layout = qt.QGridLayout()
@@ -86,7 +84,7 @@ class MosaicityWidget(qt.QWidget):
         layout.addWidget(separator, 2, 0, 1, 2)
 
         #
-        # zsum threshold
+        # zsum threshold and colormap selection
         # Row 3
         #
 
@@ -98,8 +96,15 @@ class MosaicityWidget(qt.QWidget):
         """ Discard mosa values below this threshold """
         self._thresholdSB.setButtonSymbols(qt.QAbstractSpinBox.ButtonSymbols.NoButtons)
         self._thresholdSB.editingFinished.connect(self._computeMosaicityAndOriDist)
-        thresholdLayout.addWidget(qt.QLabel("ZSum Threshold : "))
+        self._colormapCB = qt.QComboBox()
+        """ Combo box to select one of the colormap of `colorstamps` package. """
+        self._colormapCB.addItems(["hsv", "cut", "orangeBlue", "flat"])
+        self._colormapCB.currentTextChanged.connect(self._computeMosaicityAndOriDist)
+        thresholdLayout.addWidget(qt.QLabel("ZSum Threshold"))
         thresholdLayout.addWidget(self._thresholdSB)
+        thresholdLayout.addSpacing(20)
+        thresholdLayout.addWidget(qt.QLabel("Colormap"))
+        thresholdLayout.addWidget(self._colormapCB)
         thresholdLayout.addStretch(1)
         layout.addLayout(thresholdLayout, 3, 0)
 
@@ -123,7 +128,7 @@ class MosaicityWidget(qt.QWidget):
         return self._sliders.indexDimY()
 
     def getMosaicity(self):
-        return self._mosaicity
+        return self._orientation_dist_data.mosaicity
 
     def getContoursImage(self):
         return self._oriDistPlot.getImage()
@@ -147,13 +152,14 @@ class MosaicityWidget(qt.QWidget):
         self._computeMosaicityAndOriDist()
 
     def _plotMosaicity(self):
-        if self._grainPlotMaps is None:
+        if self._grainPlotMaps is None or self._orientation_dist_data is None:
             return
 
-        if self._mosaicity is not None:
-            add_image_with_transformation(
-                self._mosaicityPlot, self._mosaicity, self._grainPlotMaps.transformation
-            )
+        add_image_with_transformation(
+            self._mosaicityPlot,
+            self._orientation_dist_data.mosaicity,
+            self._grainPlotMaps.transformation,
+        )
 
     def _plotOrientationData(self, state=None):
         if self._grainPlotMaps is None or self._orientation_dist_data is None:
@@ -360,22 +366,14 @@ class MosaicityWidget(qt.QWidget):
         zsum = self._grainPlotMaps.zsum.copy()
         zsum[maskZsum] = 0
 
-        self._mosaicity = compute_mosaicity(
-            self._grainPlotMaps.moments_dims,
-            x_dimension=self.dimension1,
-            y_dimension=self.dimension2,
-            x_dimension_range=self._sliders.rangeDimX(),
-            y_dimension_range=self._sliders.rangeDimY(),
-        )
-        self._mosaicity[maskZsum] = 0, 0, 0  # Black
-
-        self._orientation_dist_data = OrientationDistData(
+        self._orientation_dist_data = GrainPlotData(
             self._grainPlotMaps,
             x_dimension=self.dimension1,
             y_dimension=self.dimension2,
             x_dimension_range=self._sliders.rangeDimX(),
             y_dimension_range=self._sliders.rangeDimY(),
             zsum=zsum,
+            colormap_name=self._colormapCB.currentText(),
         )
         self._plotMosaicity()
         self._plotOrientationData()

darfix/gui/{magnificationWidget.py → magnification_widget.py}

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from enum import Enum as _Enum
 
-from ewoksorange.gui.parameterform import block_signals
+from ewoksorange.gui.widgets.parameter_form import block_signals
 from silx.gui import qt
 
 

darfix/gui/{noiseremoval → noise_removal}/noise_removal_widget.py

@@ -11,13 +11,13 @@ from silx.gui.widgets.FrameBrowser import HorizontalSliderWithBrowser
 
 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 operation_to_str
-from darfix.core.state_of_operation import Operation
-from darfix.gui.operationThread import OperationThread
+from darfix.core.noise_removal import BackgroundType
+from darfix.core.noise_removal import NoiseRemovalOperation
+from darfix.core.noise_removal import add_background_data_into_operation
+from darfix.core.noise_removal import apply_noise_removal_operation
+from darfix.core.noise_removal import operation_to_str
+from darfix.core.noise_removal_type import NoiseRemovalType
+from darfix.gui.parallel.operation_thread import OperationThread
 
 from .operation_list_widget import OperationListWidget
 from .parameters_widget import ParametersWidget
@@ -158,10 +158,6 @@ class NoiseRemovalWidget(qt.QWidget):
             self._parametersWidget.bsBackgroundCB.addItem(
                 BackgroundType.DARK_DATA.value
             )
-        if dataset.bg_indices is not None:
-            self._parametersWidget.bsBackgroundCB.addItem(
-                BackgroundType.UNUSED_DATA.value
-            )
         self._parametersWidget.bsBackgroundCB.addItem(BackgroundType.DATA.value)
 
         opersations = self._operationList.getOperations()
@@ -177,14 +173,14 @@ class NoiseRemovalWidget(qt.QWidget):
             == qt.QMessageBox.StandardButton.Yes
         ):
             for operation in opersations:
-                if operation["type"] is Operation.BS:
+                if operation["type"] is NoiseRemovalType.BS:
                     self._computeBackgroundAsync(operation)
         else:
             self._operationList.clear()
 
     def _launchBackgroundSubtraction(self):
         operation = NoiseRemovalOperation(
-            type=Operation.BS,
+            type=NoiseRemovalType.BS,
             parameters={
                 "method": self._parametersWidget.bsMethodsCB.currentText(),
                 "background_type": self._parametersWidget.bsBackgroundCB.currentText(),
@@ -226,7 +222,7 @@ class NoiseRemovalWidget(qt.QWidget):
         size = self._parametersWidget.hpSizeCB.currentText()
 
         operation = NoiseRemovalOperation(
-            type=Operation.HP,
+            type=NoiseRemovalType.HP,
             parameters={
                 "kernel_size": int(size),
             },
@@ -247,7 +243,7 @@ class NoiseRemovalWidget(qt.QWidget):
             top_threshold = None
 
         operation = NoiseRemovalOperation(
-            type=Operation.THRESHOLD,
+            type=NoiseRemovalType.THRESHOLD,
             parameters={
                 "bottom": bottom_threshold,
                 "top": top_threshold,
@@ -261,7 +257,7 @@ class NoiseRemovalWidget(qt.QWidget):
         if mask is None:
             return
         operation = NoiseRemovalOperation(
-            type=Operation.MASK,
+            type=NoiseRemovalType.MASK,
             parameters={"mask": mask},
         )
         self._operationList.append(operation)

darfix/gui/{noiseremoval → noise_removal}/operation_list_widget.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from silx.gui import qt
 
-from ...core.noiseremoval import NoiseRemovalOperation
-from ...core.noiseremoval import operation_to_str
+from ...core.noise_removal import NoiseRemovalOperation
+from ...core.noise_removal import operation_to_str
 
 
 class OperationListWidget(qt.QWidget):

darfix/gui/{noiseremoval → noise_removal}/parameters_widget.py

@@ -5,9 +5,9 @@ from typing import Optional
 from silx.gui import qt
 from silx.gui.widgets.WaitingPushButton import WaitingPushButton
 
-from darfix.core.noiseremoval import NoiseRemovalOperation
-from darfix.core.noiseremoval import Operation
-from darfix.processing.imageOperations import Method
+from darfix.core.noise_removal import NoiseRemovalOperation
+from darfix.core.noise_removal import NoiseRemovalType
+from darfix.processing.image_operations import Method
 
 _logger = logging.getLogger(__file__)
 
@@ -98,19 +98,19 @@ class ParametersWidget(qt.QWidget):
         # follow history to obtain last values set by the user
         for operation in history:
             try:
-                if operation["type"] is Operation.BS:
+                if operation["type"] is NoiseRemovalType.BS:
                     index = self.bsMethodsCB.findText(
                         str(operation["parameters"]["method"])
                     )
                     if index > 0:
                         self.bsMethodsCB.setCurrentIndex(index)
-                elif operation["type"] is Operation.HP:
+                elif operation["type"] is NoiseRemovalType.HP:
                     index = self.hpSizeCB.findText(
                         str(operation["parameters"]["kernel_size"])
                     )
                     if index > 0:
                         self.hpSizeCB.setCurrentIndex(index)
-                elif operation["type"] is Operation.THRESHOLD:
+                elif operation["type"] is NoiseRemovalType.THRESHOLD:
                     if operation["parameters"]["bottom"] is not None:
                         self.bottomLE.setText(str(operation["parameters"]["bottom"]))
                     if operation["parameters"]["top"] is not None:

darfix/gui/{PCAWidget.py → pca_widget.py}

@@ -6,7 +6,7 @@ from silx.gui.plot import Plot1D
 
 from darfix import dtypes
 
-from .operationThread import OperationThread
+from .parallel.operation_thread import OperationThread
 
 
 class PCAPlot(Plot1D):
@@ -43,7 +43,7 @@ class PCAWidget(qt.QMainWindow):
     def _computePCA(self):
         try:
             self._thread = OperationThread(self, self._dataset.pca)
-            self._thread.setArgs(return_vals=True, indices=self.indices)
+            self._thread.setArgs(return_vals=True)
             self._thread.finished.connect(self._updateData)
             self._thread.start()
         except Exception as e:
@@ -51,8 +51,6 @@ class PCAWidget(qt.QMainWindow):
 
     def setDataset(self, dataset: dtypes.Dataset):
         self._dataset = dataset.dataset
-        self.indices = dataset.indices
-        self.bg_indices = dataset.bg_indices
         self.bg_dataset = dataset.bg_dataset
         self._computePCA()
 

darfix/gui/{projectionWidget.py → projection_widget.py}

@@ -4,7 +4,7 @@ from silx.gui.plot.StackView import StackViewMainWindow
 
 from .. import config
 from ..dtypes import ImageDataset
-from .chooseDimensions import ChooseDimensionWidget
+from .choose_dimensions import ChooseDimensionWidget
 
 
 class ProjectionWidget(qt.QWidget):

darfix/gui/rocking_curves/{rockingCurvesPlot.py → rocking_curves_plot.py}

@@ -10,6 +10,8 @@ from silx.gui.plot import StackView
 from silx.gui.plot.items.image import ImageStack
 
 import darfix
+from darfix.math import bivariate_gaussian
+from darfix.math import gaussian
 
 from ...core.dataset import ImageDataset
 from ...core.dimension import Dimension
@@ -65,11 +67,9 @@ class RockingCurvesPlot(qt.QWidget):
         layout.addWidget(self._fitPlotGroup)
 
         self._dataset: ImageDataset | None = None
-        self._indices = None
 
     def setDataset(self, dataset: Dataset):
         self._dataset = dataset.dataset
-        self._indices = dataset.indices
 
         if self._dataset.dims.ndim == 3:
             # fitplot would be a 3D plot ? Not implemented for now.
@@ -87,7 +87,7 @@ class RockingCurvesPlot(qt.QWidget):
         if self._dataset is None:
             stack = None
         else:
-            stack = self._dataset.as_array3d(self._indices)
+            stack = self._dataset.as_array3d()
 
         self._sv.setStack(stack)
         self._sv.setFrameNumber(nframe)
@@ -206,7 +206,7 @@ class RockingCurvesPlot(qt.QWidget):
             return
 
         try:
-            data = self._dataset.as_array3d(self._indices)
+            data = self._dataset.as_array3d()
             if isinstance(data, numpy.ndarray):
                 rocking_curve = data[:, int(py), int(px)]
             else:
@@ -224,8 +224,6 @@ class RockingCurvesPlot(qt.QWidget):
             raise TooManyDimensionsForRockingCurvesError()
 
     def _plot2DRockingCurve(self, dataset: ImageDataset, rocking_curve: numpy.ndarray):
-        y_values = numpy.zeros(dataset.nframes)
-        y_values[self._indices] = rocking_curve
         dim1 = dataset.dims.get(1)
         dim0 = dataset.dims.get(0)
         assert dim1 is not None
@@ -242,7 +240,9 @@ class RockingCurvesPlot(qt.QWidget):
         )
 
         try:
-            y_gauss, pars = fit_2d_rocking_curve(rocking_curve, x_values)
+            _, pars = fit_2d_rocking_curve(rocking_curve, x_values)
+            # Recompute fitted y without any masking (Better vizualisation of the gaussian contours)
+            y_gauss = bivariate_gaussian(x_values, *pars)
 
         except (TypeError, RuntimeError):
             _logger.warning("Cannot fit", exc_info=True)
@@ -272,7 +272,7 @@ class RockingCurvesPlot(qt.QWidget):
     def _plot1DRockingCurve(self, dataset: ImageDataset, rocking_curve: numpy.ndarray):
         dim = dataset.dims.get(0)
         assert dim is not None
-        motor_values = dataset.get_metadata_values(key=dim.name, indices=self._indices)
+        motor_values = dataset.get_metadata_values(key=dim.name)
         if self._axisTypeComboBox.getCurrentAxisType() == "dims":
             self._fitPlot.setGraphXLabel(dim.name)
             x = motor_values
@@ -288,7 +288,9 @@ class RockingCurvesPlot(qt.QWidget):
         self._fitPlot.setGraphYLabel("Intensity")
         i = self._sv.getFrameNumber()
         try:
-            y_gauss, pars = fit_1d_rocking_curve(rocking_curve, x)
+            _, pars = fit_1d_rocking_curve(rocking_curve, x)
+            # Recompute fitted y without any masking (Better vizualisation of the gaussian contours)
+            y_gauss = gaussian(x, *pars)
             self._lastFitParamsLabel.setText(
                 "AMP:{:.3f} PEAK:{:.3f} FWHM:{:.3f} BG:{:.3f}".format(*pars)
             )
@@ -296,9 +298,7 @@ class RockingCurvesPlot(qt.QWidget):
             _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")
-            i_gauss = i * int((len(y_gauss) - 1) / (len(x) - 1))
-            self._addFitMarker(x_gauss[i_gauss], y_gauss[i_gauss])
+            self._fitPlot.addCurve(x, y_gauss, legend="fit", color="r")
+            self._addFitMarker(x[i], y_gauss[i])
 
         self._addDataMarker(x[i], rocking_curve[i])

darfix/gui/rocking_curves/{rockingCurvesWidget.py → rocking_curves_widget.py}

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import numpy
-from ewoksorange.gui.parameterform import block_signals
+from ewoksorange.gui.widgets.parameter_form import block_signals
 from silx.gui import qt
 from silx.gui.colors import Colormap
 from silx.gui.plot import Plot2D
 from silx.io.dictdump import dicttonx
 
 from ... import dtypes
-from ...core.dataset import Operation
+from ...core.rocking_curves import compute_residuals
 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
@@ -17,8 +17,8 @@ from ...core.utils import NoDimensionsError
 from ...core.utils import TooManyDimensionsForRockingCurvesError
 from ..utils.message import missing_dataset_msg
 from ..utils.utils import select_output_hdf5_file_with_dialog
-from .fitComboBox import FitComboBox
-from .rockingCurvesPlot import RockingCurvesPlot
+from .fit_combobox import FitComboBox
+from .rocking_curves_plot import RockingCurvesPlot
 
 # "Residuals" are not given by the fit but computed by the widget.
 # It needs to be handled separately of other `MAPS` values
@@ -43,12 +43,12 @@ class RockingCurvesWidget(qt.QWidget):
     """
 
     sigFitClicked = qt.Signal()
+    sigAbortClicked = qt.Signal()
 
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent)
 
         self.dataset = None
-        self.indices = None
         self._update_dataset = None
         self._residuals_cache = None
         self.maps = None
@@ -77,7 +77,8 @@ class RockingCurvesWidget(qt.QWidget):
         self._abortFitBtn = qt.QPushButton("Abort")
         self._abortFitBtn.hide()
         self._abortFitBtn.clicked.connect(self.__abort)
-        layout.addWidget(self._abortFitBtn)
+        self._abortFitBtn.clicked.connect(self.sigAbortClicked)
+        fitLayout.addWidget(self._abortFitBtn)
 
         self._mapsCB = qt.QComboBox(self)
         self._mapsCB.hide()
@@ -102,7 +103,6 @@ class RockingCurvesWidget(qt.QWidget):
         if not dataset.dataset.dims.ndim:
             raise NoDimensionsError("RockingCurvesWidget")
         self.dataset = dataset.dataset
-        self.indices = dataset.indices
         self._update_dataset = dataset.dataset
         self._residuals_cache = None
 
@@ -133,8 +133,7 @@ class RockingCurvesWidget(qt.QWidget):
 
         self._launchFitBtn.hide()
         self.sigFitClicked.emit()
-        # TODO: Abort button is not working
-        # self._abortFit.show()
+        self._abortFitBtn.show()
 
     def _computeResiduals(self) -> numpy.ndarray | None:
         """Note: The computation is cached as long as the dataset is loaded."""
@@ -145,12 +144,7 @@ class RockingCurvesWidget(qt.QWidget):
         if self._residuals_cache is not None:
             return self._residuals_cache
 
-        self._residuals_cache = numpy.sqrt(
-            numpy.subtract(
-                self._update_dataset.zsum(self.indices), self.dataset.zsum(self.indices)
-            )
-            ** 2
-        )
+        self._residuals_cache = compute_residuals(self._update_dataset, self.dataset)
         return self._residuals_cache
 
     def _displayMap(self, map_name: str):
@@ -178,9 +172,7 @@ class RockingCurvesWidget(qt.QWidget):
         self._addImage(self.maps[self._mapsCB.currentIndex()])
 
     def __abort(self):
-        self._abortFitBtn.setEnabled(False)
-        if self.dataset is not None:
-            self.dataset.stop_operation(Operation.FIT)
+        self._abortFitBtn.hide()
 
     def onFitFinished(self):
         self._abortFitBtn.hide()

darfix/gui/{roiSelectionWidget.py → roi_selection_widget.py}

@@ -4,8 +4,6 @@ __date__ = "26/04/2021"
 
 import logging
 
-import silx
-from packaging.version import Version
 from silx.gui import qt
 from silx.gui.colors import Colormap
 from silx.gui.plot.items.roi import RectangleROI
@@ -16,7 +14,7 @@ import darfix
 from darfix import dtypes
 from darfix.core.roi import clampROI
 
-from .roiLimitsToolbar import RoiLimitsToolBar
+from .roi_limits_toolbar import RoiLimitsToolBar
 
 _logger = logging.getLogger(__file__)
 
@@ -26,29 +24,11 @@ class ROISelectionWidget(qt.QWidget):
     Widget that allows the user to pick a ROI in any image of the dataset.
     """
 
-    sigValidate = qt.Signal()
-    """Emit when user wants to keep the current resized dataset and move to next widget"""
-
-    sigApply = qt.Signal()
-    """Emit when user wants to Apply a ROI. Then we wait for a refinement or a validation"""
-
-    sigReset = qt.Signal()
-    """Emit when user wants to come back to the initial dataset"""
-
-    sigROIChanged = qt.Signal()
-    """Emit when the roi is changed"""
-
     def __init__(self, parent=None):
         super().__init__(parent)
 
         self.setLayout(qt.QVBoxLayout())
         self._sv = StackViewMainWindow()
-        _buttons = qt.QDialogButtonBox(parent=self)
-
-        self._okB = _buttons.addButton(_buttons.Ok)
-        self._applyB = _buttons.addButton(_buttons.Apply)
-        self._resetB = _buttons.addButton(_buttons.Reset)
-        self._okB.setDefault(False)
 
         self._sv.setColormap(
             Colormap(
@@ -58,20 +38,13 @@ class ROISelectionWidget(qt.QWidget):
         )
         self._sv.setKeepDataAspectRatio(True)
         self.layout().addWidget(self._sv)
-        self.layout().addWidget(_buttons)
 
-        if Version(silx.version) < Version("2.0.0"):
-            plot = self._sv.getPlot()
-        else:
-            plot = self._sv.getPlotWidget()
+        plot = self._sv.getPlotWidget()
 
         self._roiManager = RegionOfInterestManager(plot)
 
         self._roi = RectangleROI()
-        if Version(silx.version) < Version("2.0.0"):
-            self._roi.setLabel("ROI")
-        else:
-            self._roi.setText("ROI")
+        self._roi.setText("ROI")
         self._roi.setGeometry(origin=(0, 0), size=(10, 10))
         self._roi.setEditable(True)
         self._roiManager.addRoi(self._roi)
@@ -79,20 +52,15 @@ class ROISelectionWidget(qt.QWidget):
         self._roiToolBar = RoiLimitsToolBar(roiManager=self._roiManager)
         self._sv.addToolBar(qt.Qt.BottomToolBarArea, self._roiToolBar)
 
-        # connect signal / slot
-        self._applyB.clicked.connect(self.applyRoi)
-        self._okB.clicked.connect(self.sigValidate)
-        self._resetB.clicked.connect(self.sigReset)
-        # self._roiManager.sigRoiChanged.connect(self.sigROIChanged)
-        self._roi.sigRegionChanged.connect(self.sigROIChanged)
-
-    def setDataset(self, dataset: dtypes.Dataset):
+    def setDataset(self, dataset: dtypes.Dataset, roiEnabled: bool = True):
         """Saves the dataset and updates the stack with the dataset data."""
         if dataset.dataset.title != "":
             self._sv.setGraphTitle(dataset.dataset.title)
-        self.setStack(dataset=dataset.dataset)
+        self._roi.setVisible(roiEnabled)
+        self._roiToolBar.setEnabled(roiEnabled)
+        self._setStack(dataset=dataset.dataset)
 
-    def _setROIForNewDataset(self, dataset: dtypes.ImageDataset):
+    def setROIForNewDataset(self, dataset: dtypes.ImageDataset):
         if not isinstance(dataset, dtypes.ImageDataset):
             raise dtypes.DatasetTypeError(dataset)
         first_frame_shape = dataset.frame_shape
@@ -100,7 +68,7 @@ class ROISelectionWidget(qt.QWidget):
         size = first_frame_shape[1] // 5, first_frame_shape[0] // 5
         self.setRoi(center=center, size=size)
 
-    def setStack(self, dataset: dtypes.ImageDataset):
+    def _setStack(self, dataset: dtypes.ImageDataset):
         """
         Sets new data to the stack.
         Maintains the current frame showed in the view.
@@ -145,63 +113,6 @@ class ROISelectionWidget(qt.QWidget):
         """
         return self._roi
 
-    def applyRoi(self):
-        """
-        Function to apply the region of interest at the data of the dataset
-        and show the new data in the stack. Dataset data is not yet replaced.
-        A new roi is created in the middle of the new stack.
-        """
-        if self._sv.getPlotWidget().getActiveImage() is None:
-            return
-
-        self.enableApplyingROI(False)
-        self.sigApply.emit()
-
-    def enableApplyingROI(self, enable: bool) -> None:
-        self._applyB.setEnabled(enable)
-
-    def _fitROIToDataset(self, dataset: dtypes.ImageDataset):
-        """
-        This function is called when the ROI is applied to the dataset.
-        The ROI must be updated to match the contour of the new shape.
-        """
-        dataset_shape = dataset.frame_shape
-        self._roi.setGeometry(
-            size=dataset_shape[::-1],
-            center=(dataset_shape[1] / 2.0, dataset_shape[0] / 2.0),
-        )
-
-    def setVisible(self, visible):
-        super().setVisible(visible)  # sets okB as default
-        self._okB.setDefault(False)
-
-    def getDataset(self) -> dtypes.Dataset:
-        return self._update_dataset
-
-    def getStackViewColormap(self):
-        """
-        Returns the colormap from the stackView
-
-        :rtype: silx.gui.colors.Colormap
-        """
-        return self._sv.getColormap()
-
-    def setStackViewColormap(self, colormap):
-        """
-        Sets the stackView colormap
-
-        :param colormap: Colormap to set
-        :type colormap: silx.gui.colors.Colormap
-        """
-        self._sv.setColormap(colormap)
-
-    def clearStack(self):
-        """
-        Clears stack.
-        """
-        self._sv.setStack(None)
-        self._roi.setGeometry(origin=(0, 0), size=(10, 10))
-
     def clampRoiToDataset(self, dataset: dtypes.ImageDataset):
         frame_height, frame_width = dataset.frame_shape
         # warning: we need to invert the order of the frame shape (frame_height, frame_width) vs (frame_width, frame_height)
@@ -215,6 +126,3 @@ class ROISelectionWidget(qt.QWidget):
             origin=new_origin,
             size=new_size,
         )
-
-    def enableValidation(self, isAllowed: bool) -> None:
-        self._okB.setEnabled(isAllowed)

darfix/gui/{shiftcorrection/shiftCorrectionWidget.py → shift_correction/shift_correction_widget.py}

@@ -13,10 +13,10 @@ import darfix
 
 from ... import dtypes
 from ...core.dataset import ImageDataset
-from ..filterByDimension import FilterByDimensionWidget
-from ..operationProcess import OperationProcess
+from ..filter_by_dimension import FilterByDimensionWidget
+from ..parallel.operation_process import OperationProcess
 from ..utils.message import missing_dataset_msg
-from .shiftInput import ShiftInput
+from .shift_input import ShiftInput
 
 _logger = logging.getLogger(__file__)
 
@@ -30,8 +30,6 @@ class ShiftCorrectionWidget(qt.QMainWindow):
         super().__init__(parent=parent)
         self.setWindowFlags(qt.Qt.WindowType.Widget)
         self._input_dataset: ImageDataset | None = None
-        self.indices = None
-        self.bg_indices = None
         self.bg_dataset = None
         self._axis = None
 
@@ -100,7 +98,6 @@ class ShiftCorrectionWidget(qt.QMainWindow):
             self,
             dataset.find_shift,
             self._axis,
-            indices=self.indices,
         )
         self.thread_detection.finished.connect(self._updateShift)
         self.thread_detection.start()
@@ -160,6 +157,6 @@ class ShiftCorrectionWidget(qt.QMainWindow):
     def refreshPlot(self) -> None:
         # TODO is there another way to refresh plot ?
         if self._axis is None:
-            self._sv.setStack(self._input_dataset.as_array3d(self.indices))
+            self._sv.setStack(self._input_dataset.as_array3d())
         else:
             self._sv.setStack(self._input_dataset.z_sum_along_axis(self._axis))