tomwer 1.5.0rc0__py3-none-any.whl → 1.5.1__py3-none-any.whl

tomwer/gui/configuration/level.py

@@ -1,4 +1,4 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class ConfigurationLevel(_Enum):

tomwer/gui/control/actions.py

@@ -86,7 +86,7 @@ class TomoObjDisplayModeToolButton(qt.QToolButton):
         urlDescAction.triggered.connect(partial(self.setDisplayMode, DisplayMode.URL))
 
     def setDisplayMode(self, mode: DisplayMode):
-        mode = DisplayMode.from_value(mode)
+        mode = DisplayMode(mode)
         if mode is DisplayMode.SHORT:
             self.setIcon(self._shortDescIcon)
             self.setToolTip(self._SHORT_DESC_TOOLTIP)

tomwer/gui/control/datalist.py

@@ -616,7 +616,7 @@ class _TomwerObjectList(qt.QTableWidget):
         self.setDisplayMode(DisplayMode.SHORT)
 
     def setDisplayMode(self, mode: DisplayMode) -> None:
-        self._displayMode = DisplayMode.from_value(mode)
+        self._displayMode = DisplayMode(mode)
         self._update()
 
     def n_data(self):

tomwer/gui/control/series/seriescreator.py

@@ -6,7 +6,7 @@ from typing import Iterable
 
 from silx.gui import qt
 from silx.gui.utils import blockSignals
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomoscan.series import Series
 
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -144,8 +144,8 @@ class SeriesDefinition(qt.QWidget):
         self.layout().addWidget(self._modeLabel, 0, 0, 1, 1)
 
         self._modeCB = qt.QComboBox(self)
-        for mode in _SeriesDefinitionMode.values():
-            self._modeCB.addItem(mode)
+        for mode in _SeriesDefinitionMode:
+            self._modeCB.addItem(mode.value)
         self.layout().addWidget(self._modeCB, 0, 1, 1, 1)
 
         self._manualDefWidget = SeriesManualFromTomoObj(parent=self)
@@ -169,10 +169,10 @@ class SeriesDefinition(qt.QWidget):
             raise ValueError(f"mode {self.getMode()} is not handled yet")
 
     def getMode(self) -> str:
-        return _SeriesDefinitionMode.from_value(self._modeCB.currentText())
+        return _SeriesDefinitionMode(self._modeCB.currentText())
 
     def setMode(self, mode: str):
-        mode = _SeriesDefinitionMode.from_value(mode)
+        mode = _SeriesDefinitionMode(mode)
         idx = self._modeCB.findText(mode.value)
         self._modeCB.setCurrentIndex(idx)
 

tomwer/gui/control/tomoobjdisplaymode.py

@@ -1,4 +1,4 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class DisplayMode(_Enum):

tomwer/gui/dataportal/gallery.py

@@ -29,7 +29,7 @@ class GalleryWidget(qt.QWidget):
         self.layout().addRow("precision", self._precisionQCB)
         # binning
         self._binningQCB = qt.QComboBox(self)
-        self._binningQCB.addItems(Binning.values())
+        self._binningQCB.addItems([item.value for item in Binning])
         self.layout().addRow("binning", self._binningQCB)
         self._binningQCB.setCurrentText(Binning.SIXTEEN_BY_SIXTEEN.value)
         self._binningQCB.setToolTip(
@@ -37,7 +37,7 @@ class GalleryWidget(qt.QWidget):
         )  # recommended size: 5ko for the entire gallery
         # output format
         self._outputFormat = qt.QComboBox(self)
-        self._outputFormat.addItems(OutputFormat.values())
+        self._outputFormat.addItems([item.value for item in OutputFormat])
         self.layout().addRow("output format", self._outputFormat)
         # overwrite
         self._overwriteCB = qt.QCheckBox("overwrite", self)
@@ -49,17 +49,17 @@ class GalleryWidget(qt.QWidget):
         self._binningQCB.currentIndexChanged.connect(self._configChanged)
 
     def getOutputFormat(self) -> OutputFormat:
-        return OutputFormat.from_value(self._outputFormat.currentText())
+        return OutputFormat(self._outputFormat.currentText())
 
     def setOutputFormat(self, format: OutputFormat):
-        format = OutputFormat.from_value(format)
+        format = OutputFormat(format)
         self._outputFormat.setCurrentText(format.value)
 
     def getBinning(self) -> Binning:
-        return Binning.from_value(self._binningQCB.currentText())
+        return Binning(self._binningQCB.currentText())
 
     def setBinning(self, binning: Binning):
-        binning = Binning.from_value(binning)
+        binning = Binning(binning)
         self._binningQCB.setCurrentText(binning.value)
 
     def overwrite(self) -> bool:

tomwer/gui/edit/tests/test_nx_editor.py

@@ -29,7 +29,7 @@ _ureg = pint.get_application_registry()
 @pytest.mark.parametrize("detector_y_pixel_size", (None,))
 @pytest.mark.parametrize("sample_x_pixel_size", (None,))
 @pytest.mark.parametrize("sample_y_pixel_size", (None, 0.0066 * _ureg.meter))
-@pytest.mark.parametrize("field_of_view", FOV.values())
+@pytest.mark.parametrize("field_of_view", [item.value for item in FOV])
 @pytest.mark.parametrize("sample_detector_distance", (1.2 * _ureg.meter,))
 @pytest.mark.parametrize("sample_source_distance", (-10.2 * _ureg.meter,))
 @pytest.mark.parametrize("propagation_distance", (1.01 * _ureg.meter,))

tomwer/gui/reconstruction/axis/EstimatedCorComboBox.py

@@ -13,8 +13,8 @@ class _EstimatedCorValidator(qt.QDoubleValidator):
 
     def validate(self, a0: str, a1: int):
         """validate float or string that could be part of the side values..."""
-        for value in Side.values():
-            if value.startswith(a0):
+        for side in Side:
+            if side.value.startswith(a0):
                 return (qt.QDoubleValidator.Acceptable, a0, a1)
         return super().validate(a0, a1)
 

tomwer/gui/reconstruction/axis/InputWidget.py

@@ -153,8 +153,8 @@ class InputWidget(qt.QWidget):
         modes = set(modes)
         for mode in modes:
             try:
-                axis_mode._InputType.from_value(mode)
-            except Exception:
+                axis_mode._InputType(mode)
+            except ValueError:
                 raise ValueError(
                     f"mode {mode} should be an instance of {axis_mode._InputType}"
                 )
@@ -166,7 +166,7 @@ class InputWidget(qt.QWidget):
         elif len(modes) < 0:
             raise ValueError("modes is empty")
         else:
-            mode = axis_mode._InputType.from_value(modes.pop())
+            mode = axis_mode._InputType(modes.pop())
             if mode is axis_mode._InputType.SINOGRAM:
                 self._sinogramGB.setEnabled(True)
                 self._radioGB.setEnabled(False)

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

@@ -49,9 +49,7 @@ class _NabuStageConfigBase:
         :returns: _FilteringObject to use to define widget visibility
         """
         filteringObj = _FilteringObject(widget=widget)
-        self._registeredWidgets[filteringObj] = ConfigurationLevel.from_value(
-            config_level
-        )
+        self._registeredWidgets[filteringObj] = ConfigurationLevel(config_level)
         return filteringObj
 
     def getConfiguration(self) -> dict:

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from silx.gui import qt
 from silx.gui.utils import blockSignals
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
 from tomwer.gui.reconstruction.nabu.nabuconfig import base
@@ -159,8 +159,8 @@ class CTFGeometry(qt.QGroupBox):
         super().__init__(parent, title=title)
         self.setLayout(qt.QFormLayout())
         self._beamShapeCB = QComboBoxIgnoreWheel(self)
-        for shape in _BeamShape.values():
-            self._beamShapeCB.addItem(shape)
+        for shape in _BeamShape:
+            self._beamShapeCB.addItem(shape.value)
         self.layout().addRow("shape", self._beamShapeCB)
 
         # cone beam settings
@@ -188,10 +188,10 @@ class CTFGeometry(qt.QGroupBox):
         self._beamShapeCB.currentIndexChanged.connect(self._confChanged)
 
     def getBeamShape(self):
-        return _BeamShape.from_value(self._beamShapeCB.currentText())
+        return _BeamShape(self._beamShapeCB.currentText())
 
     def setBeamShape(self, shape: str | _BeamShape):
-        shape = _BeamShape.from_value(shape)
+        shape = _BeamShape(shape)
         self._beamShapeCB.setCurrentText(shape.value)
 
     def _updateView(self, *args, **kwargs):
@@ -228,7 +228,7 @@ class CTFGeometry(qt.QGroupBox):
 
             beam_shape = ddict.get("beam_shape", None)
             if beam_shape is not None:
-                if _BeamShape.from_value(beam_shape) is _BeamShape.CONE:
+                if _BeamShape(beam_shape) is _BeamShape.CONE:
                     self._coneBeamSettings.setGeometry(params)
                 self.setBeamShape(beam_shape)
 

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

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.reconstruction.nabu.utils import _NabuPhaseMethod, _NabuStages
 from tomwer.core.utils.char import BETA_CHAR, DELTA_CHAR
@@ -212,10 +212,10 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
 
     def getPaddingType(self) -> PaddingMode:
         current_text = self._paddingTypeCB.currentText()
-        return PaddingMode.from_value(current_text)
+        return PaddingMode(current_text)
 
     def setPaddingType(self, padding_type):
-        padding_type = PaddingMode.from_value(padding_type)
+        padding_type = PaddingMode(padding_type)
         item_index = self._paddingTypeCB.findText(padding_type.value)
         self._paddingTypeCB.setCurrentIndex(item_index)
 

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

@@ -221,7 +221,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._signalConfChanged("flatfield")
 
     def _dffChanged(self, *args, **kwargs):
-        self._signalConfChanged("double_flatfield_enabled")
+        self._signalConfChanged("double_flatfield")
 
     def _dffSigmaChanged(self, *args, **kwargs):
         self._signalConfChanged("dff_sigma")
@@ -337,7 +337,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         tilt_correction, autotilt_opts = self._tiltCorrection.getTiltCorrection()
         return {
             "flatfield": int(self.isFlatFieldActivate()),
-            "double_flatfield_enabled": int(self.isDoubleFlatFieldActivate()),
+            "double_flatfield": int(self.isDoubleFlatFieldActivate()),
             "dff_sigma": self.getDFFSigma(),
             "ccd_filter_enabled": int(self.isCCDFilterActivate()),
             "ccd_filter_threshold": self.getCCDThreshold(),
@@ -365,7 +365,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         if ff is not None:
             self._flatFieldCB.setChecked(bool(ff))
 
-        dff = conf.get("double_flatfield_enabled", None)
+        dff = conf.get("double_flatfield", None)
         if dff is not None:
             self._dffCB.setChecked(bool(dff))
 

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

@@ -7,7 +7,7 @@ import logging
 
 from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from nxtomomill.io.utils import convert_str_to_tuple
 from tomwer.core.utils.char import DEGREE_CHAR
@@ -159,9 +159,13 @@ class TranslationMvtFileWidget(qt.QWidget):
         self._grpBox.layout().setContentsMargins(0, 0, 0, 0)
         self._grpBox.layout().setSpacing(0)
 
-        self._hdf5FileRB = qt.QRadioButton(self.Mode.HDF5.value, self)
+        self._hdf5FileRB = qt.QRadioButton(
+            TranslationMvtFileWidget.Mode.HDF5.value, self
+        )
         self._grpBox.layout().addWidget(self._hdf5FileRB)
-        self._textFileRB = qt.QRadioButton(self.Mode.TEXT.value, self)
+        self._textFileRB = qt.QRadioButton(
+            TranslationMvtFileWidget.Mode.TEXT.value, self
+        )
         self._grpBox.layout().addWidget(self._textFileRB)
         self.layout().addWidget(self._grpBox)
 

tomwer/gui/reconstruction/nabu/slices.py

@@ -10,7 +10,7 @@ from nabu.pipeline.fullfield.nabu_config import (
 )
 from silx.gui import icons as silx_icons
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from nxtomo.nxobject.nxdetector import FOV
 
 from tomwer.core.utils.dictutils import concatenate_dict
@@ -113,8 +113,8 @@ class _NabuProcess(qt.QWidget):
         qt.QWidget.__init__(self, parent=parent)
         self.setLayout(qt.QGridLayout())
         self._stageCB = qt.QComboBox(parent=self)
-        for stage in _NabuStages.values():
-            self._stageCB.addItem(stage)
+        for stage in _NabuStages:
+            self._stageCB.addItem(stage.value)
 
         self.layout().addWidget(qt.QLabel("stage:", self), 0, 0, 1, 1)
         self.layout().addWidget(self._stageCB, 0, 1, 1, 1)
@@ -323,7 +323,7 @@ class NabuWindow(qt.QMainWindow):
         self._mainWidget.nabuSettingsWidget._configuration._preProcessingWidget._sinoRingsOpts.resetConfiguration()
         default_config["tomwer_slices"] = "middle"
         default_config["preproc"]["ccd_filter_enabled"] = False
-        default_config["preproc"]["double_flatfield_enabled"] = False
+        default_config["preproc"]["double_flatfield"] = False
         default_config["preproc"]["flatfield"] = True
         default_config["preproc"]["take_logarithm"] = True
         self.setConfiguration(default_config)
@@ -377,7 +377,7 @@ class NabuWindow(qt.QMainWindow):
         return self._filterAction.isChecked()
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         if level == ConfigurationLevel.REQUIRED:
             self._minimalisticAction.setChecked(True)
         elif level == ConfigurationLevel.ADVANCED:
@@ -601,7 +601,7 @@ class NabuWidget(qt.QWidget):
         self._configurationScrollArea.updateGeometry()
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         self._configuration_level = level
         self.updateConfigurationFilter()
 

tomwer/gui/reconstruction/nabu/volume.py

@@ -330,7 +330,7 @@ class NabuVolumeWidget(_NabuStageConfigBase, qt.QWidget):
             self.setHistogramRequested(requested=bool(config["output_histogram"]))
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         _NabuStageConfigBase.setConfigurationLevel(self, level)
 
     def getConfigurationLevel(self):

tomwer/gui/reconstruction/normalization/intensity.py

@@ -502,12 +502,12 @@ class _NormIntensityOptions(qt.QWidget):
 
     def getCurrentSource(self):
         if self.getCurrentMethod() in (Method.DIVISION, Method.SUBTRACTION):
-            return _ValueSource.from_value(self._sourceCB.currentText())
+            return _ValueSource(self._sourceCB.currentText())
         else:
             return _ValueSource.NONE
 
     def setCurrentSource(self, source):
-        source = _ValueSource.from_value(source)
+        source = _ValueSource(source)
         idx = self._sourceCB.findText(source.value)
         self._sourceCB.setCurrentIndex(idx)
 
@@ -601,8 +601,8 @@ class _NormIntensityCalcOpts(qt.QWidget):
         self.setLayout(qt.QFormLayout())
         # calculation function
         self._calculationModeCB = qt.QComboBox(self)
-        for fct in _normParams._ValueCalculationFct.values():
-            self._calculationModeCB.addItem(fct)
+        for fct in _normParams._ValueCalculationFct:
+            self._calculationModeCB.addItem(fct.value)
         self._calculationModeLabel = qt.QLabel("calculation fct", self)
         self.layout().addRow(self._calculationModeLabel, self._calculationModeCB)
 
@@ -616,14 +616,10 @@ class _NormIntensityCalcOpts(qt.QWidget):
         self._calculationModeCB.setVisible(visible)
 
     def getCalculationFct(self):
-        return _normParams._ValueCalculationFct.from_value(
-            self._calculationModeCB.currentText()
-        )
+        return _normParams._ValueCalculationFct(self._calculationModeCB.currentText())
 
     def setCalculationFct(self, fct):
-        idx = self._calculationModeCB.findText(
-            _normParams._ValueCalculationFct.from_value(fct)
-        )
+        idx = self._calculationModeCB.findText(_normParams._ValueCalculationFct(fct))
         self._calculationModeCB.setCurrentIndex(idx)
 
 

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -13,7 +13,7 @@ from silx.gui import icons as silxicons
 from silx.gui import qt
 from silx.gui.dialog.ImageFileDialog import ImageFileDialog
 from silx.gui.plot import items
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomoscan.esrf.scan.utils import get_data
 
 from tomwer.core.process.reconstruction.utils.cor import (
@@ -308,7 +308,7 @@ class _ReconstructionModeGB(qt.QGroupBox):
             raise ValueError("No reconstruction mode selected")
 
     def setReconstructionMode(self, mode: ReconstructionMode | str) -> None:
-        mode = ReconstructionMode.from_value(mode)
+        mode = ReconstructionMode(mode)
         if mode is ReconstructionMode.TILT_CORRECTION:
             self._tiltCorrectionRB.setChecked(True)
         elif mode is ReconstructionMode.VERTICAL:

tomwer/gui/reconstruction/sacommon.py

@@ -87,7 +87,7 @@ class NabuWidgetWithToolbar(qt.QMainWindow):
         self._nabuSettings._configuration._preProcessingWidget._sinoRingsOpts.resetConfiguration()
         default_config["tomwer_slices"] = "middle"
         default_config["preproc"]["ccd_filter_enabled"] = False
-        default_config["preproc"]["double_flatfield_enabled"] = False
+        default_config["preproc"]["double_flatfield"] = False
         default_config["preproc"]["flatfield"] = True
         default_config["preproc"]["take_logarithm"] = True
         self._nabuSettings.setConfiguration(default_config)
@@ -107,7 +107,7 @@ class NabuWidgetWithToolbar(qt.QMainWindow):
             self._nabuSettings.setConfiguration(config)
 
     def setConfigurationLevel(self, level):
-        level = ConfigurationLevel.from_value(level)
+        level = ConfigurationLevel(level)
         if level == ConfigurationLevel.REQUIRED:
             self._minimalisticAction.setChecked(True)
         elif level == ConfigurationLevel.ADVANCED:

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -248,10 +248,10 @@ class VariableSelection(qt.QWidget):
         self._img_width = width
 
     def getScoreMethod(self):
-        return ScoreMethod.from_value(self._scoreMethodCB.currentText())
+        return ScoreMethod(self._scoreMethodCB.currentText())
 
     def setScoreMethod(self, method):
-        method_value = ScoreMethod.from_value(method).value
+        method_value = ScoreMethod(method).value
         index = self._scoreMethodCB.findText(method_value)
         self._scoreMethodCB.setCurrentIndex(index)
 
@@ -671,7 +671,7 @@ class ScorePlot(qt.QWidget):
         :param scores: cor value (float) as key and
                             tuple(url: DataUrl, score: float) as value
         """
-        score_method = ScoreMethod.from_value(score_method)
+        score_method = ScoreMethod(score_method)
         if not update_only_scores:
             self.clear()
             self._scores = scores

tomwer/gui/reconstruction/tests/test_nabu.py

@@ -90,7 +90,7 @@ class TestNabuPreProcConfig(TestCaseQt):
         """Test that the get configuration is working"""
         ini_conf = {
             "flatfield": 1,
-            "double_flatfield_enabled": 0,
+            "double_flatfield": 0,
             "dff_sigma": 0.0,
             "ccd_filter_enabled": 0,
             "ccd_filter_threshold": 0.04,
@@ -110,7 +110,7 @@ class TestNabuPreProcConfig(TestCaseQt):
         """Test that the set configuration is working"""
         conf = {
             "flatfield": 0,
-            "double_flatfield_enabled": 1,
+            "double_flatfield": 1,
             "dff_sigma": 2.0,
             "ccd_filter_enabled": 1,
             "ccd_filter_threshold": 0.98,

tomwer/gui/stitching/config/positionoveraxis.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import functools
 import numpy
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.gui import icons

tomwer/gui/utils/buttons.py

@@ -111,7 +111,7 @@ class TapeMeasureToolButton(PlotToolButton):
             self._lastRoiCreated.setVisible(self.isChecked())
         if self.isChecked():
             self._roiManager.start(
-                self.TapeMeasureROI,
+                TapeMeasureROI,
                 self,
             )
             self.__interactiveModeStarted(self._roiManager)

tomwer/gui/utils/flow.py

@@ -4,7 +4,7 @@ import functools
 from typing import Iterable
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.gui import icons
 from tomwer.utils import docstring

tomwer/gui/utils/loadingmode.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import functools
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from silx.gui import qt
 from tomwer.gui import icons
 

tomwer/gui/utils/vignettes.py

@@ -302,7 +302,7 @@ class VignettesWidget(qt.QWidget):
                     f"score is expected to be a dict with values as (v1: numpy.ndarray, v2: ComputedScore). v2 type Found: {type(score_cls)}"
                 )
             scores_values.append(score_cls.get(score_method))
-        self.__score_method = ScoreMethod.from_value(score_method)
+        self.__score_method = ScoreMethod(score_method)
         highest_score_indices = numpy.nanargmax(scores_values)
         self._vignettesGroup = qt.QButtonGroup(self)
         self._vignettesGroup.setExclusive(True)

tomwer/gui/visualization/dataviewer.py

@@ -1,7 +1,7 @@
 import weakref
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.volume.volumebase import TomwerVolumeBase
@@ -318,26 +318,26 @@ class DisplayControl(qt.QWidget):
 
         :return: selected mode: display slices or radios
         """
-        return _DisplayMode.from_value(self._displayMode.currentText())
+        return _DisplayMode(self._displayMode.currentText())
 
     def setDisplayMode(self, mode):
-        mode = _DisplayMode.from_value(mode)
+        mode = _DisplayMode(mode)
         idx = self._displayMode.findText(mode.value)
         self._displayMode.setCurrentIndex(idx)
 
     def getRadioOption(self) -> _RadioMode:
-        return _RadioMode.from_value(self._radioMode.currentText())
+        return _RadioMode(self._radioMode.currentText())
 
     def setRadioOption(self, opt):
-        opt = _RadioMode.from_value(opt)
+        opt = _RadioMode(opt)
         idx = self._radioMode.findText(opt.value)
         self._radioMode.setCurrentIndex(idx)
 
     def getSliceOption(self) -> _SliceMode:
-        return _SliceMode.from_value(self._sliceMode.currentText())
+        return _SliceMode(self._sliceMode.currentText())
 
     def setSliceOption(self, opt):
-        opt = _SliceMode.from_value(opt)
+        opt = _SliceMode(opt)
         idx = self._sliceMode.findText(opt.value)
         self._sliceMode.setCurrentIndex(idx)
 

tomwer/gui/visualization/reconstructionparameters.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import numpy
 import logging
 from silx.gui import qt
 from tomwer.core.utils.char import BETA_CHAR, DELTA_CHAR
@@ -28,14 +29,16 @@ class ReconstructionParameters(qt.QWidget):
         self._deltaBetaQLE = qt.QLineEdit("", self)
         self._deltaBetaQLE.setReadOnly(True)
         self.layout().addRow(self._deltaBetaLabel, self._deltaBetaQLE)
-        # distance
-        self._distanceQLE = qt.QLineEdit("", self)
-        self._distanceQLE.setReadOnly(True)
-        self.layout().addRow("distance (cm)", self._distanceQLE)
+        # sample_detector distance
+        self._sampleDetectorDistanceQLE = qt.QLineEdit("", self)
+        self._sampleDetectorDistanceQLE.setReadOnly(True)
+        self.layout().addRow(
+            "sample-detector distance (cm)", self._sampleDetectorDistanceQLE
+        )
         # pixel size
-        self._pixelSizeQLE = qt.QLineEdit("", self)
-        self._pixelSizeQLE.setReadOnly(True)
-        self.layout().addRow("pixel size (cm)", self._pixelSizeQLE)
+        self._voxelSizeQLE = qt.QLineEdit("", self)
+        self._voxelSizeQLE.setReadOnly(True)
+        self.layout().addRow("voxel size (cm)", self._voxelSizeQLE)
         # cor
         self._corQLE = qt.QLineEdit("", self)
         self._corQLE.setReadOnly(True)
@@ -89,7 +92,7 @@ class ReconstructionParameters(qt.QWidget):
             self._setPhaseMethod,
             self._setDeltaBeta,
             self._setDistance,
-            self._setPixelSize,
+            self._setVoxelSize,
             self._setCor,
             self._setPaddingType,
             self._setHalfTomo,
@@ -136,29 +139,38 @@ class ReconstructionParameters(qt.QWidget):
             distance_cm = f"{distance_cm:.2}"
         else:
             distance_cm = ""
-        self._distanceQLE.setText(distance_cm)
+        self._sampleDetectorDistanceQLE.setText(distance_cm)
 
-    def _setPixelSize(self, metadata: dict):
+    def _setVoxelSize(self, metadata: dict):
         # voxel size can be stored as pixel size (old version) or voxel size (new version)
         recons_params = metadata.get("processing_options", {}).get("reconstruction", {})
-        voxel_size_cm = recons_params.get("voxel_size_cm", None)
+        voxel_size_cm = recons_params.get("voxel_size_cm", [None] * 3)
+        # back compatibility when voxel was a scalar ( ~ nabu 2023 ?)
+        if numpy.isscalar(voxel_size_cm):
+            voxel_size_cm = [voxel_size_cm] * 3
 
         # now voxel size is expected to be a tuple of three elements
         if voxel_size_cm is not None:
-            voxel_size_cm = voxel_size_cm[0]
-            # FIXME: load_ini seems to fail to remove some char like '(' or ')'... to be fixed or investigate
-            # simplest might be to filter those when dumping it to text file... ??? or to handle those at silx level
-            if isinstance(voxel_size_cm, str):
-                for char_to_ignore in (" ", "(", ")", "[", "]"):
-                    voxel_size_cm = voxel_size_cm.replace(char_to_ignore, "")
+
+            def clean_voxel_value(value):
+                if isinstance(value, str):
+                    for char_to_ignore in (" ", "(", ")", "[", "]"):
+                        value = value.replace(char_to_ignore, "")
+                return value
+
+            voxel_size_cm = [clean_voxel_value(value) for value in voxel_size_cm]
+
         else:
             # backward compatibility with old volume
-            voxel_size_cm = recons_params.get("pixel_size_cm", None)
-        if voxel_size_cm is not None:
-            voxel_size_cm = f"{float(voxel_size_cm):.8}"
-        self._pixelSizeQLE.setText(
-            str(voxel_size_cm) if voxel_size_cm is not None else ""
-        )
+            voxel_size_cm = recons_params.get("pixel_size_cm", [None] * 3)
+
+        voxel_size_cm = filter(None, voxel_size_cm)
+
+        def cast_voxel_value(value: float | None):
+            return f"{float(value):.8}"
+
+        voxel_size_cm = [cast_voxel_value(value) for value in voxel_size_cm]
+        self._voxelSizeQLE.setText("x".join(voxel_size_cm))
 
     def _setCor(self, metadata: dict):
         cor = (