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

tomwer/gui/reconstruction/nabu/nabuconfig/preprocessing.py

@@ -29,17 +29,18 @@ __date__ = "06/12/2021"
 
 
 import logging
-from typing import Optional
+from typing import Optional, Union
 
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.nabu.utils import (
     _NabuStages,
-    _RingCorrectionMethod,
+    RingCorrectionMethod,
 )
 from tomwer.gui.reconstruction.nabu.nabuconfig.base import _NabuStageConfigBase
 from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel as QComboBox
 from tomwer.gui.utils.scrollarea import QDoubleSpinBoxIgnoreWheel as QDoubleSpinBox
+from tomwer.gui.utils.scrollarea import QSpinBoxIgnoreWheel as QSpinBox
 from tomwer.utils import docstring
 
 _logger = logging.getLogger(__name__)
@@ -78,6 +79,9 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._dffSigmaQDSB.setMinimum(0.0)
         self._dffSigmaQDSB.setDecimals(2)
         self._dffSigmaQDSB.setSingleStep(0.1)
+        self._dffSigmaQDSB.setToolTip(
+            "Sigma value to give to the double flat field unsharp mask"
+        )
         self.layout().addWidget(self._dffSigmaQDSB, 1, 3, 1, 1)
         self.registerWidget(self._flatFieldCB, "required")
         self._dffOptWidgets = [
@@ -92,16 +96,16 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self.registerWidget(self._sinoRingCorrectionCB, "required")
 
         self._sinoRingCorrectionMthd = QComboBox(parent=self, scrollArea=scrollArea)
-        for method in _RingCorrectionMethod:
+        for method in RingCorrectionMethod:
             self._sinoRingCorrectionMthd.addItem(method.value)
         ## force method to be None by default
-        idx = self._sinoRingCorrectionMthd.findText(_RingCorrectionMethod.NONE.value)
+        idx = self._sinoRingCorrectionMthd.findText(RingCorrectionMethod.NONE.value)
         self._sinoRingCorrectionMthd.setCurrentIndex(idx)
 
         self.layout().addWidget(self._sinoRingCorrectionMthd, 2, 2, 1, 1)
         self.registerWidget(self._sinoRingCorrectionMthd, "required")
 
-        self._sinoRingsOpts = SinoRingsOptions(parent=self)
+        self._sinoRingsOpts = SinoRingsOptions(parent=self, scrollArea=scrollArea)
         self.layout().addWidget(self._sinoRingsOpts, 3, 1, 1, 3)
 
         ## ccd filter
@@ -232,8 +236,8 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._sinoRingCorrectionMthd.currentIndexChanged.connect(
             self._sinoRingCorrectionChanged
         )
-        self._sinoRingsOpts._levels.valueChanged.connect(self._sinoRingOptsChanged)
-        self._sinoRingsOpts._sigma.valueChanged.connect(self._sinoRingOptsChanged)
+        self._sinoRingsOpts._levelsMunch.valueChanged.connect(self._sinoRingOptsChanged)
+        self._sinoRingsOpts._sigmaMunch.valueChanged.connect(self._sinoRingOptsChanged)
 
         self._tiltCorrection.toggled.connect(self._tiltCorrectionChanged)
         self._tiltCorrection.sigChanged.connect(self._tiltCorrectionChanged)
@@ -266,9 +270,13 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._signalConfChanged("take_logarithm")
 
     def _sinoRingCorrectionChanged(self, *args, **kwargs):
-        self._sinoRingsOpts.setVisible(
-            self.getSinoRingcorrectionMethod() in (_RingCorrectionMethod.MUNCH.value,)
-        )
+        method = self.getSinoRingcorrectionMethod()
+        if method is not RingCorrectionMethod.NONE.value:
+            self._sinoRingsOpts.setVisible(True)
+            self._sinoRingsOpts.setMethod(method)
+        else:
+            self._sinoRingsOpts.setVisible(False)
+
         self._signalConfChanged("sino_rings_correction")
 
     def _sinoRingOptsChanged(self, *args, **kwargs):
@@ -341,8 +349,11 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         opt_as_dict = {}
         for opt in options.split(";"):
             opt = opt.replace(" ", "")
-            key, value = opt.split("=")
-            opt_as_dict[key] = value
+            if len(opt.split("=")) == 2:
+                key, value = opt.split("=")
+                opt_as_dict[key] = value
+            else:
+                _logger.info(f"ignore option {opt}. Invalid synthax")
 
         self._sinoRingsOpts.setOptions(opt_as_dict)
 
@@ -412,8 +423,8 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         sino_rings_correction = conf.get("sino_rings_correction", None)
         if sino_rings_correction is not None:
             if sino_rings_correction == "":
-                sino_rings_correction = _RingCorrectionMethod.NONE
-            sino_rings_correction = _RingCorrectionMethod.from_value(
+                sino_rings_correction = RingCorrectionMethod.NONE
+            sino_rings_correction = RingCorrectionMethod.from_value(
                 sino_rings_correction
             ).value
             idx = self._sinoRingCorrectionMthd.findText(sino_rings_correction)
@@ -431,32 +442,212 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
 
 
 class SinoRingsOptions(qt.QWidget):
-    def __init__(self, parent=None, *args, **kwargs):
+    _VO_DIMS = ("horizontaly", "horizontaly and vertically")
+
+    def __init__(self, parent=None, scrollArea=None, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
+        self._method = None
         self.setLayout(qt.QFormLayout())
-        self._sigma = qt.QDoubleSpinBox(self)
-        self._sigma.setRange(0.0, 2147483647)
-        self.layout().addRow("sigma", self._sigma)
-
-        self._levels = qt.QSpinBox(self)
-        self._levels.setRange(0, 2147483647)
-        self.layout().addRow("levels", self._levels)
-
+        self.layout().setContentsMargins(0, 0, 0, 0)
+        self.layout().setSpacing(0)
+        # munch parameters
+        self._sigmaMunchLabel = qt.QLabel("sigma", self)
+        self._sigmaMunch = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaMunch.setRange(0.0, 2147483647)
+        self.layout().addRow(self._sigmaMunchLabel, self._sigmaMunch)
+
+        self._levelsMunchLabel = qt.QLabel("levels", self)
+        self._levelsMunch = QSpinBox(self, scrollArea=scrollArea)
+        self._levelsMunch.setRange(0, 2147483647)
+        self.layout().addRow(self._levelsMunchLabel, self._levelsMunch)
+
+        self._paddingMunch = qt.QCheckBox("padding", self)
+        self.layout().addWidget(self._paddingMunch)
+
+        # vo parameters
+        self._snrVOLabel = qt.QLabel("snr", self)
+        self._snrVO = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._snrVO.setMinimum(0.0)
+        tooltip = "Ratio used to locate large stripes. Greater is less sensitive."
+        self._snrVO.setToolTip(tooltip)
+        self._snrVOLabel.setToolTip(tooltip)
+        self.layout().addRow(self._snrVOLabel, self._snrVO)
+
+        self._laSizeVOLabel = qt.QLabel("la_size", self)
+        self._laSizeVO = QSpinBox(self, scrollArea=scrollArea)
+        self._laSizeVO.setMinimum(0)
+        tooltip = "Window size of the median filter to remove large stripes."
+        self._laSizeVO.setToolTip(tooltip)
+        self._laSizeVOLabel.setToolTip(tooltip)
+        self.layout().addRow(self._laSizeVOLabel, self._laSizeVO)
+
+        self._smSizeVOLabel = qt.QLabel("sm_size", self)
+        self._smSizeVO = QSpinBox(self, scrollArea=scrollArea)
+        self._smSizeVO.setMinimum(0)
+        tooltip = "Window size of the median filter to remove small-to-medium stripes."
+        self._laSizeVO.setToolTip(tooltip)
+        self._smSizeVOLabel.setToolTip(tooltip)
+        self.layout().addRow(self._smSizeVOLabel, self._smSizeVO)
+
+        self._dimVOLabel = qt.QLabel("dimension", self)
+        self._dimVO = QComboBox(self, scrollArea=scrollArea)
+        self._dimVO.addItems(self._VO_DIMS)
+        self.layout().addRow(self._dimVOLabel, self._dimVO)
+
+        # sino mean deringer
+        self._sigmaLowLabel = qt.QLabel("signal low", self)
+        self._sigmaLow = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaLow.setMinimum(0.0)
+        self._sigmaHighLabel = qt.QLabel("signal high", self)
+        self.layout().addRow(self._sigmaLowLabel, self._sigmaLow)
+
+        self._sigmaHigh = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaHigh.setMinimum(0.0)
+        tooltip = (
+            "sigma low and sigma high values are defining the standard deviation of "
+            "gaussian(sigma_low) * (1 - gaussian(sigma_high)). \n"
+            "High values of sigma mean stronger effect of associated filters."
+        )
+        self._sigmaHigh.setToolTip(tooltip)
+        self._sigmaLow.setToolTip(tooltip)
+        self.layout().addRow(self._sigmaHighLabel, self._sigmaHigh)
         # set up
-        self._sigma.setValue(1.0)
-        self._levels.setValue(10)
+        self.resetConfiguration()
+
+    def resetConfiguration(self):
+        self.setMethod(method=RingCorrectionMethod.MUNCH)
+        self._levelsMunch.setValue(10)
+        self._sigmaMunch.setValue(1.0)
+        self._paddingMunch.setChecked(False)
+
+        self._sigmaHigh.setValue(30.0)
+        self._sigmaLow.setValue(0.0)
+
+        self._snrVO.setValue(3.0)
+        self._laSizeVO.setValue(51)
+        self._smSizeVO.setValue(21)
+
+    def getVoDim(self):
+        if self._dimVO.currentText() == self._VO_DIMS[0]:
+            return 1
+        elif self._dimVO.currentText() == self._VO_DIMS[1]:
+            return 2
+        else:
+            raise NotImplementedError
+
+    def setVoDim(self, dim: Union[int, str]):
+        if dim in ("1", 1, self._VO_DIMS[0]):
+            self._dimVO.setCurrentText(self._VO_DIMS[0])
+        elif dim in ("2", 2, self._VO_DIMS[1]):
+            self._dimVO.setCurrentText(self._VO_DIMS[1])
+        else:
+            raise NotImplementedError(f"dim {dim} not handled")
 
     def getOptions(self) -> dict:
-        return {
-            "sigma": self._sigma.value(),
-            "levels": self._levels.value(),
-        }
+        if self.getMethod() is RingCorrectionMethod.NONE:
+            return {}
+        elif self.getMethod() is RingCorrectionMethod.MUNCH:
+            return {
+                "sigma": self._sigmaMunch.value(),
+                "levels": self._levelsMunch.value(),
+                "padding": self._paddingMunch.isChecked(),
+            }
+        elif self.getMethod() is RingCorrectionMethod.VO:
+            return {
+                "snr": self._snrVO.value(),
+                "la_size": self._laSizeVO.value(),
+                "sm_size": self._smSizeVO.value(),
+                "dim": self.getVoDim(),
+            }
+        elif self.getMethod() in (
+            RingCorrectionMethod.MEAN_DIVISION,
+            RingCorrectionMethod.MEAN_SUBTRACTION,
+        ):
+            return {
+                "filter_cutoff": (self._sigmaLow.value(), self._sigmaHigh.value()),
+            }
+        else:
+            raise NotImplementedError
 
     def setOptions(self, options: dict) -> None:
+        # handle munch propertoies
         if "sigma" in options:
-            self._sigma.setValue(float(options["sigma"]))
+            self._sigmaMunch.setValue(float(options["sigma"]))
         if "levels" in options:
-            self._levels.setValue(int(options["levels"]))
+            self._levelsMunch.setValue(int(options["levels"]))
+        padding = options.get("padding")
+        if padding is not None:
+            self._paddingMunch.setChecked(padding in (True, 1, "1", "True"))
+        # handle VO properties
+        snr = options.get("snr")
+        if snr is not None:
+            self._snrVO.setValue(float(snr))
+        la_size = options.get("la_size")
+        if la_size is not None:
+            self._laSizeVO.setValue(int(la_size))
+        sm_size = options.get("sm_size")
+        if sm_size is not None:
+            self._smSizeVO.setValue(int(sm_size))
+        dim = options.get("dim")
+        if dim is not None:
+            self.setVoDim(dim)
+        # handle mean subtraction or division options
+        filter_cutoff = options.get("filter_cutoff")
+        if filter_cutoff is not None:
+            low_pass, high_pass = filter_cutoff
+            self._sigmaLow.setValue(float(low_pass))
+            self._sigmaHigh.setValue(float(high_pass))
+
+    def setMethod(self, method: RingCorrectionMethod):
+        method = RingCorrectionMethod.from_value(method)
+        self._method = method
+        # handle munch options
+        self._sigmaMunch.setVisible(method is RingCorrectionMethod.MUNCH)
+        self._sigmaMunchLabel.setVisible(method is RingCorrectionMethod.MUNCH)
+        self._levelsMunch.setVisible(method is RingCorrectionMethod.MUNCH)
+        self._levelsMunchLabel.setVisible(method is RingCorrectionMethod.MUNCH)
+        self._paddingMunch.setVisible(method is RingCorrectionMethod.MUNCH)
+        # handle VO options
+        self._snrVO.setVisible(method is RingCorrectionMethod.VO)
+        self._snrVOLabel.setVisible(method is RingCorrectionMethod.VO)
+        self._laSizeVO.setVisible(method is RingCorrectionMethod.VO)
+        self._laSizeVOLabel.setVisible(method is RingCorrectionMethod.VO)
+        self._smSizeVO.setVisible(method is RingCorrectionMethod.VO)
+        self._smSizeVOLabel.setVisible(method is RingCorrectionMethod.VO)
+        self._dimVO.setVisible(method is RingCorrectionMethod.VO)
+        self._dimVOLabel.setVisible(method is RingCorrectionMethod.VO)
+        # mean subtractions / division deringer
+        self._sigmaLow.setVisible(
+            method
+            in (
+                RingCorrectionMethod.MEAN_DIVISION,
+                RingCorrectionMethod.MEAN_SUBTRACTION,
+            )
+        )
+        self._sigmaLowLabel.setVisible(
+            method
+            in (
+                RingCorrectionMethod.MEAN_DIVISION,
+                RingCorrectionMethod.MEAN_SUBTRACTION,
+            )
+        )
+        self._sigmaHigh.setVisible(
+            method
+            in (
+                RingCorrectionMethod.MEAN_DIVISION,
+                RingCorrectionMethod.MEAN_SUBTRACTION,
+            )
+        )
+        self._sigmaHighLabel.setVisible(
+            method
+            in (
+                RingCorrectionMethod.MEAN_DIVISION,
+                RingCorrectionMethod.MEAN_SUBTRACTION,
+            )
+        )
+
+    def getMethod(self) -> RingCorrectionMethod:
+        return self._method
 
 
 class TiltCorrection(qt.QGroupBox):

tomwer/gui/reconstruction/nabu/nabuconfig/reconstruction.py

@@ -35,6 +35,7 @@ from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
 from silx.utils.enum import Enum as _Enum
 
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.process.reconstruction.nabu.nabuslices import NabuSliceMode
 from tomwer.core.process.reconstruction.nabu.utils import (
     _NabuFBPFilterType,
@@ -85,16 +86,13 @@ class SliceGroupBox(qt.QGroupBox):
 
         # connect signal / slot
         self._modeCB.currentIndexChanged.connect(self._updateSliceQLEVisibilty)
-        self._modeCB.currentIndexChanged.connect(self._triggerSlicesChanged)
-        self._sliceQLE.editingFinished.connect(self._triggerSlicesChanged)
-        self.toggled.connect(self._triggerSlicesChanged)
+        self._modeCB.currentIndexChanged.connect(self.sigSlicesChanged)
+        self._sliceQLE.editingFinished.connect(self.sigSlicesChanged)
+        self.toggled.connect(self.sigSlicesChanged)
 
     def _updateSliceQLEVisibilty(self, *args, **kwargs):
         self._sliceQLE.setVisible(self.getMode() == NabuSliceMode.OTHER)
 
-    def _triggerSlicesChanged(self):
-        self.sigSlicesChanged.emit()
-
     def setMode(self, mode: NabuSliceMode):
         mode = NabuSliceMode.from_value(mode)
         item_index = self._modeCB.findText(mode.value)
@@ -303,55 +301,74 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         # come with an issue as we are on a scroll area
         self._slicesWidget.setFocusPolicy(qt.Qt.FocusPolicy.NoFocus)
 
+        # axis
+        self._axisLabel = qt.QLabel("reconstruction plane", self)
+        self._axisLabel.setToolTip("Over which axis the slice must be picked")
+        self.layout().addWidget(self._axisLabel)
+        self._axisQCB = qt.QComboBox(self)
+        axis_tooltips = {
+            NabuPlane.YZ.value: "along axis x (aka axis 2 - expected to be slow)",
+            NabuPlane.XZ.value: "along axis y (aka axis 1 - expected to be slow)",
+            NabuPlane.XY.value: "along axis Z (aka axis 0 - fastest)",
+        }
+        for item, tooltip in axis_tooltips.items():
+            self._axisQCB.addItem(item)
+            self._axisQCB.setItemData(
+                self._axisQCB.findText(item),
+                tooltip,
+                qt.Qt.ToolTipRole,
+            )
+        self.layout().addWidget(self._axisQCB, 1, 1, 1, 1)
+
         # method
         self._methodLabel = qt.QLabel("method", self)
-        self.layout().addWidget(self._methodLabel, 1, 0, 1, 1)
+        self.layout().addWidget(self._methodLabel, 2, 0, 1, 1)
         self._methodQCB = QComboBoxIgnoreWheel(parent=self, scrollArea=scrollArea)
         for method in _NabuReconstructionMethods:
             self._methodQCB.addItem(method.value)
-        self.layout().addWidget(self._methodQCB, 1, 1, 1, 1)
+        self.layout().addWidget(self._methodQCB, 2, 1, 1, 1)
         self.registerWidget(self._methodLabel, "required")
         self.registerWidget(self._methodQCB, "required")
 
         # angle_offset
         self._labelOffsetLabel = qt.QLabel("angle offset (in degree)", self)
-        self.layout().addWidget(self._labelOffsetLabel, 2, 0, 1, 1)
+        self.layout().addWidget(self._labelOffsetLabel, 3, 0, 1, 1)
         self._angleOffsetQDSB = QDoubleSpinBoxIgnoreWheel(self, scrollArea)
         self._angleOffsetQDSB.setMaximum(-180)
         self._angleOffsetQDSB.setMaximum(180)
-        self.layout().addWidget(self._angleOffsetQDSB, 2, 1, 1, 1)
+        self.layout().addWidget(self._angleOffsetQDSB, 3, 1, 1, 1)
         self.registerWidget(self._labelOffsetLabel, "advanced")
         self.registerWidget(self._angleOffsetQDSB, "advanced")
 
         # fbp filter type
         self._fbpFilterCB = qt.QCheckBox("fbp filter", self)
-        self.layout().addWidget(self._fbpFilterCB, 3, 0, 1, 1)
+        self.layout().addWidget(self._fbpFilterCB, 4, 0, 1, 1)
         self._fbpFilterType = QComboBoxIgnoreWheel(self, scrollArea)
         for filter_type in _NabuFBPFilterType:
             self._fbpFilterType.addItem(filter_type.value)
-        self.layout().addWidget(self._fbpFilterType, 3, 1, 1, 1)
+        self.layout().addWidget(self._fbpFilterType, 4, 1, 1, 1)
         self.registerWidget(self._fbpFilterCB, "advanced")
         self.registerWidget(self._fbpFilterType, "advanced")
 
         # padding type
         self._paddingTypeLabel = qt.QLabel("padding type", self)
-        self.layout().addWidget(self._paddingTypeLabel, 4, 0, 1, 1)
+        self.layout().addWidget(self._paddingTypeLabel, 5, 0, 1, 1)
         self._paddingType = QComboBoxIgnoreWheel(self, scrollArea)
         for fbp_padding_type in _NabuPaddingType:
             self._paddingType.addItem(fbp_padding_type.value)
-        self.layout().addWidget(self._paddingType, 4, 1, 1, 1)
+        self.layout().addWidget(self._paddingType, 5, 1, 1, 1)
         self.registerWidget(self._paddingTypeLabel, "optional")
         self.registerWidget(self._paddingType, "optional")
 
         # sub region
         self._subRegionSelector = _NabuReconstructionSubRegion(parent=self)
-        self.layout().addWidget(self._subRegionSelector, 6, 0, 1, 2)
+        self.layout().addWidget(self._subRegionSelector, 7, 0, 1, 2)
 
         # iterations
         self._iterationsLabel = qt.QLabel("iterations", self)
-        self.layout().addWidget(self._iterationsLabel, 7, 0, 1, 1)
+        self.layout().addWidget(self._iterationsLabel, 8, 0, 1, 1)
         self._iterationSB = qt.QSpinBox(parent=self)
-        self.layout().addWidget(self._iterationSB, 7, 1, 1, 1)
+        self.layout().addWidget(self._iterationSB, 8, 1, 1, 1)
         self._iterationSB.setMinimum(1)
         self._iterationSB.setMaximum(9999)
         # not supported for now so hidden
@@ -362,14 +379,14 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._binSubSamplingGB = _BinSubSampling(
             "binning and subsampling", parent=self, scrollArea=scrollArea
         )
-        self.layout().addWidget(self._binSubSamplingGB, 8, 0, 1, 2)
+        self.layout().addWidget(self._binSubSamplingGB, 9, 0, 1, 2)
 
         # optimization algorithm:
         # set has default value for now, because has only one at the moment
 
         # weight total variation
         self._tvLabel = qt.QLabel("total variation weight", self)
-        self.layout().addWidget(self._tvLabel, 9, 0, 1, 1)
+        self.layout().addWidget(self._tvLabel, 10, 0, 1, 1)
         self._totalVariationWeight = qt.QDoubleSpinBox(self)
         self._totalVariationWeight.setMinimum(0.0)
         self._totalVariationWeight.setMaximum(1.0)
@@ -385,7 +402,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._preconditioningFilter.setToolTip(
             'Whether to enable "filter ' 'preconditioning" for iterative' " methods"
         )
-        self.layout().addWidget(self._preconditioningFilter, 9, 0, 1, 2)
+        self.layout().addWidget(self._preconditioningFilter, 10, 0, 1, 2)
         # not supported for now so hidden
         self._preconditioningFilter.hide()
 
@@ -394,7 +411,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._positivityConstraintCB.setToolTip(
             "Whether to enforce a " "positivity constraint in the " "reconstruction."
         )
-        self.layout().addWidget(self._positivityConstraintCB, 10, 0, 1, 2)
+        self.layout().addWidget(self._positivityConstraintCB, 11, 0, 1, 2)
         # not supported for now so hidden
         self._positivityConstraintCB.hide()
 
@@ -403,28 +420,28 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._clipOuterCircleCB.setToolTip(
             "Whether to set to zero voxels falling outside of the reconstruction region"
         )
-        self.layout().addWidget(self._clipOuterCircleCB, 11, 0, 1, 2)
+        self.layout().addWidget(self._clipOuterCircleCB, 12, 0, 1, 2)
         self.registerWidget(self._clipOuterCircleCB, "optional")
 
         # centered axis option
         self._centeredAxisCB = qt.QCheckBox("centered axis", self)
         self._centeredAxisCB.setToolTip("")
-        self.layout().addWidget(self._centeredAxisCB, 12, 0, 1, 2)
+        self.layout().addWidget(self._centeredAxisCB, 13, 0, 1, 2)
         self.registerWidget(self._centeredAxisCB, "optional")
 
         # translation movement file
         self._transMvtFileLabel = qt.QLabel("translation movement file", self)
-        self.layout().addWidget(self._transMvtFileLabel, 21, 0, 1, 1)
+        self.layout().addWidget(self._transMvtFileLabel, 22, 0, 1, 1)
         self._transMvtFileWidget = TranslationMvtFileWidget(self)
-        self.layout().addWidget(self._transMvtFileWidget, 21, 1, 1, 1)
+        self.layout().addWidget(self._transMvtFileWidget, 22, 1, 1, 1)
         self.registerWidget(self._transMvtFileLabel, "advanced")
         self.registerWidget(self._transMvtFileWidget, "advanced")
 
         # angle files (if the user want's to overwrite rotation angles)
         self._angleFileLabel = qt.QLabel("angles file", self)
-        self.layout().addWidget(self._angleFileLabel, 22, 0, 1, 1)
+        self.layout().addWidget(self._angleFileLabel, 23, 0, 1, 1)
         self._anglesFileWidget = AnglesFileWidget(self)
-        self.layout().addWidget(self._anglesFileWidget, 22, 1, 1, 1)
+        self.layout().addWidget(self._anglesFileWidget, 23, 1, 1, 1)
         self.registerWidget(self._angleFileLabel, "advanced")
         self.registerWidget(self._anglesFileWidget, "advanced")
 
@@ -434,6 +451,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self.layout().addWidget(spacer, 200, 1, 1, 1)
 
         # set up
+        self.setNabuPlane("XY")
         self._fbpFilterCB.setChecked(True)
         fbp_item = self._methodQCB.findText(_NabuReconstructionMethods.FBP.value)
         self._methodQCB.setCurrentIndex(fbp_item)
@@ -450,6 +468,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._centeredAxisCB.setChecked(False)
 
         # connect signal / slot
+        self._axisQCB.currentIndexChanged.connect(self._slicesChanged)
         self._methodQCB.currentIndexChanged.connect(self._methodChanged)
         self._angleOffsetQDSB.editingFinished.connect(self._angleOffsetChanged)
         self._fbpFilterCB.toggled.connect(self._FBPFilterTypeChanged)
@@ -631,6 +650,14 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
     def setCenteredAxis(self, checked: bool):
         self._centeredAxisCB.setChecked(checked)
 
+    def getNabuPlane(self) -> NabuPlane:
+        """return over which axis we expect to do the reconstruction"""
+        return NabuPlane.from_value(self._axisQCB.currentText())
+
+    def setNabuPlane(self, axis: typing.Union[str, NabuPlane]):
+        axis = NabuPlane.from_value(axis)
+        self._axisQCB.setCurrentText(axis.value)
+
     @docstring(_NabuStageConfigBase)
     def getConfiguration(self) -> dict:
         fbp_filter_type = self.getFBPFilterType()
@@ -640,6 +667,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
             fbp_filter_type = fbp_filter_type.value
         config = {
             "method": self.getMethod().value,
+            "slice_plane": self.getNabuPlane().value,
             "angles_file": self.getAnglesFile(),
             "axis_correction_file": "",  # not managed for now
             "angle_offset": self.getAngleOffset(),
@@ -692,6 +720,8 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
             self.setClipOuterCircle(bool(config["clip_outer_circle"]))
         if "centered_axis" in config:
             self.setCenteredAxis(bool(config["centered_axis"]))
+        if "slice_plane" in config:
+            self.setNabuPlane(config["slice_plane"])
         self._subRegionSelector.setConfiguration(config=config)
 
     def _signalConfChanged(self, param):

tomwer/gui/reconstruction/nabu/nabuflow.py

@@ -108,23 +108,27 @@ class NabuFlowControl(qt.QWidget):
         self._iniProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.INI)
         )
-        self._iniProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._iniProcessWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._preProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PRE)
         )
-        self._preProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._preProcessWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._phaseProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PHASE)
         )
-        self._phaseProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._phaseProcessWidgets.sigWidgetDeactivated.connect(
+            self.sigResetConfiguration
+        )
         self._processWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.PROC)
         )
-        self._processWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._processWidgets.sigWidgetDeactivated.connect(self.sigResetConfiguration)
         self._postProcessWidgets.sigWidgetActivated.connect(
             functools.partial(self._updateActiveProcess, _NabuStages.POST)
         )
-        self._postProcessWidgets.sigWidgetDeactivated.connect(self._activeProcessUnset)
+        self._postProcessWidgets.sigWidgetDeactivated.connect(
+            self.sigResetConfiguration
+        )
 
         # set up
         self.setIniprocVisible(False)
@@ -133,9 +137,6 @@ class NabuFlowControl(qt.QWidget):
         self.setProcVisible(True)
         self.setPostVisible(True)
 
-    def _activeProcessUnset(self):
-        self.sigResetConfiguration.emit()
-
     def _updateActiveProcess(self, stage):
         stage = _NabuStages.from_value(stage)
 
@@ -396,14 +397,8 @@ class NabuFlowArea(qt.QWidget):
 
         # connect signal / slot
         self._addRmWidget.sigRmProcess.connect(self._control._removeActiveProcess)
-        self._control.sigConfigurationChanged.connect(self._repeatConfigSignal)
-        self._control.sigResetConfiguration.connect(self._repeatResetConfigSignal)
-
-    def _repeatConfigSignal(self, *args):
-        self.sigConfigurationChanged.emit(*args)
-
-    def _repeatResetConfigSignal(self):
-        self.sigResetConfiguration.emit()
+        self._control.sigConfigurationChanged.connect(self.sigConfigurationChanged)
+        self._control.sigResetConfiguration.connect(self.sigResetConfiguration)
 
     @docstring(NabuFlowControl)
     def setIniProcessing(self, processes, icons):
@@ -464,12 +459,9 @@ class _AddRemoveProcessWidget(qt.QWidget):
 
         # connect signal / slot
         self._addButton.pressed.connect(self._addProcess)
-        self._rmButton.pressed.connect(self._rmProcess)
+        self._rmButton.pressed.connect(self.sigRmProcess)
 
     def _addProcess(self):
         # should be able to add a process from ini, post, processing and pre
 
         raise NotImplementedError(" not implemented, to be defined")
-
-    def _rmProcess(self):
-        self.sigRmProcess.emit()