tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

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",
         )
@@ -664,7 +727,7 @@ class ZStitchingWindow(qt.QMainWindow):
 
         # clean current preview to notify some calculation is going on
         preview_plot = self._widget._mainWidget._previewPlot
-        preview_plot.setWaiting(True)
+        preview_plot._waitingOverlay.show()
 
         # start sitching on a thread
         self._previewThread = PreviewThread(stitching_config=config)
@@ -679,12 +742,14 @@ 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
 
         preview_plot = self._widget._mainWidget._previewPlot
-        preview_plot.setWaiting(False)
+        preview_plot._waitingOverlay.hide()
 
         self._previewThread.finished.disconnect(self._previewCalculationFinished)
         self._previewThread = None
@@ -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):