tomwer 1.4.19__py3-none-any.whl → 1.5.0__py3-none-any.whl

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
@@ -102,7 +102,7 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
         self.sigConfChanged.emit(param)
 
     def getMethod(self) -> _NabuPhaseMethod:
-        return _NabuPhaseMethod.from_value(self._methodCB.currentText())
+        return _NabuPhaseMethod(self._methodCB.currentText())
 
     @docstring(base._NabuStageConfigBase)
     def setConfiguration(self, config) -> None:
@@ -111,7 +111,7 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
             if method == "none":
                 method = _NabuPhaseMethod.NONE
             self._paganinOpts.setConfiguration(config)
-            method = _NabuPhaseMethod.from_value(method)
+            method = _NabuPhaseMethod(method)
             index_method = self._methodCB.findText(method.value)
             if index_method >= 0:
                 self._methodCB.setCurrentIndex(index_method)
@@ -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

@@ -401,9 +401,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         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
-            ).value
+            sino_rings_correction = RingCorrectionMethod(sino_rings_correction).value
             idx = self._sinoRingCorrectionMthd.findText(sino_rings_correction)
             if idx >= 0:
                 self._sinoRingCorrectionMthd.setCurrentIndex(idx)
@@ -581,7 +579,7 @@ class SinoRingsOptions(qt.QWidget):
             self._sigmaHigh.setValue(float(high_pass))
 
     def setMethod(self, method: RingCorrectionMethod):
-        method = RingCorrectionMethod.from_value(method)
+        method = RingCorrectionMethod(method)
         self._method = method
         # handle munch options
         self._sigmaMunch.setVisible(method is RingCorrectionMethod.MUNCH)

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
@@ -97,7 +97,7 @@ class SliceGroupBox(qt.QGroupBox):
         )
 
     def setMode(self, mode: NabuSliceMode):
-        mode = NabuSliceMode.from_value(mode)
+        mode = NabuSliceMode(mode)
         item_index = self._modeCB.findText(mode.value)
         self._modeCB.setCurrentIndex(item_index)
         old = self.blockSignals(True)
@@ -105,7 +105,7 @@ class SliceGroupBox(qt.QGroupBox):
         self.blockSignals(old)
 
     def getMode(self) -> NabuSliceMode:
-        mode = NabuSliceMode.from_value(self._modeCB.currentText())
+        mode = NabuSliceMode(self._modeCB.currentText())
         return mode
 
     def _getSliceSelected(self):
@@ -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)
 
@@ -334,45 +338,52 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self.registerWidget(self._methodLabel, "required")
         self.registerWidget(self._methodQCB, "required")
 
+        self._methodWarningLabel = qt.QLabel(
+            f"\tWARNING: \n\t1.' {_NabuReconstructionMethods.MLEM.value}' can be EXTREMELY SLOW on transmission\n\tdata and may produce erroneous results.\n\t2.MLEM should only be used with XRFCT data."
+        )
+        self._methodWarningLabel.setStyleSheet("color: red")
+        self._methodWarningLabel.setVisible(False)
+        self.layout().addWidget(self._methodWarningLabel, 3, 0, 1, 2)
+
         # angle_offset
         self._labelOffsetLabel = qt.QLabel("angle offset (in degree)", self)
-        self.layout().addWidget(self._labelOffsetLabel, 3, 0, 1, 1)
+        self.layout().addWidget(self._labelOffsetLabel, 4, 0, 1, 1)
         self._angleOffsetQDSB = QDoubleSpinBoxIgnoreWheel(self)
         self._angleOffsetQDSB.setMaximum(-180)
         self._angleOffsetQDSB.setMaximum(180)
-        self.layout().addWidget(self._angleOffsetQDSB, 3, 1, 1, 1)
+        self.layout().addWidget(self._angleOffsetQDSB, 4, 1, 1, 1)
         self.registerWidget(self._labelOffsetLabel, "advanced")
         self.registerWidget(self._angleOffsetQDSB, "advanced")
 
         # fbp filter type
         self._fbpFilterCB = qt.QCheckBox("fbp filter", self)
-        self.layout().addWidget(self._fbpFilterCB, 4, 0, 1, 1)
+        self.layout().addWidget(self._fbpFilterCB, 5, 0, 1, 1)
         self._fbpFilterType = QComboBoxIgnoreWheel(self)
         for filter_type in _NabuFBPFilterType:
             self._fbpFilterType.addItem(filter_type.value)
-        self.layout().addWidget(self._fbpFilterType, 4, 1, 1, 1)
+        self.layout().addWidget(self._fbpFilterType, 5, 1, 1, 1)
         self.registerWidget(self._fbpFilterCB, "advanced")
         self.registerWidget(self._fbpFilterType, "advanced")
 
         # padding type
         self._paddingTypeLabel = qt.QLabel("padding type", self)
-        self.layout().addWidget(self._paddingTypeLabel, 5, 0, 1, 1)
+        self.layout().addWidget(self._paddingTypeLabel, 6, 0, 1, 1)
         self._paddingType = QComboBoxIgnoreWheel(self)
         for fbp_padding_type in _NabuPaddingType:
             self._paddingType.addItem(fbp_padding_type.value)
-        self.layout().addWidget(self._paddingType, 5, 1, 1, 1)
+        self.layout().addWidget(self._paddingType, 6, 1, 1, 1)
         self.registerWidget(self._paddingTypeLabel, "optional")
         self.registerWidget(self._paddingType, "optional")
 
         # sub region
         self._subRegionSelector = _NabuReconstructionSubRegion(parent=self)
-        self.layout().addWidget(self._subRegionSelector, 7, 0, 1, 2)
+        self.layout().addWidget(self._subRegionSelector, 8, 0, 1, 2)
 
         # iterations
         self._iterationsLabel = qt.QLabel("iterations", self)
-        self.layout().addWidget(self._iterationsLabel, 8, 0, 1, 1)
+        self.layout().addWidget(self._iterationsLabel, 9, 0, 1, 1)
         self._iterationSB = qt.QSpinBox(parent=self)
-        self.layout().addWidget(self._iterationSB, 8, 1, 1, 1)
+        self.layout().addWidget(self._iterationSB, 9, 1, 1, 1)
         self._iterationSB.setMinimum(1)
         self._iterationSB.setMaximum(9999)
         # not supported for now so hidden
@@ -383,20 +394,20 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._binSubSamplingGB = _BinSubSampling(
             "binning and sub-sampling", parent=self
         )
-        self.layout().addWidget(self._binSubSamplingGB, 9, 0, 1, 2)
+        self.layout().addWidget(self._binSubSamplingGB, 10, 0, 1, 2)
 
         # optimization algorithm:
         # set has default value for now, because has only one at the moment
 
         # weight total variation
         self._tvLabel = qt.QLabel("total variation weight", self)
-        self.layout().addWidget(self._tvLabel, 10, 0, 1, 1)
+        self.layout().addWidget(self._tvLabel, 11, 0, 1, 1)
         self._totalVariationWeight = qt.QDoubleSpinBox(self)
         self._totalVariationWeight.setMinimum(0.0)
         self._totalVariationWeight.setMaximum(1.0)
         self._totalVariationWeight.setDecimals(4)
         self._totalVariationWeight.setSingleStep(0.002)
-        self.layout().addWidget(self._totalVariationWeight, 9, 1, 1, 1)
+        self.layout().addWidget(self._totalVariationWeight, 10, 1, 1, 1)
         # not supported for now so hidden
         self._tvLabel.hide()
         self._totalVariationWeight.hide()
@@ -406,7 +417,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._preconditioningFilter.setToolTip(
             'Whether to enable "filter ' 'preconditioning" for iterative' " methods"
         )
-        self.layout().addWidget(self._preconditioningFilter, 10, 0, 1, 2)
+        self.layout().addWidget(self._preconditioningFilter, 11, 0, 1, 2)
         # not supported for now so hidden
         self._preconditioningFilter.hide()
 
@@ -415,7 +426,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._positivityConstraintCB.setToolTip(
             "Whether to enforce a " "positivity constraint in the " "reconstruction."
         )
-        self.layout().addWidget(self._positivityConstraintCB, 11, 0, 1, 2)
+        self.layout().addWidget(self._positivityConstraintCB, 12, 0, 1, 2)
         # not supported for now so hidden
         self._positivityConstraintCB.hide()
 
@@ -424,13 +435,13 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self._clipOuterCircleCB.setToolTip(
             "Whether to set to zero voxels falling outside of the reconstruction region"
         )
-        self.layout().addWidget(self._clipOuterCircleCB, 12, 0, 1, 2)
+        self.layout().addWidget(self._clipOuterCircleCB, 13, 0, 1, 2)
         self.registerWidget(self._clipOuterCircleCB, "optional")
 
         # centered axis option
         self._centeredAxisCB = qt.QCheckBox("centered axis", self)
         self._centeredAxisCB.setToolTip("")
-        self.layout().addWidget(self._centeredAxisCB, 13, 0, 1, 2)
+        self.layout().addWidget(self._centeredAxisCB, 14, 0, 1, 2)
         self.registerWidget(self._centeredAxisCB, "optional")
 
         # translation movement file
@@ -440,6 +451,12 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         self.layout().addWidget(self._transMvtFileWidget, 22, 1, 1, 1)
         self.registerWidget(self._transMvtFileLabel, "advanced")
         self.registerWidget(self._transMvtFileWidget, "advanced")
+        translation_movement_tooltip = """
+        A file where each line describes the horizontal and vertical translations of the sample (or detector).
+        The order is 'horizontal, vertical'
+        It can be created from a numpy array saved with 'numpy.savetxt'"""
+        self._transMvtFileLabel.setToolTip(translation_movement_tooltip)
+        self._transMvtFileWidget.setToolTip(translation_movement_tooltip)
 
         # angle files (if the user want's to overwrite rotation angles)
         self._angleFileLabel = qt.QLabel("angles file", self)
@@ -527,8 +544,12 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
     def _slicesChanged(self, *args, **kwargs):
         self._signalConfChanged("tomwer_slices")
 
-    def _methodChanged(self, *args, **kwargs):
+    def _methodChanged(self, index):  # *args, **kwargs):
         self._signalConfChanged("method")
+        selected_method = self.getMethod()
+        self._methodWarningLabel.setVisible(
+            selected_method == _NabuReconstructionMethods.MLEM
+        )
 
     def _angleOffsetChanged(self, *args, **kwargs):
         self._signalConfChanged("angle_offset")
@@ -574,10 +595,10 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
         raise NotImplementedError()
 
     def getMethod(self) -> _NabuReconstructionMethods:
-        return _NabuReconstructionMethods.from_value(self._methodQCB.currentText())
+        return _NabuReconstructionMethods(self._methodQCB.currentText())
 
     def setMethod(self, method):
-        method = _NabuReconstructionMethods.from_value(method)
+        method = _NabuReconstructionMethods(method)
         item_index = self._methodQCB.findText(method.value)
         self._methodQCB.setCurrentIndex(item_index)
 
@@ -589,7 +610,7 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
 
     def getFBPFilterType(self) -> _NabuFBPFilterType | None:
         if self._fbpFilterCB.isChecked():
-            return _NabuFBPFilterType.from_value(self._fbpFilterType.currentText())
+            return _NabuFBPFilterType(self._fbpFilterType.currentText())
         else:
             return None
 
@@ -605,10 +626,10 @@ class _NabuReconstructionConfig(qt.QWidget, _NabuStageConfigBase):
             self._fbpFilterType.setCurrentIndex(filter_index)
 
     def getFBPPaddingType(self) -> _NabuPaddingType:
-        return _NabuPaddingType.from_value(self._paddingType.currentText())
+        return _NabuPaddingType(self._paddingType.currentText())
 
     def setFBPPaddingType(self, padding):
-        padding = _NabuPaddingType.from_value(padding)
+        padding = _NabuPaddingType(padding)
         padding_index = self._paddingType.findText(padding.value)
         self._paddingType.setCurrentIndex(padding_index)
 
@@ -1012,17 +1033,22 @@ class _BinSubSampling(qt.QGroupBox):
     def __init__(self, text, parent):
         qt.QGroupBox.__init__(self, text)
         self.setLayout(qt.QFormLayout())
-        # horizontal binning
-        self._hBinningSB = QSpinBoxIgnoreWheel(self)
-        self._hBinningSB.setMinimum(1)
-        self._hBinningSB.setMaximum(3)
-        self.layout().addRow("horizontal binning", self._hBinningSB)
-        # vertical binning
-        self._vBinningSB = qt.QSpinBox(self)
-        self._vBinningSB.setMinimum(1)
-        self._vBinningSB.setMaximum(100)
-        # self.layout().addRow('vertical binning', self._vBinningSB)
-        self._vBinningSB.setVisible(False)
+        # binning
+        self._binningSB = QSpinBoxIgnoreWheel(self)
+        self._binningSB.setMinimum(1)
+        self._binningSB.setMaximum(3)
+        self.layout().addRow("binning", self._binningSB)
+        self._binningSB.setToolTip(
+            "Binning factor in the horizontal dimension when reading the data. \nThe final slices dimensions will be divided by this factor."
+        )
+        # z binning
+        self._zBinningSB = qt.QSpinBox(self)
+        self._zBinningSB.setMinimum(1)
+        self._zBinningSB.setMaximum(100)
+        self.layout().addRow("vertical binning", self._zBinningSB)
+        self._zBinningSB.setToolTip(
+            "Binning factor in the vertical dimension when reading the data. \nThis results in a lesser number of reconstructed slices."
+        )
         # projection sub-sampling
         self._projSubsamplingSB = QSpinBoxIgnoreWheel(self)
         self._projSubsamplingSB.setMinimum(1)
@@ -1030,35 +1056,35 @@ class _BinSubSampling(qt.QGroupBox):
         self.layout().addRow("projection sub-sampling", self._projSubsamplingSB)
 
         # connect signal / slot
-        self._vBinningSB.valueChanged.connect(self._valueUpdated)
-        self._hBinningSB.valueChanged.connect(self._valueUpdated)
+        self._zBinningSB.valueChanged.connect(self._valueUpdated)
+        self._binningSB.valueChanged.connect(self._valueUpdated)
 
-    def getHorizontalBinning(self):
-        return self._hBinningSB.value()
+    def getHorizontalBinning(self) -> int:
+        return self._binningSB.value()
 
-    def setHorizontalBinning(self, binning):
-        return self._hBinningSB.setValue(int(binning))
+    def setHorizontalBinning(self, binning: int):
+        return self._binningSB.setValue(int(binning))
 
-    def getVerticalBinning(self):
-        return self._vBinningSB.value()
+    def getVerticalBinning(self) -> int:
+        return self._zBinningSB.value()
 
-    def setVerticalBinning(self, binning):
-        return self._vBinningSB.setValue(int(binning))
+    def setVerticalBinning(self, binning: int):
+        return self._zBinningSB.setValue(int(binning))
 
-    def getProjSubsampling(self):
+    def getProjSubsampling(self) -> int:
         return self._projSubsamplingSB.value()
 
-    def setProjSubsampling(self, subsampling):
+    def setProjSubsampling(self, subsampling: int):
         return self._projSubsamplingSB.setValue(int(subsampling))
 
-    def getConfiguration(self):
+    def getConfiguration(self) -> dict:
         return {
             "binning": self.getHorizontalBinning(),
             "binning_z": self.getVerticalBinning(),
             "projections_subsampling": self.getProjSubsampling(),
         }
 
-    def setConfiguration(self, config):
+    def setConfiguration(self, config: dict):
         if "binning" in config:
             self.setHorizontalBinning(config["binning"])
         if "binning_z" in config:

tomwer/gui/reconstruction/nabu/nabuflow.py

@@ -9,7 +9,6 @@ from silx.gui import qt
 
 from tomwer.core.process.reconstruction.nabu.utils import _NabuStages
 from tomwer.gui import icons
-from tomwer.gui.utils.illustrations import _IllustrationWidget
 from tomwer.utils import docstring
 
 from ...utils.flow import FlowCanvas, FlowDirection
@@ -32,7 +31,7 @@ class NabuFlowControl(qt.QWidget):
     def __init__(self, parent, direction):
         qt.QWidget.__init__(self, parent=parent)
 
-        self._direction = FlowDirection.from_value(direction)
+        self._direction = FlowDirection(direction)
 
         if self._direction is FlowDirection.VERTICAL:
             self.setLayout(qt.QVBoxLayout())
@@ -113,7 +112,7 @@ class NabuFlowControl(qt.QWidget):
         self.setPostVisible(True)
 
     def _updateActiveProcess(self, stage):
-        stage = _NabuStages.from_value(stage)
+        stage = _NabuStages(stage)
 
         if stage is _NabuStages.INI:
             activeWidget = self._iniProcessWidgets
@@ -330,20 +329,13 @@ class NabuFlowArea(qt.QWidget):
 
     def __init__(self, parent, direction):
         qt.QWidget.__init__(self, parent=parent)
-        direction = FlowDirection.from_value(direction)
+        direction = FlowDirection(direction)
 
         if direction is FlowDirection.VERTICAL:
             self.setLayout(qt.QHBoxLayout(self))
-            img_flow = "flow_down"
         else:
             self.setLayout(qt.QVBoxLayout(self))
-            img_flow = "flow_right"
 
-        self._flowIllustration = _IllustrationWidget(parent=self, img=img_flow)
-        self._flowIllustration.setFixedWidth(50)
-        self._flowIllustration.setSizePolicy(
-            qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
-        )
         self._control = NabuFlowControl(parent=self, direction=direction)
         self._control.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum)
         self._addRmWidget = _AddRemoveProcessWidget(parent=self, direction=direction)
@@ -352,13 +344,11 @@ class NabuFlowArea(qt.QWidget):
 
         if direction is FlowDirection.VERTICAL:
             # if vertical illustration left sided
-            self.layout().addWidget(self._flowIllustration)
             self.layout().addWidget(self._control)
             self.layout().addWidget(self._addRmWidget)
         else:
             # if horizontal illustration bottom sided
             self.layout().addWidget(self._control)
-            self.layout().addWidget(self._flowIllustration)
             self.layout().addWidget(self._addRmWidget)
 
         # set up

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
@@ -56,7 +56,7 @@ class _NabuStages(_Enum):
     @staticmethod
     def getProcessEnum(stage):
         """Return the process Enum associated to the stage"""
-        stage = _NabuStages.from_value(stage)
+        stage = _NabuStages(stage)
         if stage is _NabuStages.INI:
             raise NotImplementedError()
         elif stage is _NabuStages.PRE:
@@ -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)
@@ -147,7 +147,7 @@ class _NabuConfiguration(qt.QWidget):
             self.addStage(stage=stage, processes=processes)
 
     def addStage(self, stage, processes):
-        stage = _NabuStages.from_value(value=stage)
+        stage = _NabuStages(value=stage)
         for process in processes:
             _NabuStages.getProcessEnum(stage=stage)
 
@@ -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:
@@ -436,7 +436,7 @@ class NabuWidget(qt.QWidget):
 
     def __init__(self, parent, flow_direction="vertical"):
         qt.QWidget.__init__(self, parent=parent)
-        flow_direction = FlowDirection.from_value(flow_direction)
+        flow_direction = FlowDirection(flow_direction)
         self.setLayout(qt.QGridLayout())
         self._filteringActive = True
         self._configuration_level = ConfigurationLevel.OPTIONAL
@@ -485,7 +485,7 @@ class NabuWidget(qt.QWidget):
             qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
         )
         self._configurationScrollArea.setSizePolicy(
-            qt.QSizePolicy.Minimum, qt.QSizePolicy.Minimum
+            qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum
         )
 
         # expose API
@@ -575,10 +575,10 @@ class NabuWidget(qt.QWidget):
         self._configuration.hidePaganinInterface()
 
     def getMode(self):
-        return _NabuMode.from_value(self._nabuModeCB.currentText())
+        return _NabuMode(self._nabuModeCB.currentText())
 
     def setMode(self, mode):
-        mode = _NabuMode.from_value(mode)
+        mode = _NabuMode(mode)
         idx = self._nabuModeCB.findText(mode.value)
         self._nabuModeCB.setCurrentIndex(idx)
 
@@ -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/test/test_cast_volume.py

@@ -15,6 +15,7 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": True,
         "rescale_max_percentile": 90,
         "rescale_min_percentile": 10,
+        "remove_input_volume": False,
     }
 
     widget._minMaxAuto.setChecked(False)
@@ -28,6 +29,7 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": True,
         "rescale_max_percentile": None,
         "rescale_min_percentile": None,
+        "remove_input_volume": False,
     }
 
     widget.setDataMin(1.0)
@@ -43,6 +45,7 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": True,
         "rescale_max_percentile": None,
         "rescale_min_percentile": None,
+        "remove_input_volume": False,
     }
     widget.setOutputFileformat("edf")
     assert widget.getConfiguration() == {
@@ -55,6 +58,7 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": True,
         "rescale_max_percentile": None,
         "rescale_min_percentile": None,
+        "remove_input_volume": False,
     }
     widget.setOverwrite(False)
     assert widget.getConfiguration() == {
@@ -67,6 +71,7 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": False,
         "rescale_max_percentile": None,
         "rescale_min_percentile": None,
+        "remove_input_volume": False,
     }
     widget.setOutputDataType("float32")
     assert widget.getConfiguration() == {
@@ -79,4 +84,18 @@ def test_CastVolumeWidget(qtapp):  # noqa F811
         "overwrite": False,
         "rescale_max_percentile": None,
         "rescale_min_percentile": None,
+        "remove_input_volume": False,
+    }
+    widget.setRemoveInputVolume(True)
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 10.0,
+        "data_min": 1.0,
+        "output_data_type": "float32",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "edf",
+        "overwrite": False,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+        "remove_input_volume": True,
     }

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

@@ -493,21 +493,21 @@ class _NormIntensityOptions(qt.QWidget):
         self._lockButton.hide()
 
     def getCurrentMethod(self):
-        return Method.from_value(self._modeCB.currentText())
+        return Method(self._modeCB.currentText())
 
     def setCurrentMethod(self, method):
-        method = Method.from_value(method)
+        method = Method(method)
         idx = self._modeCB.findText(method.value)
         self._modeCB.setCurrentIndex(idx)
 
     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: