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

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

@@ -34,8 +34,9 @@ import typing
 
 from silx.gui import qt
 
-from tomwer.core.process.reconstruction.nabu.nabucommon import NabuOutputFileFormat
+from tomwer.core.process.reconstruction.output import NabuOutputFileFormat
 from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
+from tomwer.core.process.reconstruction.output import ProcessDataOutputDirMode
 from tomwer.gui.qlefilesystem import QLFileSystem
 from tomwer.gui.reconstruction.nabu.nabuconfig.base import _NabuStageConfigBase
 from tomwer.io.utils import get_default_directory
@@ -79,51 +80,110 @@ class QNabuFileFormatComboBoxIgnoreWheel(QNabuFileFormatComboBox):
         pass
 
 
-class NabuOutputLocationWidget(qt.QWidget):
+class NabuOutputLocationWidget(qt.QGroupBox):
+    sigOutputChanged = qt.Signal()
+    """Emit when location changed"""
+
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.setLayout(qt.QHBoxLayout())
+        super().__init__(title="output folder", *args, **kwargs)
+        self.setLayout(qt.QGridLayout())
 
-        self._outputLabel = qt.QLabel("output:", self)
         self.layout().setContentsMargins(0, 0, 0, 0)
         self.layout().setSpacing(0)
-        self.layout().addWidget(self._outputLabel)
 
-        self._defaultOutput = qt.QCheckBox("raw data root level", self)
-        self._defaultOutput.setToolTip(
-            "set reconstruction at the the same " "level as raw data"
+        # in scan folder
+        self._inScanFolderRB = qt.QRadioButton(
+            ProcessDataOutputDirMode.IN_SCAN_FOLDER.value, self
+        )
+        self._inScanFolderRB.setToolTip(
+            "Reconstruction will be saved at the same level as the acquisition folder. (near the NXtomo file (.nx) or under the spec acquisition folder)"
+        )
+        self.layout().addWidget(self._inScanFolderRB, 1, 0, 1, 1)
+        # in processed data dir
+        self._processedDataDirRB = qt.QRadioButton(
+            ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER.value, self
+        )
+        self._inScanFolderRB.setToolTip(
+            "Reconstruction will be saved under the PROCESSED_DATA/dataset folder. if exists else under the scan folder."
         )
-        self.layout().addWidget(self._defaultOutput)
+        self.layout().addWidget(self._processedDataDirRB, 2, 0, 1, 1)
+        # raw data dir
+        self._rawDataDirRB = qt.QRadioButton(
+            ProcessDataOutputDirMode.RAW_DATA_FOLDER.value, self
+        )
+        self._rawDataDirRB.setToolTip(
+            "Reconstruction will be saved under the RAW_DATA/dataset folder. if exists else under the scan folder."
+        )
+        self.layout().addWidget(self._rawDataDirRB, 3, 0, 1, 1)
+        # other dir
+        self._otherDirRB = qt.QRadioButton(ProcessDataOutputDirMode.OTHER.value, self)
+        self._otherDirRB.setToolTip(
+            "Reconstruction will be saved under user provided folder."
+        )
+        self.layout().addWidget(self._otherDirRB, 4, 0, 1, 1)
         self._outputDirQLE = QLFileSystem(
             "", self, filters=qt.QDir.NoDotAndDotDot | qt.QDir.Dirs
         )
-        self.layout().addWidget(self._outputDirQLE)
+        self.layout().addWidget(self._outputDirQLE, 4, 1, 1, 1)
         style = qt.QApplication.style()
         icon_opendir = style.standardIcon(qt.QStyle.SP_DirOpenIcon)
         self._selectOutputPB = qt.QPushButton(icon_opendir, "", self)
         self._selectOutputPB.setIcon(icon_opendir)
-        general_tooltip = "You can enter a string with some keywords like {my_keyword}. Those will be interpreted during runtime according to scan metadata. Possible keywords are:"
-        "\n - 'scan_dir_name': returns name of the directory containing the acquisition (! not a path !)"
-        "\n - 'scan_basename': returns basename of the directory containing the acquisition"
-        "\n - 'scan_parent_dir_basename': returns basename of the PARENT directory containing the acquisition"
+        general_tooltip = (
+            "You can enter a string with some keywords like {my_keyword}. Those will be interpreted during runtime according to scan metadata. Possible keywords are:"
+            + "\n - 'scan_dir_name': returns name of the directory containing the acquisition (! not a path !)"
+            + "\n - 'scan_basename': returns basename of the directory containing the acquisition"
+            + "\n - 'scan_parent_dir_basename': returns basename of the PARENT directory containing the acquisition"
+        )
 
         self._selectOutputPB.setToolTip(general_tooltip)
         self._outputDirQLE.setToolTip(general_tooltip)
-        self.layout().addWidget(self._selectOutputPB)
+        self.layout().addWidget(self._selectOutputPB, 4, 2, 1, 1)
+
+        # set up:
+        self._inScanFolderRB.setChecked(True)
 
         # connect signal / slot
-        self._defaultOutput.toggled.connect(self._hideOutput)
+        self._inScanFolderRB.toggled.connect(self._outputModeChanged)
+        self._processedDataDirRB.toggled.connect(self._outputModeChanged)
+        self._rawDataDirRB.toggled.connect(self._outputModeChanged)
+        self._otherDirRB.toggled.connect(self._outputModeChanged)
         self._selectOutputPB.released.connect(self._selectOutput)
-        self._defaultOutput.setChecked(True)
-        self._hideOutput(True)
-
-    def _hideOutput(self, hide):
-        self._outputDirQLE.setVisible(not hide)
-        self._selectOutputPB.setVisible(not hide)
+        self._inScanFolderRB.setChecked(True)
+        self._outputModeChanged()
+
+    def getOutputDirMode(self) -> ProcessDataOutputDirMode:
+        if self._inScanFolderRB.isChecked():
+            return ProcessDataOutputDirMode.IN_SCAN_FOLDER
+        elif self._processedDataDirRB.isChecked():
+            return ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER
+        elif self._rawDataDirRB.isChecked():
+            return ProcessDataOutputDirMode.RAW_DATA_FOLDER
+        elif self._otherDirRB.isChecked():
+            return ProcessDataOutputDirMode.OTHER
+
+    def setOutputDirMode(
+        self, mode: typing.Union[ProcessDataOutputDirMode, str]
+    ) -> None:
+        mode = ProcessDataOutputDirMode.from_value(mode)
+        if mode is ProcessDataOutputDirMode.IN_SCAN_FOLDER:
+            self._inScanFolderRB.setChecked(True)
+        elif mode is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
+            self._processedDataDirRB.setChecked(True)
+        elif mode is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+            self._rawDataDirRB.setChecked(True)
+        elif mode is ProcessDataOutputDirMode.OTHER:
+            self._otherDirRB.setChecked(True)
+
+    def _outputModeChanged(self, *args, **kwargs):
+        outputMode = self.getOutputDirMode()
+        self._outputDirQLE.setVisible(outputMode is ProcessDataOutputDirMode.OTHER)
+        self._selectOutputPB.setVisible(outputMode is ProcessDataOutputDirMode.OTHER)
+        self.sigOutputChanged.emit()
 
     def _selectOutput(self):  # pragma: no cover
         defaultDirectory = self._outputDirQLE.text()
-        if os.path.isdir(defaultDirectory):
+        if not os.path.isdir(defaultDirectory):
             defaultDirectory = get_default_directory()
 
         dialog = qt.QFileDialog(self, directory=defaultDirectory)
@@ -141,16 +201,15 @@ class NabuOutputLocationWidget(qt.QWidget):
         :return: None if the default output directory is selected else
                  return path to the directory
         """
-        if self._defaultOutput.isChecked():
-            return None
-        else:
+        if self._otherDirRB.isChecked():
             return self._outputDirQLE.text()
+        else:
+            return None
 
     def setOutputDir(self, output_dir):
         if output_dir in (None, ""):
-            self._defaultOutput.setChecked(True)
+            pass
         else:
-            self._defaultOutput.setChecked(False)
             self._outputDirQLE.setText(output_dir)
 
 
@@ -170,7 +229,7 @@ class _NabuOutputConfig(_NabuStageConfigBase, qt.QWidget):
         self.setLayout(qt.QGridLayout())
 
         # output dir
-        self._output_dir_widget = NabuOutputLocationWidget(self)
+        self._output_dir_widget = NabuOutputLocationWidget(parent=self)
         self.layout().addWidget(self._output_dir_widget, 0, 0, 1, 4)
         self.registerWidget(self._output_dir_widget, "advanced")
 
@@ -207,7 +266,7 @@ class _NabuOutputConfig(_NabuStageConfigBase, qt.QWidget):
         self._output_dir_widget._outputDirQLE.editingFinished.connect(
             self._outputDirChanged
         )
-        self._output_dir_widget._defaultOutput.toggled.connect(self._outputDirChanged)
+        self._output_dir_widget.sigOutputChanged.connect(self._outputDirChanged)
         self._fileFormatCB.currentTextChanged.connect(self._fileFormatChanged)
         self._framePerGroup.valueChanged.connect(self._framePerGroupChanged)
 
@@ -226,6 +285,12 @@ class _NabuOutputConfig(_NabuStageConfigBase, qt.QWidget):
     def setOutputDir(self, dir):
         return self._output_dir_widget.setOutputDir(dir)
 
+    def getOutputdirMode(self):
+        return self._output_dir_widget.getOutputDirMode()
+
+    def setOutputdirMode(self, mode):
+        return self._output_dir_widget.setOutputDirMode(mode=mode)
+
     def getFileFormat(self) -> NabuOutputFileFormat:
         return NabuOutputFileFormat.from_value(self._fileFormatCB.currentText())
 
@@ -244,13 +309,25 @@ class _NabuOutputConfig(_NabuStageConfigBase, qt.QWidget):
         return {
             "file_format": self.getFileFormat().value,
             "location": self.getOutputDir() or "",
+            "output_dir_mode": self.getOutputdirMode().value,
             # 'frames_per_group': self.getFramePerGroup(),
         }
 
     def setConfiguration(self, config):
         if "file_format" in config:
             self.setFileformat(config["file_format"])
-        if "location" in config:
-            self.setOutputDir(config["location"])
+        location = config.get("location", None)
+        if location == "":
+            location = None
+        if location is not None:
+            self.setOutputDir(location)
         if "frames_per_group" in config:
             self.setFramePerGroup(int(config["frames_per_group"]))
+
+        # definition of default_output_dir_mode ensure backward compatibility
+        default_output_dir_mode = (
+            None if location is None else ProcessDataOutputDirMode.OTHER
+        )
+        output_dir_mode = config.get("output_dir_mode", default_output_dir_mode)
+        if output_dir_mode is not None:
+            self.setOutputdirMode(output_dir_mode)

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

@@ -107,9 +107,9 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
 
         # connect signal / slot
         self._methodCB.currentIndexChanged.connect(self._methodChanged)
-        self._paganinOpts.sigConfChanged.connect(self._signalConfChanged)
-        self._unsharpOpts.sigConfChanged.connect(self._signalConfChanged)
-        self._ctfOpts.sigConfChanged.connect(self._signalConfChanged)
+        self._paganinOpts.sigConfChanged.connect(self.sigConfChanged)
+        self._unsharpOpts.sigConfChanged.connect(self.sigConfChanged)
+        self._ctfOpts.sigConfChanged.connect(self.sigConfChanged)
 
         # set up
         self._paganinOpts.setEnabled(self.getMethod() is not _NabuPhaseMethod.NONE)
@@ -118,7 +118,7 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
     def _methodChanged(self, *args, **kwargs):
         self._paganinOpts.setEnabled(self.getMethod() is not _NabuPhaseMethod.NONE)
         self._ctfOpts.setEnabled(self.getMethod() is _NabuPhaseMethod.CTF)
-        self._signalConfChanged("method")
+        self.sigConfChanged.emit("method")
 
     def _signalConfChanged(self, param):
         self.sigConfChanged.emit(param)
@@ -224,13 +224,13 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
         self._paddingTypeCB.currentIndexChanged.connect(self._paganinPaddingTypeChanged)
 
     def _paganinDBChanged(self, *args, **kwargs):
-        self._signalConfChanged("delta_beta")
+        self.sigConfChanged.emit("delta_beta")
 
     def _paganinMargeChanged(self, *args, **kwargs):
-        self._signalConfChanged("marge")
+        self.sigConfChanged.emit("marge")
 
     def _paganinPaddingTypeChanged(self, *args, **kwargs):
-        self._signalConfChanged("padding_type")
+        self.sigConfChanged.emit("padding_type")
 
     def getPaddingType(self) -> PaddingMode:
         current_text = self._paddingTypeCB.currentText()
@@ -263,9 +263,6 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
         if padding_type is not None:
             self.setPaddingType(padding_type)
 
-    def _signalConfChanged(self, param):
-        self.sigConfChanged.emit(param)
-
 
 class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
     """Configuration widget dedicated to the unsharp options for nabu"""
@@ -331,10 +328,10 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
         self._unsharpSigmaQLE.editingFinished.connect(self._unsharpSigmaChanged)
 
     def _unsharpCoeffChanged(self, *args, **kwargs):
-        self._signalConfChanged("unsharp_coeff")
+        self.sigConfChanged.emit("unsharp_coeff")
 
     def _unsharpSigmaChanged(self, *args, **kwargs):
-        self._signalConfChanged("unsharp_sigma")
+        self.sigConfChanged.emit("unsharp_sigma")
 
     def isUnsharpCoeffActive(self):
         return self._unsharpCoeffCB.isChecked()

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

@@ -29,13 +29,13 @@ __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
@@ -78,6 +78,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,10 +95,10 @@ 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)
@@ -232,8 +235,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 +269,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 +348,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 +422,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 +441,212 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
 
 
 class SinoRingsOptions(qt.QWidget):
+    _VO_DIMS = ("horizontaly", "horizontaly and vertically")
+
     def __init__(self, parent=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 = qt.QDoubleSpinBox(self)
+        self._sigmaMunch.setRange(0.0, 2147483647)
+        self.layout().addRow(self._sigmaMunchLabel, self._sigmaMunch)
+
+        self._levelsMunchLabel = qt.QLabel("levels", self)
+        self._levelsMunch = qt.QSpinBox(self)
+        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 = qt.QDoubleSpinBox(self)
+        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 = qt.QSpinBox(self)
+        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 = qt.QSpinBox(self)
+        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 = qt.QComboBox(self)
+        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 = qt.QDoubleSpinBox(self)
+        self._sigmaLow.setMinimum(0.0)
+        self._sigmaHighLabel = qt.QLabel("signal high", self)
+        self.layout().addRow(self._sigmaLowLabel, self._sigmaLow)
+
+        self._sigmaHigh = qt.QDoubleSpinBox(self)
+        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

@@ -85,16 +85,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)