tomwer 1.2.9__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

tomwer/gui/reconstruction/test/test_lamino.py

@@ -37,7 +37,8 @@ from silx.gui import qt
 
 from tomwer.core import settings
 from tomwer.gui.reconstruction.lamino.tofu import TofuWindow
-from tomwer.tests.utils import UtilsTest, skip_gui_test
+from tomwer.tests.datasets import TomwerCIDatasets
+from tomwer.tests.utils import skip_gui_test
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
@@ -59,7 +60,9 @@ class TestLamino(unittest.TestCase):
 
     def testSetup(self):
         """Make sure the widget is correctly setting parameters from a scan"""
-        dataset = UtilsTest.getEDFDataset("test01")
+        dataset = TomwerCIDatasets.get_dataset(
+            "edf_datasets/test01",
+        )
         self._window.loadFromScan(dataset)
         reconsParams = self._widget.getParameters()
         # check general information
@@ -101,7 +104,9 @@ class TestLamino(unittest.TestCase):
         outputWidget.setOutput("toto")
         outputWidget.lockOutput()
 
-        dataset = UtilsTest.getEDFDataset("test01")
+        dataset = TomwerCIDatasets.get_dataset(
+            "edf_datasets/test01",
+        )
         self._window.loadFromScan(dataset)
 
         self.assertTrue(inputWidget.rotationAngle._overallAngle.getAngle() == 12.0)

tomwer/gui/reconstruction/test/test_nabu.py

@@ -37,7 +37,7 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.output import _NabuOutputConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.preprocessing import (
     _NabuPreProcessingConfig,
-    _RingCorrectionMethod,
+    RingCorrectionMethod,
 )
 from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
     _NabuReconstructionConfig,
@@ -45,6 +45,7 @@ from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
 from tomwer.gui.reconstruction.nabu.volume import NabuVolumeWidget
 from tomwer.tests.utils import skip_gui_test
+from tomwer.core.process.output import ProcessDataOutputDirMode
 
 
 class ProcessClass:
@@ -119,8 +120,8 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_max_clip": 10.0,
             "take_logarithm": True,
             "normalize_srcurrent": 0,
-            "sino_rings_correction": _RingCorrectionMethod.NONE.value,
-            "sino_rings_options": "sigma=1.0 ; levels=10",
+            "sino_rings_correction": RingCorrectionMethod.NONE.value,
+            "sino_rings_options": "sigma=1.0 ; levels=10 ; padding=False",
             "tilt_correction": "",
             "autotilt_options": "",
         }
@@ -138,8 +139,8 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_max_clip": 250.0,
             "take_logarithm": False,
             "normalize_srcurrent": 1,
-            "sino_rings_correction": _RingCorrectionMethod.MUNCH.value,
-            "sino_rings_options": "sigma=1.4 ; levels=11",
+            "sino_rings_correction": RingCorrectionMethod.MUNCH.value,
+            "sino_rings_options": "sigma=1.4 ; levels=11 ; padding=True",
             "tilt_correction": "1d-correlation",
             "autotilt_options": "low_pass=1; high_pass=20",
         }
@@ -303,17 +304,25 @@ class TestNabuOutputConfig(TestCaseQt):
         self.qapp.processEvents()
 
     def testGetConfiguration(self):
-        ini_conf = {"file_format": "hdf5", "location": ""}
+        ini_conf = {
+            "file_format": "hdf5",
+            "location": "",
+            "output_dir_mode": "same folder as scan",
+        }
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)
 
     def testSetConfiguration(self):
-        conf = {"file_format": "tiff", "location": os.sep.join(("tmp", "my_output"))}
+        conf = {
+            "file_format": "tiff",
+            "location": os.sep.join(("tmp", "my_output")),
+            "output_dir_mode": "other",
+        }
         self.nabuWidget.setConfiguration(conf)
         self.nabuWidget.show()
         self.qapp.processEvents()
         # check some widget visibility
         self.assertTrue(self.nabuWidget._output_dir_widget._outputDirQLE.isVisible())
-        self.assertFalse(self.nabuWidget._output_dir_widget._defaultOutput.isChecked())
+        self.assertTrue(self.nabuWidget._output_dir_widget._otherDirRB.isChecked())
 
         self.assertEqual(self.nabuWidget.getConfiguration(), conf)
 
@@ -323,6 +332,7 @@ class TestNabuVolumeWidget(TestCaseQt):
     def setUp(self):
         TestCaseQt.setUp(self)
         self.nabuWidget = NabuVolumeWidget(parent=None)
+        self.nabuWidget.setConfigurationLevel("advanced")
 
     def tearDown(self):
         self.nabuWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
@@ -334,6 +344,8 @@ class TestNabuVolumeWidget(TestCaseQt):
             "start_z": 0,
             "end_z": -1,
             "gpu_mem_fraction": 0.9,
+            "output_dir_mode": ProcessDataOutputDirMode.IN_SCAN_FOLDER.value,
+            "overwrite_output_location": False,
             "postproc": {"output_histogram": 1},
             "cpu_mem_fraction": 0.9,
             "use_phase_margin": True,
@@ -354,6 +366,13 @@ class TestNabuVolumeWidget(TestCaseQt):
             "new_output_location": "/new/location",
         }
         self.nabuWidget.setConfiguration(conf)
-        self.nabuWidget.show()
         self.qapp.processEvents()
+
+        # update the config dict has setting an other custom output directory update some items
+        conf.update(
+            {
+                "overwrite_output_location": True,
+                "output_dir_mode": ProcessDataOutputDirMode.OTHER.value,
+            }
+        )
         self.assertEqual(self.nabuWidget.getConfiguration(), conf)

tomwer/gui/reconstruction/test/test_saaxis.py

@@ -37,7 +37,7 @@ import pytest
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
-from tomoscan.unitsystem import metricsystem
+from pyunitsystem import metricsystem
 
 from tomwer.core.process.reconstruction.saaxis.params import (
     ReconstructionMode,
@@ -45,7 +45,7 @@ from tomwer.core.process.reconstruction.saaxis.params import (
 )
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
 from tomwer.gui.reconstruction.saaxis.saaxis import SAAxisWindow
 from tomwer.tests.utils import skip_gui_test
@@ -144,7 +144,7 @@ class TestSAAxisWindow(TestCaseQt):
         # create a scan
         self.folder = tempfile.mkdtemp()
         dim = 10
-        mock = MockHDF5(
+        mock = MockNXtomo(
             scan_path=self.folder, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
         )
         mock.add_alignment_radio(index=10, angle=90)

tomwer/gui/reconstruction/test/test_sadeltabeta.py

@@ -41,7 +41,7 @@ from silx.io.url import DataUrl
 from tomwer.core.process.reconstruction.sadeltabeta.params import SADeltaBetaParams
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.reconstruction.sadeltabeta import SADeltaBetaWindow
 from tomwer.tests.utils import skip_gui_test
 
@@ -75,7 +75,7 @@ class TestSADeltaBetaWindow(TestCaseQt):
         # create a scan
         self.folder = tempfile.mkdtemp()
         dim = 10
-        mock = MockHDF5(
+        mock = MockNXtomo(
             scan_path=self.folder, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
         )
         mock.add_alignment_radio(index=10, angle=90)

tomwer/gui/settings.py

@@ -1,31 +1,8 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "05/11/2018"
+from silx.gui import qt
 
 
 Y_AXIS_DOWNWARD = True
+"""Default axis direction Y"""
+
+EDITING_BACKGROUND_COLOR = qt.QColor("#c3d0d6")
+"""Background color used to notify the user that application waits end of edition before taking it into account"""

tomwer/gui/stackplot.py

@@ -555,7 +555,7 @@ class _StackImageToLoad(_StackImage, qt.QObject):
 
     def clear(self):
         for img in self._images.values():
-            img.sigLoaded.disconnect(self._loaded)
+            img.sigLoaded.disconnect(self.sigImageLoaded)
         _StackImage.clear(self)
         self._url_to_index.clear()
 
@@ -568,7 +568,7 @@ class _StackImageToLoad(_StackImage, qt.QObject):
             raise TypeError(f"Unmanaged type: {type(image)}")
         self._url_to_index[image_.url.path()] = self.nextIndex
         _StackImage.addImage(self, image_)
-        image_.sigLoaded.connect(self._loaded)
+        image_.sigLoaded.connect(self.sigImageLoaded)
         if self._mode == ASAP_LOADING:
             image_.load(self._force_sync)
 
@@ -615,9 +615,6 @@ class _StackImageToLoad(_StackImage, qt.QObject):
             except Exception as e:
                 logger.error(e)
 
-    def _loaded(self, url_path):
-        self.sigImageLoaded.emit(url_path)
-
     def setForceSync(self, value):
         self._force_sync = value
 

tomwer/gui/stitching/action.py

@@ -0,0 +1,49 @@
+from silx.gui import qt
+from silx.gui import icons as silx_icons
+from tomwer.gui import icons as tomwer_icons
+
+
+class LoadConfigurationAction(qt.QAction):
+    """Action to trigger load of a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip("load nabu-stitching configuration")
+        load_icon = silx_icons.getQIcon("document-open")
+        self.setIcon(load_icon)
+
+
+class SaveConfigurationAction(qt.QAction):
+    """Action to trigger save of a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip("save nabu-stitching configuration")
+        save_icon = silx_icons.getQIcon("document-save")
+        self.setIcon(save_icon)
+
+
+class AddTomoObjectAction(qt.QAction):
+    """Action to trigger add a volume to a stitching configuration"""
+
+    def __init__(self, parent=None, text=None):
+        super().__init__(parent)
+        if text is not None:
+            self.setText(text)
+        self.setToolTip(
+            "Add a NXtomo or a (nabu) reconstructed volume to the stitching"
+        )
+        add_icon = tomwer_icons.getQIcon("add")
+        self.setIcon(add_icon)
+
+
+class PreviewAction(qt.QAction):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setToolTip("Compute preview with current settings (shortcut: F5)")
+        update_preview_icon = tomwer_icons.getQIcon("update_stitching_preview")
+        self.setIcon(update_preview_icon)

tomwer/gui/stitching/config/axisparams.py

@@ -2,11 +2,11 @@ import logging
 from typing import Union
 
 from nabu.stitching import config as stitching_config
-from nabu.stitching.utils import ScoreMethod
 from nabu.stitching.utils import ShiftAlgorithm as StitchShiftAlgorithm
 from silx.gui import qt
 
 from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.configuration.level import ConfigurationLevel
 
 _logger = logging.getLogger(__name__)
 
@@ -34,7 +34,6 @@ class StitcherAxisParams(qt.QWidget):
         axis_0_shift_search_method = [
             StitchShiftAlgorithm.NABU_FFT,
             StitchShiftAlgorithm.SKIMAGE,
-            StitchShiftAlgorithm.SHIFT_GRID,
             StitchShiftAlgorithm.ITK_IMG_REG_V4,
             StitchShiftAlgorithm.NONE,
         ]
@@ -54,13 +53,6 @@ class StitcherAxisParams(qt.QWidget):
         tooltip = "size of the window to try to refine shift"
         self._windowSizeLabel.setToolTip(tooltip)
         self._windowSizeSB.setToolTip(tooltip)
-        # score method
-        self._scoreMethodLabel = qt.QLabel("score method", self)
-        self.layout().addWidget(self._scoreMethodLabel, 2, 0, 1, 1)
-        self._scoreMethodCB = qt.QComboBox(self)
-        for method in ScoreMethod:
-            self._scoreMethodCB.addItem(method.value)
-        self.layout().addWidget(self._scoreMethodCB, 2, 1, 1, 1)
 
         # filter options
         self._filteringGroup = _FilteringGroupBox("filter for shift search", self)
@@ -68,7 +60,7 @@ class StitcherAxisParams(qt.QWidget):
         self._filteringGroup.setChecked(False)
         self._filteringGroup.setLowPassValue(1)
         self._filteringGroup.setHighPassValue(20)
-        self.layout().addWidget(self._filteringGroup, 3, 0, 2, 3)
+        self.layout().addWidget(self._filteringGroup, 2, 0, 2, 3)
 
         # set up
         self._methodChanged()
@@ -76,7 +68,6 @@ class StitcherAxisParams(qt.QWidget):
         # connect signal / slot
         self._shiftSearchMethodCB.currentIndexChanged.connect(self._methodChanged)
         self._windowSizeSB.valueChanged.connect(self._notifyConfigChanged)
-        self._scoreMethodCB.currentIndexChanged.connect(self._notifyConfigChanged)
         self._filteringGroup.sigValueChanged.connect(self._notifyConfigChanged)
 
     @property
@@ -91,21 +82,12 @@ class StitcherAxisParams(qt.QWidget):
         idx = self._shiftSearchMethodCB.findText(method.value)
         self._shiftSearchMethodCB.setCurrentIndex(idx)
 
-    def setScoreMethod(self, method: Union[ScoreMethod, str]) -> None:
-        method = ScoreMethod.from_value(method)
-        idx = self._scoreMethodCB.findText(method.value)
-        self._scoreMethodCB.setCurrentIndex(idx)
-
     def getConfiguration(self) -> dict:
         method = self.getShiftSearchMethod()
         param_opts = [
             f"{stitching_config.KEY_IMG_REG_METHOD}={method.value}",
             f"{stitching_config.KEY_WINDOW_SIZE}={self._windowSizeSB.value()}",
         ]
-        if method is StitchShiftAlgorithm.SHIFT_GRID:
-            param_opts.append(
-                f"{stitching_config.KEY_SCORE_METHOD}='{self._scoreMethodCB.currentText()}'"
-            )
         if self._filteringGroup.isChecked():
             param_opts.append(
                 f"{stitching_config.KEY_LOW_PASS_FILTER}='{self._filteringGroup.getLowPassValue()}'"
@@ -136,8 +118,6 @@ class StitcherAxisParams(qt.QWidget):
                     self.setShiftSearchMethod(opt_value)
                 elif opt_name == stitching_config.KEY_WINDOW_SIZE:
                     self._windowSizeSB.setValue(int(opt_value))
-                elif opt_name == stitching_config.KEY_SCORE_METHOD:
-                    self.setScoreMethod(opt_value)
                 elif opt_name == stitching_config.KEY_LOW_PASS_FILTER:
                     self._filteringGroup.setLowPassValue(int(opt_value))
                     self._filteringGroup.setEnabled(True)
@@ -153,8 +133,6 @@ class StitcherAxisParams(qt.QWidget):
     def _methodChanged(self) -> None:
         method = self.getShiftSearchMethod()
         with block_signals(self):
-            self._scoreMethodCB.setVisible(method is StitchShiftAlgorithm.SHIFT_GRID)
-            self._scoreMethodLabel.setVisible(method is StitchShiftAlgorithm.SHIFT_GRID)
             self._windowSizeSB.setVisible(method is not StitchShiftAlgorithm.NONE)
             self._windowSizeLabel.setVisible(method is not StitchShiftAlgorithm.NONE)
         self._notifyConfigChanged()
@@ -162,6 +140,11 @@ class StitcherAxisParams(qt.QWidget):
     def _notifyConfigChanged(self, *args, **kwargs) -> None:
         self.sigConfigChanged.emit()
 
+    def setConfigurationLevel(self, level: ConfigurationLevel):
+        self._windowSizeLabel.setVisible(level >= ConfigurationLevel.OPTIONAL)
+        self._windowSizeSB.setVisible(level >= ConfigurationLevel.OPTIONAL)
+        self._filteringGroup.setVisible(level >= ConfigurationLevel.ADVANCED)
+
 
 class _FilteringGroupBox(qt.QGroupBox):
     sigValueChanged = qt.Signal()

tomwer/gui/stitching/config/output.py

@@ -5,9 +5,10 @@ from nabu.stitching.config import StitchingType
 from nxtomomill.io.utils import convert_str_to_bool
 from silx.gui import qt
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan, HDF5TomoScanIdentifier
+from tomwer.core.scan.nxtomoscan import NXtomoScan, NXtomoScanIdentifier
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.gui.utils.inputwidget import OutputVolumeDefinition
+from tomwer.gui.qlefilesystem import QLFileSystem
 
 _logger = logging.getLogger(__name__)
 
@@ -21,21 +22,21 @@ class _PreProcessingOutput(qt.QWidget):
         super().__init__(parent)
         self.setLayout(qt.QFormLayout())
         # TODO: check if the widget with output .nx file exists somewhere
-        self._outputFile = qt.QLineEdit("stitching/stitched.nx", self)
+        self._outputFile = QLFileSystem("stitching/stitched.nx", self)
         self.layout().addRow("output nexus file", self._outputFile)
         self._outputDataPath = qt.QLineEdit("entry0000", self)
         self.layout().addRow("output data path", self._outputDataPath)
 
     def getUrl(self) -> str:
-        return HDF5TomoScanIdentifier(
-            object=HDF5TomoScan,
+        return NXtomoScanIdentifier(
+            object=NXtomoScan,
             hdf5_file=self._outputFile.text(),
             entry=self._outputDataPath.text(),
         )
 
     def setUrl(self, url: str):
         try:
-            identifier = HDF5TomoScanIdentifier.from_str(url)
+            identifier = NXtomoScanIdentifier.from_str(url)
         except Exception as e:
             _logger.warning(f"Fail to create an identifier from {url}. Error is {e}")
         else:
@@ -71,6 +72,7 @@ class StitchingOutput(qt.QWidget):
         self._postProcOutput = _PostProcessingOutput(parent=self)
         self.layout().addWidget(self._postProcOutput)
         self._overwritePB = qt.QCheckBox("overwrite", self)
+        self._overwritePB.setChecked(True)
         self.layout().addWidget(self._overwritePB)
 
         # add a vertical spacer for display
@@ -110,7 +112,7 @@ class StitchingOutput(qt.QWidget):
             except Exception:
                 scan = None
 
-            if not isinstance(scan, HDF5TomoScan):
+            if not isinstance(scan, NXtomoScan):
                 _logger.info("Failed to create an HDFTomoscan from url")
                 return None
             else:
@@ -146,8 +148,8 @@ class StitchingOutput(qt.QWidget):
             stitching_config.DATA_PATH_FIELD, None
         )
         if location is not None:
-            identifier = HDF5TomoScanIdentifier(
-                object=HDF5TomoScan, hdf5_file=location, entry=data_path
+            identifier = NXtomoScanIdentifier(
+                object=NXtomoScan, hdf5_file=location, entry=data_path
             )
             self._preProcOutput.setUrl(identifier.to_str())
 

tomwer/gui/stitching/config/positionoveraxis.py

@@ -3,6 +3,7 @@ import numpy
 from silx.gui import qt
 
 from tomwer.gui.stitching.axisorderedlist import AxisOrderedTomoObjsModel
+from tomwer.gui.utils.step import StepSizeSelectorWidget
 
 
 class PosEditorOverOneAxis(qt.QWidget):
@@ -15,7 +16,6 @@ class PosEditorOverOneAxis(qt.QWidget):
     ) -> None:
         assert axis_edited in (0, 1, 2)
         super().__init__(parent, *args, **kwargs)
-        self._stepSize = 1
         self._axisEdited = axis_edited
         # the axis the spin boxes are editing
         self._axisOrder = axis_order if axis_order is not None else axis_edited
@@ -25,7 +25,13 @@ class PosEditorOverOneAxis(qt.QWidget):
         self.__spinBoxescallback = {}
         self.setLayout(qt.QVBoxLayout())
         # widget to define step size
-        self._stepSizeWidget = StepSizeWidget(self)
+        self._stepSizeWidget = StepSizeSelectorWidget(
+            self,
+            fine_value=1,
+            medium_value=5,
+            rough_value=25,
+            dtype=int,
+        )
         self.layout().addWidget(self._stepSizeWidget)
 
         # table with the different Tomo objects
@@ -35,22 +41,28 @@ class PosEditorOverOneAxis(qt.QWidget):
 
         self.layout().addWidget(self._tomoObjsTableView)
 
+        # connect signal / slot
+        self._stepSizeWidget.valueChanged.connect(self._updateStepSize)
+
         # tune table view
         self._tomoObjsTableView.setColumnWidth(0, 15)
         self._tomoObjsTableView.setColumnWidth(2, 120)
         self._tomoObjsTableView.horizontalHeader().setSectionResizeMode(
             1, qt.QHeaderView.Stretch
         )
+        self.setStepSize(1)
 
-        # connect signal / slot
-        self._stepSizeWidget.stepSB.valueChanged.connect(self.setStepSize)
-        self._stepSize = 1
+    def _updateStepSize(self):
+        step_size = self.getStepSize()
+        for sb in self._tomoObjtoSpinBoxes.values():
+            sb.setSingleStep(step_size)
 
     def setStepSize(self, step_size: int):
-        self._stepSize = step_size
-        # update SB step size
-        for sb in self._tomoObjtoSpinBoxes.values():
-            sb.setSingleStep(self._stepSize)
+        self._stepSizeWidget.setStepSize(step_size)
+        self._updateStepSize()
+
+    def getStepSize(self) -> int:
+        return self._stepSizeWidget.getStepSize()
 
     def addTomoObj(self, tomo_obj):
         if tomo_obj is None:
@@ -68,7 +80,7 @@ class PosEditorOverOneAxis(qt.QWidget):
         spinBox = qt.QSpinBox(parent=self)
         spinBox.setRange(numpy.iinfo(numpy.int32).min, numpy.iinfo(numpy.int32).max)
         spinBox.setSuffix("px")
-        spinBox.setSingleStep(self._stepSize)
+        spinBox.setSingleStep(self.getStepSize())
         spinBox.setValue(
             tomo_obj.stitching_metadata.get_abs_position_px(axis=self._axisEdited)
             or self.DEFAULT_VALUE_WHEM_MISSING
@@ -154,16 +166,3 @@ class EditableAxisOrderedTomoObjsModel(AxisOrderedTomoObjsModel):
     def __init__(self, axis: int, parent=None) -> None:
         super().__init__(axis, parent)
         self._headers = ["index", "tomo obj", f"axis {axis} pos (px)"]
-
-
-class StepSizeWidget(qt.QWidget):
-    def __init__(self, parent=None) -> None:
-        super().__init__(parent)
-        self.setLayout(qt.QFormLayout())
-        self._stepSB = qt.QSpinBox(self)
-        self._stepSB.setRange(1, 9999)
-        self.layout().addRow("step size", self._stepSB)
-
-    @property
-    def stepSB(self):
-        return self._stepSB

tomwer/gui/stitching/normalization.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+from silx.gui import qt
+from nabu.stitching.sample_normalization import (
+    SampleSide as _SampleSide,
+    Method as _SampleNormalizationMethod,
+)
+from nabu.stitching import config as _config_stitching
+from tomwer.gui.utils.qt_utils import block_signals
+
+
+class NormalizationBySampleGroupBox(qt.QGroupBox):
+    """
+    Widget to define the normalization to apply to frames"""
+
+    sigConfigChanged = qt.Signal()
+    """Emit when the configuration is changed"""
+
+    def __init__(self, title: str = "normalization by sample", parent=None):
+        # FIXME: add a way to the user for requesting a view of the region picked ???
+        super().__init__(title, parent)
+        self.setCheckable(True)
+        self.setLayout(qt.QFormLayout())
+
+        # method
+        self._methodCB = qt.QComboBox(self)
+        self._methodCB.addItems(_SampleNormalizationMethod.values())
+        self._methodCB.setCurrentText(_SampleNormalizationMethod.MEDIAN.value)
+        self.layout().addRow("method", self._methodCB)
+
+        # side
+        self._sideCB = qt.QComboBox(self)
+        self._sideCB.addItems(_SampleSide.values())
+        self._sideCB.setCurrentText(_SampleSide.LEFT.value)
+        self.layout().addRow("sampling side", self._sideCB)
+
+        # width
+        self._widthSB = qt.QSpinBox(self)
+        self._widthSB.setRange(1, 9999999)
+        self._widthSB.setValue(30)
+        self._widthSB.setSingleStep(10)
+        self.layout().addRow("sampling width", self._widthSB)
+
+        # margin
+        self._marginSB = qt.QSpinBox(self)
+        self._marginSB.setRange(0, 999999)
+        self._marginSB.setValue(0)
+        self.layout().addRow("sampling margin", self._marginSB)
+
+        # connect signal / slot
+        self._methodCB.currentIndexChanged.connect(self._configChanged)
+        self._sideCB.currentIndexChanged.connect(self._configChanged)
+        self._widthSB.valueChanged.connect(self._configChanged)
+        self._marginSB.valueChanged.connect(self._configChanged)
+
+    def _configChanged(self, *args, **kwargs):
+        self.sigConfigChanged.emit()
+
+    def getMethod(self) -> _SampleNormalizationMethod:
+        return _SampleNormalizationMethod.from_value(self._methodCB.currentText())
+
+    def setMethod(self, method: _SampleNormalizationMethod | str):
+        method = _SampleNormalizationMethod.from_value(method)
+        self._methodCB.setCurrentText(method.value)
+
+    def getSide(self) -> _SampleSide:
+        return _SampleSide.from_value(self._sideCB.currentText())
+
+    def setSide(self, side: _SampleSide):
+        side = _SampleSide.from_value(side)
+        self._sideCB.setCurrentText(side.value)
+
+    def getMargin(self) -> int:
+        return self._marginSB.value()
+
+    def setMargin(self, margin: int):
+        self._marginSB.setValue(int(margin))
+
+    def getWidth(self) -> int:
+        return self._widthSB.value()
+
+    def setWidth(self, width: int):
+        self._widthSB.setValue(int(width))
+
+    def getConfiguration(self) -> dict:
+        return {
+            _config_stitching.NORMALIZATION_BY_SAMPLE_ACTIVE_FIELD: self.isChecked(),
+            _config_stitching.NORMALIZATION_BY_SAMPLE_METHOD: self.getMethod().value,
+            _config_stitching.NORMALIZATION_BY_SAMPLE_SIDE: self.getSide().value,
+            _config_stitching.NORMALIZATION_BY_SAMPLE_MARGIN: self.getMargin(),
+            _config_stitching.NORMALIZATION_BY_SAMPLE_WIDTH: self.getWidth(),
+        }
+
+    def setConfiguration(self, config: dict) -> None:
+        with block_signals(self):
+            method = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_METHOD, None)
+            if method is not None:
+                self.setMethod(method=method)
+
+            side = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_SIDE, None)
+            if side is not None:
+                self.setSide(side=side)
+
+            margin = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_MARGIN, None)
+            if margin is not None:
+                self.setMargin(margin=margin)
+
+            width = config.get(_config_stitching.NORMALIZATION_BY_SAMPLE_WIDTH, None)
+            if width is not None:
+                self.setWidth(width=width)
+
+            active = config.get(
+                _config_stitching.NORMALIZATION_BY_SAMPLE_ACTIVE_FIELD, None
+            )
+            if active is not None:
+                self.setChecked(active in (True, 1, "1", "True"))
+
+        self._configChanged()