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

tomwer/gui/reconstruction/nabu/check.py

@@ -29,13 +29,13 @@ __date__ = "02/12/2021"
 
 
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.utils.nxtomoutils import get_n_series
 
 
-def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True) -> bool:
+def check_dark_series(scan: NXtomoScan, logger=None, user_input: bool = True) -> bool:
     """
     check:
         - if scan has computed_dark attached. If there is more than one then ask confirmation to the user to process the dataset
@@ -43,15 +43,15 @@ def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True)
 
     ask confirmation for processing is done by a pop up dialog.
 
-    :param HDF5TomoScan scan: scan to check
+    :param NXtomoScan scan: scan to check
     :param bool user_input: if True and if n series of flat is invalid then ask the user to confirm the processing. Else print a warning and refuse processing
 
     :return: True if processing can be done else False
     :note: user can 'force' the processing to be done
     """
-    if not isinstance(scan, HDF5TomoScan):
+    if not isinstance(scan, NXtomoScan):
         raise TypeError(
-            f"scan is expected to be an instance of {HDF5TomoScan} not a {type(scan)}"
+            f"scan is expected to be an instance of {NXtomoScan} not a {type(scan)}"
         )
     try:
         image_keys = scan.image_keys
@@ -82,13 +82,13 @@ def check_dark_series(scan: HDF5TomoScan, logger=None, user_input: bool = True)
         return True
 
 
-def check_flat_series(scan: HDF5TomoScan, logger, user_input: bool = True) -> bool:
+def check_flat_series(scan: NXtomoScan, logger, user_input: bool = True) -> bool:
     """
     Insure the scan contains at least one serie of flat. Otherwise warn the user nabu will not be able to process
     """
-    if not isinstance(scan, HDF5TomoScan):
+    if not isinstance(scan, NXtomoScan):
         raise TypeError(
-            f"scan is expected to be an instance of {HDF5TomoScan} not a {type(scan)}"
+            f"scan is expected to be an instance of {NXtomoScan} not a {type(scan)}"
         )
     try:
         image_keys = scan.image_keys

tomwer/gui/reconstruction/nabu/helical.py

@@ -22,17 +22,28 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
         )
         self.layout().addWidget(self._outputFilePathQLE, 0, 2, 1, 1)
 
-        # transition_width
-        self._transitionWidthQDSP = qt.QLabel("transition width", self)
-        self.layout().addWidget(self._transitionWidthQDSP, 1, 0, 1, 1)
-        self._transitionWidthQDSP = qt.QDoubleSpinBox(self)
-        self._transitionWidthQDSP.setRange(0.0, 99999999)
-        self._transitionWidthQDSP.setValue(50.0)
-        self._transitionWidthQDSP.setToolTip(
+        # transition_width_vertical
+        self._verticalTransitionWidthQDSP = qt.QLabel("transition width", self)
+        self.layout().addWidget(self._verticalTransitionWidthQDSP, 1, 0, 1, 1)
+        self._verticalTransitionWidthQDSP = qt.QDoubleSpinBox(self)
+        self._verticalTransitionWidthQDSP.setRange(0.0, 99999999)
+        self._verticalTransitionWidthQDSP.setValue(50.0)
+        self._verticalTransitionWidthQDSP.setToolTip(
             "the transition width is used to determine how the weights are apodised near the upper and lower border"
         )
         # TODO: improve tooltip of this
-        self.layout().addWidget(self._transitionWidthQDSP, 1, 1, 1, 2)
+        self.layout().addWidget(self._verticalTransitionWidthQDSP, 1, 1, 1, 2)
+
+        # transition_width_vertical
+        self._horizontalTransitionWidthQDSP = qt.QLabel("transition width", self)
+        self.layout().addWidget(self._horizontalTransitionWidthQDSP, 1, 0, 1, 1)
+        self._horizontalTransitionWidthQDSP = qt.QDoubleSpinBox(self)
+        self._horizontalTransitionWidthQDSP.setRange(0.0, 99999999)
+        self._horizontalTransitionWidthQDSP.setValue(50.0)
+        self._horizontalTransitionWidthQDSP.setToolTip(
+            "the transition width is used to determine how the weights are apodised near the upper and lower border"
+        )
+        self.layout().addWidget(self._horizontalTransitionWidthQDSP, 1, 1, 1, 2)
 
         spacer = qt.QWidget(parent=self)
         spacer.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
@@ -40,7 +51,8 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
 
         # connect signal / slot
         self._outputFilePathQLE.editingFinished.connect(self._changed)
-        self._transitionWidthQDSP.valueChanged.connect(self._changed)
+        self._verticalTransitionWidthQDSP.valueChanged.connect(self._changed)
+        self._horizontalTransitionWidthQDSP.valueChanged.connect(self._changed)
 
     def _changed(self, *args, **kwargs):
         self.sigConfigChanged.emit()
@@ -48,7 +60,8 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
     def getConfiguration(self) -> dict:
         return {
             "processes_file": self._outputFilePathQLE.text(),
-            "transition_width": self._transitionWidthQDSP.value(),
+            "transition_width_vertical": self._verticalTransitionWidthQDSP.value(),
+            "transition_width_horizontal": self._horizontalTransitionWidthQDSP.value(),
         }
 
     def setConfiguration(self, config: dict):
@@ -56,6 +69,10 @@ class HelicalPrepareWeightsDouble(qt.QWidget):
         if processes_file is not None:
             self._outputFilePathQLE.setText(processes_file)
 
-        transition_width = config.get("transition_width", None)
+        transition_width = config.get("transition_width_vertical", None)
+        if transition_width is not None:
+            self._verticalTransitionWidthQDSP.setValue(float(transition_width))
+
+        transition_width = config.get("transition_width_horizontal", None)
         if transition_width is not None:
-            self._transitionWidthQDSP.setValue(float(transition_width))
+            self._horizontalTransitionWidthQDSP.setValue(float(transition_width))

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

@@ -30,10 +30,8 @@ __date__ = "11/02/2020"
 
 from typing import Union
 
-from tomwer.core.process.reconstruction.nabu.utils import (
-    ConfigurationLevel,
-    _NabuStages,
-)
+from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
+from tomwer.gui.configuration.level import ConfigurationLevel
 
 
 class _FilteringObject:

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

@@ -156,7 +156,8 @@ class NabuConfiguration(qt.QWidget):
             self._preProcessingWidget.setConfiguration(config["preproc"])
         if "phase" in config:
             self._phaseWidget.setConfiguration(config["phase"])
-            if config["phase"]["method"] == "":
+            paganin = config["phase"].get("method", "")
+            if paganin == "":
                 self._phaseGB.setChecked(False)
             else:
                 self._phaseGB.setChecked(True)

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
@@ -51,10 +52,25 @@ _logger = logging.getLogger(__name__)
 
 
 class QNabuFileFormatComboBox(qt.QComboBox):
-    def __init__(self, parent: typing.Optional[qt.QWidget] = ...) -> None:
+    def __init__(
+        self, parent: typing.Optional[qt.QWidget] = ..., filter_formats=tuple()
+    ) -> None:
+        """
+        :param filter_format: if provided the given file format won't have an item on the ComboBox
+        """
         super().__init__(parent=parent)
+        if not isinstance(filter_formats, tuple):
+            raise TypeError(
+                f"filter_format should be a tuple. Get {type(filter_formats)} instead"
+            )
+        filter_formats = [
+            NabuOutputFileFormat.from_value(file_format)
+            for file_format in filter_formats
+        ]
 
         for ff in NabuOutputFileFormat:
+            if ff in filter_formats:
+                continue
             if ff is NabuOutputFileFormat.JP2K:
                 if not has_glymur:
                     _logger.warning(
@@ -79,51 +95,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.layout().addWidget(self._defaultOutput)
+        self._inScanFolderRB.setToolTip(
+            "Reconstruction will be saved under the PROCESSED_DATA/dataset folder. if exists else under the scan folder."
+        )
+        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)
@@ -134,7 +209,6 @@ class NabuOutputLocationWidget(qt.QWidget):
             return
 
         self._outputDirQLE.setText(dialog.selectedFiles()[0])
-        self._outputDirChanged()
 
     def getOutputDir(self):
         """
@@ -142,16 +216,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)
 
 
@@ -171,7 +244,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")
 
@@ -208,7 +281,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)
 
@@ -227,6 +300,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())
 
@@ -245,13 +324,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

@@ -53,10 +53,6 @@ class PaddingMode(_Enum):
     REFLECT = "reflect"
 
 
-# assert set(PaddingMode.values()) == set(PaganinPhaseRetrieval.available_padding_modes)
-#
-
-
 class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
     """
     Widget to define the configuration of the nabu preprocessing
@@ -111,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)
@@ -122,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)
@@ -163,6 +159,24 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
     def setDeltaBetaValue(self, value):
         self._paganinOpts.setDeltaBetaValue(value)
 
+    def getUnsharpCoeff(self) -> float:
+        return self._unsharpOpts.getUnsharpCoeff()
+
+    def setUnsharpCoeff(self, coeff: float):
+        self._unsharpOpts.setUnsharpCoeff(coeff)
+
+    def getUnsharpSigma(self) -> float:
+        return self._unsharpOpts.getUnsharpSigma()
+
+    def setUnsharpSigma(self, sigma: float):
+        self._unsharpOpts.setUnsharpSigma(sigma)
+
+    def getPaddingType(self):
+        return self._paganinOpts.getPaddingType()
+
+    def setPaddingType(self, padding_type):
+        return self._paganinOpts.setPaddingType(padding_type)
+
 
 class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
     """Configuration widget dedicated to the paganin options for nabu"""
@@ -202,33 +216,30 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
         self.registerWidget(self._paddingTypeCB, "advanced")
 
         # set up
-        # note: hide for now margin as it is not connected at nabu side
-        # self._margeQSB.setValue(50)
         item_index = self._paddingTypeCB.findText(PaddingMode.EDGE.value)
         self._paddingTypeCB.setCurrentIndex(item_index)
 
         # connect signal - slot
         self._deltaBetaQLE.editingFinished.connect(self._paganinDBChanged)
-        # note: hide for now margin as it is not connected at nabu side
-        # self._margeQSB.editingFinished.connect(self._paganinMargeChanged)
         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()
         return PaddingMode.from_value(current_text)
 
-    # note: hide for now margin as it is not connected at nabu side
-    # def getMarge(self) -> int:
-    #     return int(self._margeQSB.text())
+    def setPaddingType(self, padding_type):
+        padding_type = PaddingMode.from_value(padding_type)
+        item_index = self._paddingTypeCB.findText(padding_type.value)
+        self._paddingTypeCB.setCurrentIndex(item_index)
 
     def getDeltaBeta(self) -> str:
         return self._deltaBetaQLE.text()
@@ -239,22 +250,18 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
     def getConfiguration(self):
         return {
             "delta_beta": self.getDeltaBeta(),  # this one is not cast because can contain several values
-            # "margin": self.getMarge(),
             "padding_type": self.getPaddingType().value,
         }
 
     def setConfiguration(self, conf):
-        if "delta_beta" in conf:
-            self._deltaBetaQLE.setText(str(conf["delta_beta"]))
-        # if "margin" in conf:
-        #     self._margeQSB.setValue(int(conf["margin"]))
-        if "padding_type" in conf:
-            padding_type = PaddingMode.from_value(conf["padding_type"])
-            item_index = self._paddingTypeCB.findText(padding_type.value)
-            self._paddingTypeCB.setCurrentIndex(item_index)
-
-    def _signalConfChanged(self, param):
-        self.sigConfChanged.emit(param)
+        # delta_beta
+        delta_beta = conf.get("delta_beta", None)
+        if delta_beta is not None:
+            self._deltaBetaQLE.setText(str(delta_beta))
+        # padding_type
+        padding_type = conf.get("padding_type", None)
+        if padding_type is not None:
+            self.setPaddingType(padding_type)
 
 
 class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
@@ -321,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()