tomwer 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

tomwer/gui/reconstruction/nabu/castvolume.py

@@ -37,13 +37,14 @@ from tomwer.core.process.reconstruction.nabu.castvolume import (
 from tomwer.core.process.reconstruction.nabu.nabucommon import NabuOutputFileFormat
 from tomwer.gui.qlefilesystem import QLFileSystem
 from tomwer.gui.reconstruction.nabu.nabuconfig.output import QNabuFileFormatComboBox
+from silx.gui.utils import blockSignals
 import logging
+from typing import Optional
 
 _logger = logging.getLogger(__name__)
 
 
 class CastVolumeWidget(qt.QWidget):
-
     sigConfigChanged = qt.Signal()
     """Signal emit when the configuration changed"""
 
@@ -59,28 +60,53 @@ class CastVolumeWidget(qt.QWidget):
         self._outputDataTypeCB = qt.QComboBox(self)
         for data_type in ("uint8", "uint16", "float32", "float64"):
             self._outputDataTypeCB.addItem(data_type)
-        self.layout().addWidget(self._outputDataTypeCB, 0, 2, 1, 2)
+        self.layout().addWidget(self._outputDataTypeCB, 0, 1, 1, 3)
         # output file format
         self._outputFileformatLabel = qt.QLabel("output file format", self)
         self.layout().addWidget(self._outputFileformatLabel, 1, 0, 1, 1)
         self._outputFileformatCB = QNabuFileFormatComboBox(self)
-        self.layout().addWidget(self._outputFileformatCB, 1, 2, 1, 1)
-        # rescale percentiles
+        self.layout().addWidget(self._outputFileformatCB, 1, 1, 1, 3)
+
+        # let the user provide min and max manually
+        self._minMaxLabel = qt.QLabel("min max values")
+        self.layout().addWidget(self._minMaxLabel, 2, 0, 1, 1)
+        self._minMaxAuto = qt.QCheckBox("auto with rescale from percentiles")
+        self._minMaxAuto.setChecked(True)
+        self._minMaxAuto.setToolTip(
+            "If set to auto will try to get min/max pixel values from nabu histogram else will compute it. Otherwise will values provided by the user"
+        )
+        self.layout().addWidget(self._minMaxAuto, 2, 1, 1, 1)
+
+        self._minPixValue = qt.QLineEdit("", self)
+        self._minPixValue.setPlaceholderText("min")
+        self._maxPixValue = qt.QLineEdit("", self)
+        self._maxPixValue.setPlaceholderText("max")
+        validator = qt.QDoubleValidator(self)
+        validator.setNotation(qt.QDoubleValidator.ScientificNotation)
+        self._minPixValue.setValidator(validator)
+        self._maxPixValue.setValidator(validator)
+        self.layout().addWidget(self._minPixValue, 4, 2, 1, 1)
+        self.layout().addWidget(self._maxPixValue, 4, 3, 1, 1)
+        self._minPixValue.setVisible(False)
+        self._maxPixValue.setVisible(False)
+        # or from percentiles
         self._percentilesLabel = qt.QLabel("rescale percentiles")
-        self.layout().addWidget(self._percentilesLabel, 2, 0, 1, 1)
+        self.layout().addWidget(self._percentilesLabel, 3, 1, 1, 1)
         self._lowPercentileQSB = qt.QSpinBox(self)
         self._lowPercentileQSB.setRange(0, 100)
         self._lowPercentileQSB.setPrefix("min:")
+        self._lowPercentileQSB.setSuffix("%")
         self._lowPercentileQSB.setValue(RESCALE_MIN_PERCENTILE)
-        self.layout().addWidget(self._lowPercentileQSB, 2, 1, 1, 1)
+        self.layout().addWidget(self._lowPercentileQSB, 3, 2, 1, 1)
         self._highPercentileQSB = qt.QSpinBox(self)
         self._highPercentileQSB.setRange(0, 100)
         self._highPercentileQSB.setPrefix("max:")
+        self._highPercentileQSB.setSuffix("%")
         self._highPercentileQSB.setValue(RESCALE_MAX_PERCENTILE)
-        self.layout().addWidget(self._highPercentileQSB, 2, 2, 1, 1)
+        self.layout().addWidget(self._highPercentileQSB, 3, 3, 1, 1)
         # save dir
         self._saveDirLabel = qt.QLabel("output directory", self)
-        self.layout().addWidget(self._saveDirLabel, 3, 0, 1, 1)
+        self.layout().addWidget(self._saveDirLabel, 5, 0, 1, 1)
         self._useDefaultSaveDirQCB = qt.QCheckBox("default", self)
         self._useDefaultSaveDirQCB.setToolTip(
             f"Default directory is: {DEFAULT_OUTPUT_DIR}"
@@ -89,7 +115,7 @@ class CastVolumeWidget(qt.QWidget):
             qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
         )
         self._useDefaultSaveDirQCB.setChecked(True)
-        self.layout().addWidget(self._useDefaultSaveDirQCB, 3, 1, 1, 1)
+        self.layout().addWidget(self._useDefaultSaveDirQCB, 5, 1, 1, 1)
         self._saveDirQLE = QLFileSystem(text=DEFAULT_OUTPUT_DIR, parent=self)
         # force text because this is not a valid path
         self._saveDirQLE.setText(DEFAULT_OUTPUT_DIR)
@@ -100,11 +126,11 @@ class CastVolumeWidget(qt.QWidget):
             """
         )
         self._saveDirQLE.setVisible(False)
-        self.layout().addWidget(self._saveDirQLE, 3, 2, 1, 1)
+        self.layout().addWidget(self._saveDirQLE, 5, 2, 1, 2)
         # overwrite
         self._overwriteCB = qt.QCheckBox("overwrite", self)
         self._overwriteCB.setChecked(True)
-        self.layout().addWidget(self._overwriteCB, 4, 0, 1, 1)
+        self.layout().addWidget(self._overwriteCB, 6, 0, 1, 1)
         # spacer
         self._spacer = qt.QWidget(self)
         self._spacer.setSizePolicy(
@@ -119,6 +145,8 @@ class CastVolumeWidget(qt.QWidget):
         self._useDefaultSaveDirQCB.toggled.connect(self._configChanged)
         self._overwriteCB.toggled.connect(self._configChanged)
         self._useDefaultSaveDirQCB.toggled.connect(self._updateOutputDirVis)
+        self._minMaxAuto.toggled.connect(self._configChanged)
+        self._minMaxAuto.toggled.connect(self._updatePixMinMaxVis)
 
     def getOutputDataType(self) -> str:
         return self._outputDataTypeCB.currentText()
@@ -155,21 +183,59 @@ class CastVolumeWidget(qt.QWidget):
     def setOverwrite(self, remove) -> None:
         self._overwriteCB.setChecked(remove)
 
+    def getDataMin(self) -> Optional[float]:
+        if (
+            self._minMaxAuto.isChecked()
+            or self._minPixValue.text().replace(" ", "") == ""
+        ):
+            return None
+        else:
+            return float(self._minPixValue.text())
+
+    def setDataMin(self, value: Optional[float]) -> None:
+        with blockSignals(self._minMaxAuto):
+            self._minMaxAuto.setChecked(value is None)
+        if value is not None:
+            with blockSignals(self._minPixValue):
+                self._minPixValue.setText(str(value))
+
+    def getDataMax(self) -> Optional[float]:
+        if (
+            self._minMaxAuto.isChecked()
+            or self._maxPixValue.text().replace(" ", "") == ""
+        ):
+            return None
+        else:
+            return float(self._maxPixValue.text())
+
+    def setDataMax(self, value: Optional[float]) -> None:
+        with blockSignals(self._minMaxAuto):
+            self._minMaxAuto.setChecked(value is None)
+        if value is not None:
+            with blockSignals(self._maxPixValue):
+                self._maxPixValue.setText(str(value))
+
     def getConfiguration(self) -> dict:
+        rescale_min_percentile, rescale_max_percentile = self.getRescalePercentiles()
         return {
             "output_data_type": self.getOutputDataType(),
             "output_type": self.getOutputFileFormat().value,
             "output_dir": self.getOutputDir(),
             "overwrite": self.getOverwrite(),
-            "rescale_percentiles": self.getRescalePercentiles(),
+            "rescale_min_percentile": rescale_min_percentile,
+            "rescale_max_percentile": rescale_max_percentile,
+            "data_min": self.getDataMin(),
+            "data_max": self.getDataMax(),
         }
 
     def getRescalePercentiles(self) -> tuple:
         return self._lowPercentileQSB.value(), self._highPercentileQSB.value()
 
     def setRescalePercentiles(self, low, high) -> tuple:
-        self._lowPercentileQSB.setValue(low)
-        self._highPercentileQSB.setValue(high)
+        if low is not None:
+            self._lowPercentileQSB.setValue(low)
+        if high is not None:
+            self._highPercentileQSB.setValue(high)
 
     def setConfiguration(self, config: dict) -> None:
         output_data_type = config.get("output_data_type", None)
@@ -184,19 +250,32 @@ class CastVolumeWidget(qt.QWidget):
         overwrite = config.get("overwrite", None)
         if overwrite is not None:
             self.setOverwrite(overwrite)
-        rescale_percentiles = config.get("rescale_percentiles", None)
-        if rescale_percentiles is not None:
-            if not len(rescale_percentiles) == 2:
-                _logger.error(
-                    f"percentiles is expected to contain two values not {len(rescale_percentiles)}"
-                )
-            else:
-                self.setRescalePercentiles(
-                    rescale_percentiles[0], rescale_percentiles[1]
-                )
+        if "rescale_percentiles" in config:
+            rescale_min_percentile, rescale_max_percentile = config[
+                "rescale_percentiles"
+            ]
+            _logger.warning(
+                "'rescale_percentiles' is deprecated. Please use 'rescale_min_percentile' and 'rescale_max_percentile' instead"
+            )
+        else:
+            rescale_min_percentile = config.get("rescale_min_percentile", None)
+            rescale_max_percentile = config.get("rescale_max_percentile", None)
+
+        self.setRescalePercentiles(rescale_min_percentile, rescale_max_percentile)
+        if "data_min" in config:
+            self.setDataMin(config["data_min"])
+        if "data_max" in config:
+            self.setDataMax(config["data_max"])
 
     def _configChanged(self, *args, **kwargs):
         self.sigConfigChanged.emit()
 
     def _updateOutputDirVis(self, *args, **kwargs):
         self._saveDirQLE.setVisible(not self._useDefaultSaveDirQCB.isChecked())
+
+    def _updatePixMinMaxVis(self, *args, **kwargs):
+        self._minPixValue.setVisible(not self._minMaxAuto.isChecked())
+        self._maxPixValue.setVisible(not self._minMaxAuto.isChecked())
+        self._percentilesLabel.setVisible(self._minMaxAuto.isChecked())
+        self._lowPercentileQSB.setVisible(self._minMaxAuto.isChecked())
+        self._highPercentileQSB.setVisible(self._minMaxAuto.isChecked())

tomwer/gui/reconstruction/nabu/check.py

@@ -30,7 +30,7 @@ __date__ = "02/12/2021"
 
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.utils.nxtomoutils import get_n_series
-from tomoscan.esrf.hdf5scan import ImageKey
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 from silx.gui import qt
 
 

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

@@ -0,0 +1,352 @@
+from silx.gui import qt
+from typing import Optional, Union
+from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
+from tomwer.gui.reconstruction.nabu.nabuconfig import base
+from tomwer.gui.utils.illustrations import _IllustrationWidget
+from silx.gui.utils import blockSignals
+from silx.utils.enum import Enum as _Enum
+from .reconstruction import AnglesFileWidget as Filewidget
+
+
+def nabu_param_ligne_to_dict(str_ligne: str) -> dict:
+    ddict = {}
+    if "=" in str_ligne:
+        for elmt in str_ligne.split(";"):
+            kwv = elmt.lstrip(" ").rstrip(" ")
+            key, value = kwv.split("=")
+            ddict[key] = value
+    return ddict
+
+
+class _DoubleScientific(qt.QLineEdit):
+    """
+    A simple QLineEdit with a Doublevalidator with Scientific Notation
+    """
+
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        validator = qt.QDoubleValidator(parent=self)
+        validator.setNotation(qt.QDoubleValidator.ScientificNotation)
+        self.setValidator(validator)
+
+    def value(self) -> float:
+        if self.text() == "":
+            return 0.0
+        else:
+            return float(self.text())
+
+    def setValue(self, value):
+        self.setText(str(value))
+
+
+class OptionalDouble(qt.QWidget):
+    """
+    A spin box with a Check box to handle 'None' case of the nabu CTF options
+    """
+
+    sigChanged = qt.Signal()
+    """emit when the combobox of the double spin box value changed"""
+
+    def __init__(self, parent) -> None:
+        super().__init__(parent)
+        self.setLayout(qt.QHBoxLayout())
+        self._cb = qt.QCheckBox("", self)
+        self.layout().addWidget(self._cb)
+        self._dsb = _DoubleScientific(self)
+        self.layout().addWidget(self._dsb)
+
+        # connect signal ? slot
+        self._cb.toggled.connect(self._updateVisibility)
+        self._cb.toggled.connect(self._changed)
+        self._dsb.textChanged.connect(self._changed)
+
+        # set up
+        self._updateVisibility()
+
+    def _changed(self, *args, **kwargs):
+        self.sigChanged.emit()
+
+    def value(self) -> Optional[float]:
+        if self._cb.isChecked():
+            return self._dsb.value()
+        else:
+            return None
+
+    def setValue(self, value: Optional[float]):
+        if value in (None, "None"):
+            self._cb.setChecked(False)
+        else:
+            self._cb.setChecked(True)
+            self._dsb.setValue(float(value))
+
+    def setText(self, text: str):
+        self._cb.setText(text)
+
+    def _updateVisibility(self, *args, **kwargs):
+        self._dsb.setVisible(self._cb.isChecked())
+
+
+class _BeamShape(_Enum):
+    PARALLEL = "parallel"
+    CONE = "cone"
+
+
+class ConeBeamOpts(qt.QGroupBox):
+    """Specific settings for cone beam geometry"""
+
+    sigConfChanged = qt.Signal()
+    """emit when ctf parameters changed"""
+
+    def __init__(self, parent=None, title="cone settings"):
+        super().__init__(parent, title=title)
+        self.setLayout(qt.QGridLayout())
+        # z1_v
+        self._z1_v = _DoubleScientific(self)
+        self._z1_v.setPlaceholderText("z1_v in meter")
+        self.layout().addWidget(qt.QLabel("z1_v", self), 0, 0, 1, 1)
+        self.layout().addWidget(self._z1_v, 0, 1, 1, 1)
+        # z1_h
+        self._z1_h = _DoubleScientific(self)
+        self._z1_h.setPlaceholderText("z1_h in meter")
+        self.layout().addWidget(qt.QLabel("z1_h", self), 1, 0, 1, 1)
+        self.layout().addWidget(self._z1_h, 1, 1, 1, 1)
+
+        # illustration to define z1, z2
+        self._ctfIllustration = _IllustrationWidget(parent=self, img="ctf_z1")
+        self._ctfIllustration.setMinimumSize(qt.QSize(200, 90))
+        self._ctfIllustration.setSizePolicy(
+            qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding
+        )
+
+        self._ctfIllustration.setContentsMargins(0, 0, 0, 0)
+        self._ctfIllustration.layout().setSpacing(0)
+        self.layout().addWidget(self._ctfIllustration, 0, 2, 2, 2)
+
+        # connect signal / slot
+        self._z1_v.textChanged.connect(self._confChanged)
+        self._z1_h.textChanged.connect(self._confChanged)
+
+    def _confChanged(self, *args, **kwargs):
+        self.sigConfChanged.emit()
+
+    def getGeometry(self) -> dict:
+        return {
+            "z1_v": self._z1_v.value(),
+            "z1_h": self._z1_h.value(),
+        }
+
+    def setGeometry(self, config: dict) -> None:
+        with blockSignals(self):
+            if "z1_v" in config:
+                self._z1_v.setValue(float(config["z1_v"]))
+            if "z1_h" in config:
+                self._z1_h.setValue(float(config["z1_h"]))
+
+
+class CTFGeometry(qt.QGroupBox):
+    """
+    widget for the ctf_geometry parameter of nabu
+    """
+
+    sigConfChanged = qt.Signal()
+    """emit when ctf parameters changed"""
+
+    def __init__(self, parent=None, title="ctf-geometry") -> None:
+        super().__init__(parent, title=title)
+        self.setLayout(qt.QFormLayout())
+        self._beamShapeCB = qt.QComboBox(self)
+        for shape in _BeamShape.values():
+            self._beamShapeCB.addItem(shape)
+        self.layout().addRow("shape", self._beamShapeCB)
+
+        # cone beam settings
+        self._coneBeamSettings = ConeBeamOpts(self)
+        self.layout().addRow(self._coneBeamSettings)
+
+        # detector pixel size
+        self._detectorPixelSize = OptionalDouble(self)
+        self._detectorPixelSize.setText("overwrite")
+        self._detectorPixelSize._dsb.setPlaceholderText("pixel size in meter")
+        self.layout().addRow("detector pixel size", self._detectorPixelSize)
+        # magnification
+        self._magnification = qt.QCheckBox("magnification", self)
+        self.layout().addRow(self._magnification)
+
+        # set up
+        self._magnification.setChecked(True)
+        self._updateView()
+
+        # connect signal / slot
+        self._coneBeamSettings.sigConfChanged.connect(self._confChanged)
+        self._detectorPixelSize.sigChanged.connect(self._confChanged)
+        self._magnification.toggled.connect(self._confChanged)
+        self._beamShapeCB.currentIndexChanged.connect(self._updateView)
+        self._beamShapeCB.currentIndexChanged.connect(self._confChanged)
+
+    def getBeamShape(self):
+        return _BeamShape.from_value(self._beamShapeCB.currentText())
+
+    def setBeamShape(self, shape: Union[str, _BeamShape]):
+        shape = _BeamShape.from_value(shape)
+        self._beamShapeCB.setCurrentText(shape.value)
+
+    def _updateView(self, *args, **kwargs):
+        self._coneBeamSettings.setVisible(self.getBeamShape() == _BeamShape.CONE)
+
+    def _confChanged(self, *args, **kwargs):
+        self.sigConfChanged.emit()
+
+    def getConfiguration(self) -> dict:
+        magnification = "True" if self._magnification.isChecked() else "False"
+        beam_shape = self.getBeamShape()
+        if beam_shape is _BeamShape.PARALLEL:
+            z1_v = None
+            z1_h = None
+        elif beam_shape is _BeamShape.CONE:
+            cone_params = self._coneBeamSettings.getGeometry()
+            z1_v = cone_params["z1_v"]
+            z1_h = cone_params["z1_h"]
+        else:
+            raise NotImplementedError(f"Geometry {beam_shape.value} is not handled")
+
+        geometry = f" z1_v={z1_v}; z1_h={z1_h}; detec_pixel_size={self._detectorPixelSize.value()}; magnification={magnification}"
+
+        return {"ctf_geometry": geometry, "beam_shape": beam_shape.value}
+
+    def setConfiguration(self, ddict: dict) -> None:
+        params = nabu_param_ligne_to_dict(ddict.get("ctf_geometry", ""))
+        with blockSignals(self):
+            for key, value in params.items():
+                if key == "detec_pixel_size":
+                    self._detectorPixelSize.setValue(value)
+                elif key == "magnification":
+                    self._magnification.setChecked(value.lower() == "true")
+
+            beam_shape = ddict.get("beam_shape", None)
+            if beam_shape is not None:
+                if _BeamShape.from_value(beam_shape) is _BeamShape.CONE:
+                    self._coneBeamSettings.setGeometry(params)
+                self.setBeamShape(beam_shape)
+
+
+class CTFAdvancedParams(qt.QGroupBox):
+    """
+    widget for the ctf_advanced_params parameter of nabu
+    """
+
+    sigConfChanged = qt.Signal()
+    """emit when ctf parameters changed"""
+
+    def __init__(self, parent=None, title="ctf-advanced-params") -> None:
+        super().__init__(parent, title=title)
+        self.setLayout(qt.QFormLayout())
+        # length_scale
+        self._length_scale = _DoubleScientific(self)
+        self.layout().addRow("length_scale", self._length_scale)
+        # lim1
+        self._lim1 = _DoubleScientific(self)
+        self._lim1Label = qt.QLabel("lim1")
+        self.layout().addRow(self._lim1Label, self._lim1)
+        # lim2
+        self._lim2 = _DoubleScientific(self)
+        self._lim2Label = qt.QLabel("lim2")
+        self.layout().addRow(self._lim2Label, self._lim2)
+        for w in (self._lim1, self._lim1Label, self._lim2, self._lim2Label):
+            w.setToolTip(
+                "parameter of the low-pass filter. Used in equation: 'lim = lim1 * r + lim2 * (1 - r)' where r is some low-pass filter (image dimensionality)"
+            )
+
+        # normalize_by_mean
+        self._normalize_by_mean = qt.QCheckBox("normalize by mean", self)
+        self.layout().addRow(self._normalize_by_mean)
+
+        # set up
+        self._length_scale.setText("1e-5")
+        self._lim1.setText("1e-5")
+        self._lim2.setText("0.2")
+        self._normalize_by_mean.setChecked(True)
+
+        # connect sginal / slot
+        self._length_scale.textChanged.connect(self._confChanged)
+        self._lim1.textChanged.connect(self._confChanged)
+        self._lim2.textChanged.connect(self._confChanged)
+        self._normalize_by_mean.toggled.connect(self._confChanged)
+
+    def getLengthScale(self) -> str:
+        if self._length_scale.text() == "":
+            return "0.0"
+        else:
+            return self._length_scale.text()
+
+    def _confChanged(self, *args, **kwargs):
+        self.sigConfChanged.emit()
+
+    def getConfiguration(self) -> dict:
+        normalize_by_mean = "True" if self._normalize_by_mean.isChecked() else "False"
+        ctf_advanced_params = f" length_scale={self._length_scale.value()}; lim1={self._lim1.value()}; lim2={self._lim2.value()}; normalize_by_mean={normalize_by_mean}"
+        return {
+            "ctf_advanced_params": ctf_advanced_params,
+        }
+
+    def setConfiguration(self, ddict: dict) -> None:
+        params = nabu_param_ligne_to_dict(ddict.get("ctf_advanced_params", {}))
+        with blockSignals(self):
+            for key, value in params.items():
+                if key == "length_scale":
+                    self._length_scale.setText(value)
+                elif key == "lim1":
+                    self._lim1.setText(value)
+                elif key == "lim2":
+                    self._lim2.setText(value)
+                elif key == "normalize_by_mean":
+                    self._normalize_by_mean.setChecked(value.lower() == "true")
+
+
+class CTFConfig(qt.QGroupBox, base._NabuStageConfigBase):
+    """
+    Widget dedicated for the CTF parameters
+    """
+
+    sigConfChanged = qt.Signal(str)
+    """emit when ctf parameters changed"""
+
+    def __init__(self, parent=None, title="ctf parameters"):
+        qt.QGroupBox.__init__(self, parent, title=title, stage=_NabuStages.PHASE)
+        base._NabuStageConfigBase.__init__(self, stage=_NabuStages.PHASE)
+
+        self.setLayout(qt.QFormLayout())
+
+        # geometry
+        self._geometryWidget = CTFGeometry(parent=self, title="geometry")
+        self.layout().addRow(self._geometryWidget)
+        self.registerWidget(self._geometryWidget, "optional")
+        # translation file
+        self._translationFile = Filewidget(self)
+        self.layout().addRow("translation file", self._translationFile)
+        self.registerWidget(self._translationFile, "optional")
+        # advanced parameters
+        self._advancedParamsWidget = CTFAdvancedParams(
+            parent=self, title="advanced parameters"
+        )
+        self.layout().addRow(self._advancedParamsWidget)
+        self.registerWidget(self._advancedParamsWidget, "advanced")
+
+        # connect signal / slot
+        self._geometryWidget.sigConfChanged.connect(self._confChanged)
+        self._advancedParamsWidget.sigConfChanged.connect(self._confChanged)
+        self._translationFile._qle.textEdited.connect(self._confChanged)
+
+    def _confChanged(self, *args, **kwargs):
+        self.sigConfChanged.emit("phase")
+
+    def getConfiguration(self) -> dict:
+        ddict = self._geometryWidget.getConfiguration()
+        ddict.update(self._advancedParamsWidget.getConfiguration())
+        ddict["ctf_translations_file"] = self._translationFile.getFile()
+        return ddict
+
+    def setConfiguration(self, ddict):
+        self._geometryWidget.setConfiguration(ddict=ddict)
+        self._advancedParamsWidget.setConfiguration(ddict=ddict)
+        if "ctf_translations_file" in ddict:
+            self._translationFile.setFile(ddict["ctf_translations_file"])

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

@@ -293,12 +293,3 @@ class NabuConfigurationTab(qt.QTabWidget):
             self._reconstructionWidget.setConfiguration(config["reconstruction"])
         if "tomwer_slices" in config:
             self._reconstructionWidget.setSlices(config["tomwer_slices"])
-
-
-if __name__ == "__main__":
-    app = qt.QApplication([])
-    widget = NabuConfiguration(None, None)
-    widget.show()
-    print(widget.getConfiguration())
-    print(widget.getSlices())
-    app.exec_()

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

@@ -119,7 +119,7 @@ class NabuOutputLocationWidget(qt.QWidget):
         self._outputDirQLE.setVisible(not hide)
         self._selectOutputPB.setVisible(not hide)
 
-    def _selectOutput(self):
+    def _selectOutput(self):  # pragma: no cover
         defaultDirectory = self._outputDirQLE.text()
         if os.path.isdir(defaultDirectory):
             defaultDirectory = get_default_directory()