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

tomwer/gui/stitching/stitchandbackground.py

@@ -21,11 +21,11 @@ class AlphaChannelWidget(qt.QWidget):
         self._alphaImgSlider = qt.QSlider(qt.Qt.Horizontal, self)
         self._alphaImgSlider.setMinimumWidth(40)
         self._alphaImgSlider.setRange(0, 100)
-        self.layout().addRow(f"{ALPHA_CHAR} stitching", self._alphaImgSlider)
+        self.layout().addRow(f"{ALPHA_CHAR} image", self._alphaImgSlider)
         self._alphaBackgroundSlider = qt.QSlider(qt.Qt.Horizontal, self)
         self._alphaBackgroundSlider.setMinimumWidth(40)
         self._alphaBackgroundSlider.setRange(0, 100)
-        self.layout().addRow(f"{ALPHA_CHAR} background", self._alphaBackgroundSlider)
+        self.layout().addRow(f"{ALPHA_CHAR} overlay", self._alphaBackgroundSlider)
 
         # connect signal / slot
         self._alphaImgSlider.valueChanged.connect(self._alphaImgchanged)
@@ -62,8 +62,8 @@ class StitchAndBackgroundAlphaMixIn:
         self._stitched_image = None
         self._composition_background = None
         # background action to show / hide the backgrounds
-        self._backGroundAction = qt.QAction("background", self)
-        self._backGroundAction.setToolTip("show / hide colored background")
+        self._backGroundAction = qt.QAction("overlay", self)
+        self._backGroundAction.setToolTip("show / hide overlay on top of image")
         self._backGroundAction.setCheckable(True)
         save_icon = tomwer_icons.getQIcon("background")
         self._backGroundAction.setIcon(save_icon)
@@ -128,8 +128,6 @@ class StitchAndBackgroundAlphaMixIn:
             )
             background_data = self.getImage(legend=self.LEGEND_BACKGROUND)
             background_data.setAlpha(self.getBackgroundImgAlpha())
-            # TODO: active image is always the image data
-
         else:
             if self.getImage(self.LEGEND_BACKGROUND) is not None:
                 self.removeImage(self.LEGEND_BACKGROUND)

tomwer/gui/stitching/stitching.py

@@ -12,6 +12,7 @@ from nabu.stitching.z_stitching import (
     PreProcessZStitcher,
 )
 from nabu.pipeline.config import generate_nabu_configfile, parse_nabu_config_file
+from nabu.stitching.alignment import AlignmentAxis1, AlignmentAxis2
 from nabu.stitching.config import (
     get_default_stitching_config,
     identifiers_as_str_to_instances,
@@ -27,19 +28,18 @@ from nxtomomill.io.utils import (
     convert_str_to_tuple as _convert_str_to_tuple,
     convert_str_to_bool as _convert_str_to_bool,
 )
-from silx.gui import icons as silx_icons
 from silx.gui import qt
 from tomoscan.serie import Serie
 from tomoscan.scanbase import TomoScanBase as _TomoScanBase
 from tomoscan.volumebase import VolumeBase as _VolumeBase
 
-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.core.volume.volumefactory import VolumeFactory
+from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.volume.hdf5volume import HDF5Volume, HDF5VolumeIdentifier
 from tomwer.io.utils.utils import str_to_dict
-from tomwer.gui import icons as tomwer_icons
 from tomwer.gui.qconfigfile import QConfigFileDialog
 from tomwer.gui.stitching.config.axisparams import StitcherAxisParams
 from tomwer.gui.stitching.config.positionoveraxis import PosEditorOverOneAxis
@@ -49,6 +49,15 @@ from tomwer.gui.stitching.stitching_preview import PreviewStitchingPlot
 from tomwer.gui.stitching.stitching_raw import RawStitchingPlot
 from tomwer.gui.stitching.axisorderedlist import EditableZOrderedTomoObjWidget
 from tomwer.gui.stitching.z_stitching.fineestimation import _SliceGetter
+from tomwer.gui.configuration.action import (
+    BasicConfigurationAction,
+    ExpertConfigurationAction,
+    MinimalisticConfigurationAction,
+)
+from tomwer.gui.configuration.level import ConfigurationLevel
+from tomwer.gui.stitching import action as stitching_action
+from tomwer.gui.stitching.normalization import NormalizationBySampleGroupBox
+
 
 _logger = logging.getLogger(__name__)
 
@@ -104,6 +113,8 @@ class ZStitchingCentralWidget(qt.QWidget):
                 raw_display_idx,
                 "If toggled will keep the raw display up to date from axis 0 modifications",
             )
+            # set up: turn overlay one by default
+            self._previewPlot._backGroundAction.setChecked(True)
 
         def _handleRawDisplayconnection(self, toggled: bool):
             if toggled:
@@ -192,9 +203,33 @@ class ZStitchingCentralWidget(qt.QWidget):
 
     def addTomoObj(self, tomo_obj: TomwerObject):
         self._mainWidget.addTomoObj(tomo_obj)
+        self._updatePreviewPixelSize()
 
     def removeTomoObj(self, tomo_obj: TomwerObject):
         self._mainWidget.removeTomoObj(tomo_obj)
+        self._updatePreviewPixelSize()
+
+    def _updatePreviewPixelSize(self):
+        """update the pixel size of the preview from existing tomo obj"""
+
+        def get_pixel_size():
+            tomo_objs = self._mainWidget.getTomoObjs()
+            for tomo_obj in tomo_objs:
+                if (
+                    isinstance(tomo_obj, NXtomoScan)
+                    and tomo_obj.x_pixel_size is not None
+                    and tomo_obj.y_pixel_size is not None
+                ):
+                    return tomo_obj.x_pixel_size, tomo_obj.y_pixel_size
+                elif (
+                    isinstance(tomo_obj, TomwerVolumeBase)
+                    and tomo_obj.voxel_size is not None
+                ):
+                    return tomo_obj.voxel_size[1], tomo_obj.voxel_size[2]
+            return None, None
+
+        pixel_size = get_pixel_size()
+        self._mainWidget._previewPlot.setPixelSize(pixel_size=pixel_size)
 
     def getConfiguration(self) -> dict:
         # missing parameters:
@@ -303,12 +338,15 @@ class ZStitchingCentralWidget(qt.QWidget):
 class ZStitchingWindow(qt.QMainWindow):
     """
     Main widget containing all the options to define the stitching to be done
+
+    :param bool with_configuration_action: if True append the load and save stitching configuration tool button.
+                                           In some cases those can also be part of Menu so we want to avoid having those twice
     """
 
     sigChanged = qt.Signal()
     """Signal emit each time the configuration is modified"""
 
-    def __init__(self, parent=None) -> None:
+    def __init__(self, parent=None, with_configuration_action=True) -> None:
         super().__init__(parent)
         self._previewFolder = None
         # folder to store files (volume or NXtomo) for previews
@@ -335,42 +373,56 @@ class ZStitchingWindow(qt.QMainWindow):
         # separator
         toolbar.addSeparator()
 
-        # load action
-        self.__loadAction = qt.QAction(self)
-        self.__loadAction.setToolTip("load nabu-stitching configuration")
-        load_icon = silx_icons.getQIcon("document-open")
-        self.__loadAction.setIcon(load_icon)
-        toolbar.addAction(self.__loadAction)
-        self.__loadAction.triggered.connect(
-            functools.partial(self._loadSettings, file_path=None)
-        )
+        if with_configuration_action:
+            # load action
+            self.__loadAction = stitching_action.LoadConfigurationAction(self)
+            toolbar.addAction(self.__loadAction)
+            self.__loadAction.triggered.connect(
+                functools.partial(self._loadSettings, file_path=None)
+            )
 
-        # save action
-        self.__saveAction = qt.QAction(self)
-        self.__saveAction.setToolTip("save nabu-stitching configuration")
-        save_icon = silx_icons.getQIcon("document-save")
-        self.__saveAction.setIcon(save_icon)
-        toolbar.addAction(self.__saveAction)
-        self.__saveAction.triggered.connect(
-            functools.partial(self._saveSettings, file_path=None)
-        )
+            # save action
+            self.__saveAction = stitching_action.SaveConfigurationAction(self)
+            toolbar.addAction(self.__saveAction)
+            self.__saveAction.triggered.connect(
+                functools.partial(self._saveSettings, file_path=None)
+            )
 
-        # separator
-        toolbar.addSeparator()
+            # separator
+            toolbar.addSeparator()
 
         # update preview action
-        self.__updatePreviewAction = qt.QAction(self)
-        self.__updatePreviewAction.setToolTip(
-            "Compute preview with current settings (shortcut: F5)"
-        )
-        update_preview_icon = tomwer_icons.getQIcon("update_stitching_preview")
-        self.__updatePreviewAction.setIcon(update_preview_icon)
+        self.__updatePreviewAction = stitching_action.PreviewAction(self)
         toolbar.addAction(self.__updatePreviewAction)
         self.__updatePreviewAction.triggered.connect(self._trigger_update_preview)
 
         # separator
         toolbar.addSeparator()
 
+        # configuraiton level / mode
+        self.__configurationModesAction = qt.QAction(self)
+        self.__configurationModesAction.setCheckable(False)
+        menu = qt.QMenu(self)
+        self.__configurationModesAction.setMenu(menu)
+        toolbar.addAction(self.__configurationModesAction)
+
+        self.__configurationModesGroup = qt.QActionGroup(self)
+        self.__configurationModesGroup.setExclusive(True)
+        self.__configurationModesGroup.triggered.connect(self._userModeChanged)
+
+        self._minimalisticAction = MinimalisticConfigurationAction(toolbar)
+        menu.addAction(self._minimalisticAction)
+        self.__configurationModesGroup.addAction(self._minimalisticAction)
+        self._basicConfigAction = BasicConfigurationAction(toolbar)
+        menu.addAction(self._basicConfigAction)
+        self.__configurationModesGroup.addAction(self._basicConfigAction)
+        self._expertConfiguration = ExpertConfigurationAction(toolbar)
+        menu.addAction(self._expertConfiguration)
+        self.__configurationModesGroup.addAction(self._expertConfiguration)
+
+        # separator
+        toolbar.addSeparator()
+
         # create central widget
         self._widget = ZStitchingCentralWidget(parent=self)
         self.setCentralWidget(self._widget)
@@ -390,11 +442,16 @@ class ZStitchingWindow(qt.QMainWindow):
         )
         ##  stitching strategies
         self._stitchingOptsWidget = StitchingOptions(parent=self)
-        self._stitchingOptsWidget.setObjectName("options")
+        self._stitchingOptsScrollArea = qt.QScrollArea(self)
+        self._stitchingOptsScrollArea.setWidget(self._stitchingOptsWidget)
+        self._stitchingOptsScrollArea.setWidgetResizable(True)
+        self._stitchingOptsScrollArea.setHorizontalScrollBarPolicy(
+            qt.Qt.ScrollBarAlwaysOff
+        )
         self._stitchingOptsDockWidget = qt.QDockWidget(parent=self)
         self._stitchingOptsDockWidget.layout().setContentsMargins(0, 0, 0, 0)
         self._stitchingOptsDockWidget.setFeatures(qt.QDockWidget.DockWidgetMovable)
-        self._stitchingOptsDockWidget.setWidget(self._stitchingOptsWidget)
+        self._stitchingOptsDockWidget.setWidget(self._stitchingOptsScrollArea)
         self._stitchingOptsDockWidget.setWindowTitle("processing options")
         self.addDockWidget(qt.Qt.RightDockWidgetArea, self._stitchingOptsDockWidget)
 
@@ -425,13 +482,13 @@ class ZStitchingWindow(qt.QMainWindow):
         )
         ### add a check box to update position from preview if asked by the user
         self._updateAxis0PosFromPreviewCalc = qt.QCheckBox(
-            "update position 0 from preview calc"
+            "update position 0 from preview calc",
+            self,
         )
         self._updateAxis0PosFromPreviewCalc.setToolTip(
-            "When the user trigger a preview, if some shift search refined over axis 0 is done then will update the axis 0 positions"
+            "When the user trigger a preview, if some shift search refined over axis 0 is done then will update the axis 0 positions",
         )
-        self._updateAxis0PosFromPreviewCalc.setChecked(False)
-        self._updateAxis0PosFromPreviewCalc.setVisible(False)
+        self._updateAxis0PosFromPreviewCalc.setChecked(True)
         self._editTomoObjAxis0PositionsWidget.layout().insertWidget(
             0, self._updateAxis0PosFromPreviewCalc
         )
@@ -463,13 +520,12 @@ class ZStitchingWindow(qt.QMainWindow):
         )
         ### add a check box to update position from preview if asked by the user
         self._updateAxis2PosFromPreviewCalc = qt.QCheckBox(
-            "update position 2 from preview calc"
+            "update position 2 from preview calc", self
         )
         self._updateAxis2PosFromPreviewCalc.setToolTip(
             "When the user trigger a preview, if some shift search refined over axis 2 is done then will update the axis 2 positions"
         )
-        self._updateAxis2PosFromPreviewCalc.setChecked(False)
-        self._updateAxis2PosFromPreviewCalc.setVisible(False)
+        self._updateAxis2PosFromPreviewCalc.setChecked(True)
         self._editTomoObjAxis2PositionsWidget.layout().insertWidget(
             0, self._updateAxis2PosFromPreviewCalc
         )
@@ -511,6 +567,9 @@ class ZStitchingWindow(qt.QMainWindow):
         self._widget.sigStitchingTypeChanged.connect(
             self._outputWidget._updateOutputForStitchingType
         )
+        self._widget.sigStitchingTypeChanged.connect(
+            self._stitchingOptsWidget._stitchingTypeChanged
+        )
 
         ## handle raw plot preview
         self._stitchingOptsWidget.sigFlipLRChanged.connect(
@@ -532,6 +591,10 @@ class ZStitchingWindow(qt.QMainWindow):
         )
         self._widget.sigTomoObjsLoaded.connect(self.getRawDisplayPlot().setTomoObjs)
 
+        # set up
+        self._basicConfigAction.setChecked(True)
+        self._userModeChanged(self._basicConfigAction)
+
     def setCallbackToGetSlurmConfig(self, callback):
         self._callbackToGetSlurmConfig = callback
 
@@ -570,8 +633,8 @@ class ZStitchingWindow(qt.QMainWindow):
 
     def getNXtomoIdentifierForPreview(self):
         folder = self.getPreviewFolder()
-        return HDF5TomoScanIdentifier(
-            object=HDF5TomoScan,
+        return NXtomoScanIdentifier(
+            object=NXtomoScan,
             hdf5_file=os.path.join(folder, "nxtomo_stiching_preview.hdf5"),
             entry="entry0000",
         )
@@ -679,7 +742,9 @@ class ZStitchingWindow(qt.QMainWindow):
         assert isinstance(sender, PreviewThread)
         composition = sender.frame_composition
         tomo_objs_new_axis_positions = sender.final_tomo_objs_positions
-        assert isinstance(tomo_objs_new_axis_positions, dict)
+        assert isinstance(
+            tomo_objs_new_axis_positions, dict
+        ), "final_tomo_objs_positions is expected to be a dict with obj identifier as key and the tuple of position as value"
         # expect it to be a dict with tomo obj identifier as key and a tuple of (axis_2_pos, axis_1_pos, axis_0_pos) as value
         output_obj_identifier = sender.output_identifier
 
@@ -780,6 +845,20 @@ class ZStitchingWindow(qt.QMainWindow):
     def setStitchingType(self, stitching_type: StitchingType):
         self._widget.setStitchingType(stitching_type)
 
+    def _userModeChanged(self, action):
+        self.__configurationModesAction.setIcon(action.icon())
+        self.__configurationModesAction.setToolTip(action.tooltip())
+        if action is self._basicConfigAction:
+            level = ConfigurationLevel.OPTIONAL
+        elif action is self._expertConfiguration:
+            level = ConfigurationLevel.ADVANCED
+        else:
+            level = ConfigurationLevel.REQUIRED
+        self._stitchingOptsWidget.setConfigurationLevel(level)
+        self._editTomoObjAxis2PositionsDockWidget.setVisible(
+            level >= ConfigurationLevel.ADVANCED
+        )
+
 
 def concatenate_dict(dict_1, dict_2) -> dict:
     """update dict which has dict as values. And we want concatenate those values to"""
@@ -921,6 +1000,92 @@ class _SlicesSelector(qt.QGroupBox):
             self._stepSliceSB.setValue(int(step))
 
 
+class _AlignmentGroupBox(qt.QGroupBox):
+    DEFAULT_PAD_MODE = "constant"
+
+    ALIGNMENT_DOC = (
+        "https://tomotools.gitlab-pages.esrf.fr/nabu/stitching/alignment.html"
+    )
+
+    DEFAULT_ALIGNMENT_AXIS_1 = AlignmentAxis1.CENTER
+    DEFAULT_ALIGNMENT_AXIS_2 = AlignmentAxis2.CENTER
+
+    _PAD_MODES = (
+        "constant",  # Pads with a constant value.
+        "edge",  # Pads with the edge values of array.
+        "linear_ramp",  # Pads with the linear ramp between end_value and the array edge value.
+        "maximum",  # Pads with the maximum value of all or part of the vector along each axis.
+        "mean",  # Pads with the mean value of all or part of the vector along each axis.
+        "median",  # Pads with the median value of all or part of the vector along each axis.
+        "minimum",  # Pads with the minimum value of all or part of the vector along each axis.
+        "reflect",  # Pads with the reflection of the vector mirrored on the first and last values of the vector along each axis.
+        "symmetric",  # Pads with the reflection of the vector mirrored along the edge of the array.
+        "wrap",  # Pads with the wrap of the vector along the axis. The first values are used to pad the end and the end values are used to pad the beginning.
+    )
+
+    def __init__(self, parent: qt.QWidget = None, title="alignment") -> None:
+        super().__init__(title, parent)
+        self.setLayout(qt.QFormLayout())
+
+        # alignment axis 1
+        self._alignmentAxis1CB = qt.QComboBox(self)
+        for alignment in AlignmentAxis1.values():
+            self._alignmentAxis1CB.addItem(alignment)
+        self.layout().addRow("Axis 1 alignment", self._alignmentAxis1CB)
+        self._alignmentAxis1CB.setToolTip(
+            f"Alignment to do in case of volumes with different size over axis 1. Only possible for post-processing (reconstructed volume). See {self.ALIGNMENT_DOC} for details."
+        )
+
+        # alignment axis 2
+        self._alignmentAxis2CB = qt.QComboBox(self)
+        for alignment in AlignmentAxis2.values():
+            self._alignmentAxis2CB.addItem(alignment)
+        self.layout().addRow("Axis 2 alignment", self._alignmentAxis2CB)
+        self._alignmentAxis2CB.setToolTip(
+            f"Alignment to do in case of frames with different size over axis 2. See {self.ALIGNMENT_DOC} for details."
+        )
+
+        # pad mode
+        self._padModeCB = qt.QComboBox(self)
+        for pad_mode in self._PAD_MODES:
+            self._padModeCB.addItem(pad_mode)
+        self.layout().addRow("pad mode", self._padModeCB)
+        self._padModeCB.setToolTip("padding mode to apply for alignment")
+
+        # set up
+        self.setAlignmentAxis1(self.DEFAULT_ALIGNMENT_AXIS_1)
+        self.setAlignmentAxis2(self.DEFAULT_ALIGNMENT_AXIS_2)
+
+    def getAlignmentAxis1(self) -> AlignmentAxis1:
+        return AlignmentAxis1.from_value(self._alignmentAxis1CB.currentText())
+
+    def setAlignmentAxis1(self, alignment: AlignmentAxis1):
+        alignment = AlignmentAxis1.from_value(alignment)
+        self._alignmentAxis1CB.setCurrentIndex(
+            self._alignmentAxis1CB.findText(alignment.value)
+        )
+
+    def getAlignmentAxis2(self) -> AlignmentAxis2:
+        return AlignmentAxis2.from_value(self._alignmentAxis2CB.currentText())
+
+    def setAlignmentAxis2(self, alignment: AlignmentAxis2):
+        alignment = AlignmentAxis2.from_value(alignment)
+        self._alignmentAxis2CB.setCurrentIndex(
+            self._alignmentAxis2CB.findText(alignment.value)
+        )
+
+    def getPadMode(self) -> str:
+        return self._padModeCB.currentText()
+
+    def setPadMode(self, pad_mode: str):
+        idx = self._padModeCB.findText(pad_mode)
+        if idx >= 0:
+            self._padModeCB.setCurrentIndex(idx)
+
+    def setAlignmentAxis1Enabled(self, enabled: bool):
+        self._alignmentAxis1CB.setEnabled(enabled)
+
+
 class StitchingOptions(qt.QWidget):
     """
     Widget to let the user define the different options for z-stitching such as which algorithm to search shift,
@@ -968,6 +1133,10 @@ class StitchingOptions(qt.QWidget):
         )
         self.layout().addRow(self._flipUD_CB)
 
+        # alignment options
+        self._alignmentGroup = _AlignmentGroupBox(self)
+        self.layout().addRow(self._alignmentGroup)
+
         # slices to be reconstructed
         self._slices = _SlicesSelector(parent=self)
         self._slices.setToolTip(
@@ -999,6 +1168,11 @@ class StitchingOptions(qt.QWidget):
         self._rescalingWidget = RescalingWidget(parent=self)
         self.layout().addRow(self._rescalingWidget)
 
+        # normalization by sample
+        self._normalizationBySampleWidget = NormalizationBySampleGroupBox(parent=self)
+        self._normalizationBySampleWidget.setChecked(False)
+        self.layout().addRow(self._normalizationBySampleWidget)
+
         # connect signal / slot
         self._stitchingStrategiesWidget.sigChanged.connect(self._updated)
         self._previewSlices.editingFinished.connect(self._sliceForPreviewHasChanged)
@@ -1052,10 +1226,14 @@ class StitchingOptions(qt.QWidget):
             stitching_config.STITCHING_SECTION: {
                 stitching_config.FLIP_LR: self._flipLR_CB.isChecked(),
                 stitching_config.FLIP_UD: self._flipUD_CB.isChecked(),
+                stitching_config.ALIGNMENT_AXIS_1_FIELD: self._alignmentGroup.getAlignmentAxis1().value,
+                stitching_config.ALIGNMENT_AXIS_2_FIELD: self._alignmentGroup.getAlignmentAxis2().value,
+                stitching_config.PAD_MODE_FIELD: self._alignmentGroup.getPadMode(),
             },
             stitching_config.INPUTS_SECTION: {
                 stitching_config.STITCHING_SLICES: slices,
             },
+            stitching_config.NORMALIZATION_BY_SAMPLE_SECTION: self._normalizationBySampleWidget.getConfiguration(),
         }
 
         for ddict in (
@@ -1075,21 +1253,65 @@ class StitchingOptions(qt.QWidget):
         slices = config.get(stitching_config.STITCHING_SECTION, {}).get(
             stitching_config.STITCHING_SLICES, ""
         )
+        # slices
         if slices == "":
             slices = None
         if slices is not None:
             self.setSlices(slices)
+        # flip_lr
         flip_lr = config.get(stitching_config.STITCHING_SECTION, {}).get(
             stitching_config.FLIP_LR, None
         )
         if flip_lr is not None:
             self._flipLR_CB.setChecked(flip_lr in (True, "True", 1, "1"))
-
+        # flip_ud
         flip_ud = config.get(stitching_config.STITCHING_SECTION, {}).get(
             stitching_config.FLIP_UD, None
         )
         if flip_ud is not None:
             self._flipUD_CB.setChecked(flip_ud in (True, "True", 1, "1"))
+        # alignment
+        alignment_axis_1 = config.get(stitching_config.STITCHING_SECTION, {}).get(
+            stitching_config.ALIGNMENT_AXIS_1_FIELD, None
+        )
+        if alignment_axis_1 is not None:
+            self._alignmentGroup.setAlignmentAxis1(alignment_axis_1)
+        alignment_axis_2 = config.get(stitching_config.STITCHING_SECTION, {}).get(
+            stitching_config.ALIGNMENT_AXIS_2_FIELD, None
+        )
+        if alignment_axis_2 is not None:
+            self._alignmentGroup.setAlignmentAxis2(alignment_axis_2)
+        # pad_mode
+        pad_mode = config.get(stitching_config.STITCHING_SECTION, {}).get(
+            stitching_config.PAD_MODE_FIELD, None
+        )
+        if pad_mode is not None:
+            self._alignmentGroup.setPadMode(pad_mode=pad_mode)
+
+        # normalization by sample
+        normalization_by_sample = config.get(
+            stitching_config.NORMALIZATION_BY_SAMPLE_SECTION, None
+        )
+        if normalization_by_sample is not None:
+            self._normalizationBySampleWidget.setConfiguration(normalization_by_sample)
+
+    def _stitchingTypeChanged(self, stiching_type: str):
+        stiching_type = StitchingType.from_value(stiching_type)
+        self._alignmentGroup.setAlignmentAxis1Enabled(
+            stiching_type is StitchingType.Z_POSTPROC
+        )
+
+    def setConfigurationLevel(self, level: ConfigurationLevel):
+        self._alignmentGroup.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._previewSlices.setVisible(level >= ConfigurationLevel.OPTIONAL)
+        self._flipLR_CB.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._flipUD_CB.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._rescalingWidget.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._axis0ShiftSearchParams.setConfigurationLevel(level)
+        self._axis2ShiftSearchParams.setConfigurationLevel(level)
+        self._normalizationBySampleWidget.setVisible(
+            level >= ConfigurationLevel.ADVANCED
+        )
 
 
 class RescalingWidget(qt.QWidget):

tomwer/gui/stitching/stitching_preview.py

@@ -4,6 +4,7 @@ from typing import Union
 import numpy
 from nabu.stitching.frame_composition import ZFrameComposition
 from silx.gui import qt
+from tomwer.gui.utils.buttons import TapeMeasureToolButton
 from tomoscan.esrf.scan.utils import get_data
 from tomoscan.identifier import BaseIdentifier
 from tomoscan.scanbase import TomoScanBase
@@ -13,6 +14,7 @@ from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.gui import icons as tomwer_icons
 from tomwer.gui import settings
 from tomwer.gui.stitching.stitchandbackground import StitchAndBackgroundAlphaMixIn
+from silx.gui.plot import Plot2D, items
 
 try:
     from silx.gui.plot.ImageStack import (  # noqa F401
@@ -24,15 +26,56 @@ except ImportError:
 _logger = logging.getLogger(__name__)
 
 
+class _PreviewPlot2D(Plot2D):
+    """simple inheritance to get data from the 'stitched image' instead of the 'background / overlay' image"""
+
+    def _getImageValue(self, x, y):
+        pickedMask = None
+        for picked in self.pickItems(
+            *self.dataToPixel(x, y, check=False),
+            lambda item: isinstance(item, items.ImageBase),
+        ):
+            if isinstance(picked.getItem(), items.MaskImageData):
+                if pickedMask is None:  # Use top-most if many masks
+                    pickedMask = picked
+            else:
+                # we want to avoid displaying the value of the background image. So just ignore it.
+                # TODO: see with Thomas if there is a better way to do this.
+                # like starting by the active image ?
+                image = picked.getItem()
+                if image.getLegend() == StitchAndBackgroundAlphaMixIn.LEGEND_BACKGROUND:
+                    continue
+
+                indices = picked.getIndices(copy=False)
+                if indices is not None:
+                    row, col = indices[0][0], indices[1][0]
+                    value = image.getData(copy=False)[row, col]
+
+                    if pickedMask is not None:  # Check if masked
+                        maskItem = pickedMask.getItem()
+                        indices = pickedMask.getIndices()
+                        row, col = indices[0][0], indices[1][0]
+                        if maskItem.getData(copy=False)[row, col] != 0:
+                            return value, "Masked"
+                    return value
+
+        return "-"  # No image picked
+
+
 class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn):
     DEFAULT_STITCHED_IMG_ALPHA = 0.95
-    DEFAULT_BACKGROUND_IMG_ALPHA = 0.15
+    DEFAULT_BACKGROUND_IMG_ALPHA = 0.20
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent=parent)  # pylint: disable=E1123
         self._stitched_image = None
         self._composition_background = None
 
+        # replace the simple Plot2D by a `_PreviewPlot2D` (to filter overlay image value to be displayed)
+        self.layout().removeWidget(self._plot)
+        self._plot = _PreviewPlot2D(parent=self)
+        self.layout().addWidget(self._plot)
+
         # tune plot
         self.getPlotWidget().setYAxisInverted(settings.Y_AXIS_DOWNWARD)
         # by default we want to have a full screen display
@@ -47,6 +90,11 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
         self.setKeepDataAspectRatio(True)
         self.getColorBarWidget().hide()
 
+        # tape mesure action
+        self._tapeMeasureButton = TapeMeasureToolButton(parent=self, plot=self._plot)
+        self._tapeMeasureButton.setCheckable(True)
+        self.toolBar().addWidget(self._tapeMeasureButton)
+
         # removing some plot action to clear toolbar
         self.getMaskAction().setVisible(False)
         self.getCopyAction().setVisible(False)
@@ -111,15 +159,19 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
             shape=(
                 (raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0]),
                 frame_width,
+                4,
             ),
         )
-        assert background.ndim == 2
+        assert background.ndim == 3
 
         def get_next_color():
+            yellow = qt.QColor(qt.Qt.yellow)
+            magenta = qt.QColor(qt.Qt.magenta)
+            blue = qt.QColor(qt.Qt.blue)
             while True:
-                yield qt.QColor(qt.Qt.yellow).hue()
-                yield qt.QColor(qt.Qt.magenta).hue()
-                yield qt.QColor(qt.Qt.blue).hue()
+                yield yellow.red(), yellow.green(), yellow.blue(), 255
+                yield magenta.red(), magenta.green(), magenta.blue(), 255
+                yield blue.red(), blue.green(), blue.blue(), 255
 
         colors_raw_frames = []
         for _, color in zip(raw_compositon.local_end_y, get_next_color()):
@@ -127,6 +179,7 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
                 shape=(
                     raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0],
                     frame_width,
+                    4,
                 ),
                 fill_value=color,
             )
@@ -237,3 +290,7 @@ class PreviewStitchingPlot(_PlotWithWaitingLabel, StitchAndBackgroundAlphaMixIn)
 
     def setDefaultColormap(self, *args, **kwargs):
         return self.getPlotWidget().setDefaultColormap(*args, **kwargs)
+
+    def setPixelSize(self, pixel_size: Union[tuple, float]):
+        """set the pixel size to be used by the ruler"""
+        self._tapeMeasureButton.setPixelSize(pixel_size_m=pixel_size)

tomwer/gui/stitching/stitching_raw.py

@@ -6,7 +6,7 @@ from contextlib import AbstractContextManager
 
 from silx.gui import qt
 from silx.gui.plot import PlotWindow
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.tomwer_object import TomwerObject
@@ -561,10 +561,7 @@ class AlphaValueSlider(qt.QTableWidget):
         self._visibleButton.released.connect(self._setVisible)
 
         # expose API
-        self._slider.valueChanged.connect(self._changed)
-
-    def _changed(self, value: int):
-        self.valueChanged.emit(value)
+        self._slider.valueChanged.connect(self.valueChanged)
 
     def _setInvisible(self, *args, **kwargs):
         self._slider.setValue(0)