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

tomwer/gui/reconstruction/saaxis/dimensionwidget.py

@@ -4,12 +4,14 @@ contains gui relative to semi-automatic axis calculation
 
 from __future__ import annotations
 
+import pint
 from typing import Iterable
 
 from silx.gui import qt
-from pyunitsystem.metricsystem import MetricSystem
 from tomwer.gui.utils.qt_utils import block_signals
 
+_ureg = pint.get_application_registry()
+
 
 class DimensionWidget(qt.QGroupBox):
     """
@@ -37,10 +39,10 @@ class DimensionWidget(qt.QGroupBox):
         assert dims_colors is None or (
             isinstance(dims_colors, Iterable) and len(dims_colors) == 3
         )
-        self._dim0Value = 1.0 * MetricSystem.MILLIMETER.value
-        self._dim1Value = 1.0 * MetricSystem.MILLIMETER.value
-        self._dim2Value = 1.0 * MetricSystem.MILLIMETER.value
-        self._displayUnit = MetricSystem.MILLIMETER
+        self._displayUnit = _ureg.millimeter
+        self._dim0Value: pint.Quantity = 1.0 * self._displayUnit
+        self._dim1Value: pint.Quantity = 1.0 * self._displayUnit
+        self._dim2Value: pint.Quantity = 1.0 * self._displayUnit
         # defined unit to display values. Always stored in m (International
         # System)
         ## set GUI
@@ -53,7 +55,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim0ValueQLE.setRange(0, 999999999999)
         self._dim0ValueQLE.setDecimals(10)
         self._dim0ValueQLE.setSingleStep(0.0001)
-        self._dim0ValueQLE.setValue(self._getDim0DisplayValue())
+        self._dim0ValueQLE.setValue(self._dim0Value.magnitude)
         if dims_colors is not None:
             stylesheet = f"background-color: {dims_colors[0]}"
             self._dim0ValueQLE.setStyleSheet(stylesheet)
@@ -65,7 +67,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim1ValueQLE.setRange(0, 999999999999)
         self._dim1ValueQLE.setDecimals(10)
         self._dim1ValueQLE.setSingleStep(0.0001)
-        self._dim1ValueQLE.setValue(self._getDim1DisplayValue())
+        self._dim1ValueQLE.setValue(self._dim1Value.magnitude)
         if dims_colors is not None:
             stylesheet = f"background-color: {dims_colors[1]}"
             self._dim1ValueQLE.setStyleSheet(stylesheet)
@@ -77,7 +79,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim2ValueQLE.setRange(0, 999999999999)
         self._dim2ValueQLE.setDecimals(10)
         self._dim2ValueQLE.setSingleStep(0.0001)
-        self._dim2ValueQLE.setValue(self._getDim2DisplayValue())
+        self._dim2ValueQLE.setValue(self._dim2Value.magnitude)
         if dims_colors is not None:
             stylesheet = f"background-color: {dims_colors[2]}"
             self._dim2ValueQLE.setStyleSheet(stylesheet)
@@ -91,42 +93,32 @@ class DimensionWidget(qt.QGroupBox):
         self._dim1ValueQLE.editingFinished.connect(self._userSetDim1)
         self._dim2ValueQLE.editingFinished.connect(self._userSetDim2)
 
-    def _getDim0DisplayValue(self) -> float:
-        return self._dim0Value / self._displayUnit.value
-
-    def _getDim1DisplayValue(self) -> float:
-        return self._dim1Value / self._displayUnit.value
-
-    def _getDim2DisplayValue(self) -> float:
-        return self._dim2Value / self._displayUnit.value
-
-    def setUnit(self, unit):
+    def setUnit(self, unit: pint.Unit):
         """
         define with which unit we should display the size
         :param unit: metric to be used for display. Internally this is always stored using the international metric system
         """
-        self._displayUnit = MetricSystem.from_value(unit)
+        if not isinstance(unit, pint.Unit):
+            raise TypeError(
+                f"unit is expected be an instance of {pint.Unit}. Got {type(unit)}"
+            )
         for widget in (self._dim0ValueQLE, self._dim1ValueQLE, self._dim2ValueQLE):
-            widget.setSuffix(str(self.unit()))
+            widget.setSuffix(f"{self._displayUnit:~}")
+        # convert current values
+        self._dim0Value = self._dim0Value.magnitude * self._displayUnit
+        self._dim1Value = self._dim1Value.magnitude * self._displayUnit
+        self._dim2Value = self._dim2Value.magnitude * self._displayUnit
         # update displayed values
         with block_signals(self):
-            self._dim0ValueQLE.setValue(self._getDim0DisplayValue())
-            self._dim1ValueQLE.setValue(self._getDim1DisplayValue())
-            self._dim2ValueQLE.setValue(self._getDim2DisplayValue())
-
-    def unit(self) -> MetricSystem:
-        """
+            self._dim0ValueQLE.setValue(self._dim0Value.magnitude)
+            self._dim1ValueQLE.setValue(self._dim1Value.magnitude)
+            self._dim2ValueQLE.setValue(self._dim2Value.magnitude)
 
-        :return: metric system used for display
-        """
-        return self._displayUnit
-
-    def setValues(
+    def setQuantities(
         self,
-        dim0: float,
-        dim1: float,
-        dim2: float,
-        unit: str | MetricSystem = "mm",
+        dim0: pint.Quantity,
+        dim1: pint.Quantity,
+        dim2: pint.Quantity,
     ) -> None:
         """
 
@@ -136,66 +128,78 @@ class DimensionWidget(qt.QGroupBox):
         :param unit: unit used for the provided values
         """
         with block_signals(self):
-            self.setDim0value(value=dim0, unit=unit)
-            self.setDim1value(value=dim1, unit=unit)
-            self.setDim2value(value=dim2, unit=unit)
+            self.setDim0Quantity(value=dim0)
+            self.setDim1value(value=dim1)
+            self.setDim2Quantity(value=dim2)
         self.valuesChanged.emit()
 
-    def getValues(self) -> tuple:
+    def getQuantities(
+        self, cast_unit_to: None | pint.Unit = None
+    ) -> tuple[pint.Quantity]:
         """
+        :param cast_unit_to: if given will cast the quantities to the requested unit
 
-        :return: (dim0 value, dim1 value, dim2 value, unit)
+        :return: (dim0 value, dim1 value, dim2 value)
         """
-        return (
-            self.getDim0Value()[0],
-            self.getDim1Value()[0],
-            self.getDim2Value()[0],
-            MetricSystem.METER,
-        )
-
-    def getDim0Value(self) -> tuple:
+        if cast_unit_to is None:
+            return (
+                self.getDim0Quantity(),
+                self.getDim1Quantity(),
+                self.getDim2Quantity(),
+            )
+        else:
+            return (
+                self.getDim0Quantity().to(cast_unit_to),
+                self.getDim1Quantity().to(cast_unit_to),
+                self.getDim2Quantity().to(cast_unit_to),
+            )
+
+    def getDim0Quantity(self) -> tuple:
         """Return Dim 0 value and unit. Unit is always meter"""
-        return self._dim0Value, MetricSystem.METER
+        return self._dim0Value
 
-    def setDim0value(self, value: str | MetricSystem, unit="mm"):
+    def setDim0Quantity(self, value: pint.Quantity):
         """
 
         :param value: value to set to dim 0.
         :return:
         """
-        self._dim0Value = value * MetricSystem.from_value(unit).value
+        assert isinstance(value, pint.Quantity)
+        self._dim0Value = value
         with block_signals(self):
-            self._dim0ValueQLE.setValue(self._dim0Value)
+            self._dim0ValueQLE.setValue(self._dim0Value.magnitude)
         self.valuesChanged.emit()
 
-    def getDim1Value(self) -> tuple:
-        """Return Dim 0 value and unit. Unit is always meter"""
-        return self._dim1Value, MetricSystem.METER
+    def getDim1Quantity(self) -> pint.Quantity:
+        """Return Dim 1 Quantity"""
+        return self._dim1Value
 
-    def setDim1value(self, value: str | MetricSystem, unit="mm"):
+    def setDim1value(self, value: pint.Quantity):
         """
 
         :param value: value to set to dim 1.
         :return:
         """
-        self._dim1Value = value * MetricSystem.from_value(unit).value
+        assert isinstance(value, pint.Quantity)
+        self._dim1Value = value
         with block_signals(self):
-            self._dim1ValueQLE.setValue(self._dim1Value)
+            self._dim1ValueQLE.setValue(self._dim1Value.magnitude)
         self.valuesChanged.emit()
 
-    def getDim2Value(self) -> tuple:
-        """Return Dim 0 value and unit. Unit is always meter"""
-        return self._dim2Value, MetricSystem.METER
+    def getDim2Quantity(self) -> pint.Quantity:
+        """Return Dim 2 value and unit. Unit is always meter"""
+        return self._dim2Value
 
-    def setDim2value(self, value: str | MetricSystem, unit="mm"):
+    def setDim2Quantity(self, value: pint.Quantity):
         """
 
         :param value: value to set to dim 2.
         :return:
         """
-        self._dim2Value = value * MetricSystem.from_value(unit).value
+        assert isinstance(value, pint.Quantity)
+        self._dim2Value = value
         with block_signals(self):
-            self._dim2ValueQLE.setValue(self._dim2Value)
+            self._dim2ValueQLE.setValue(self._dim2Value.magnitude)
         self.valuesChanged.emit()
 
     def _valuesChanged(self, *args, **kwargs):
@@ -204,17 +208,17 @@ class DimensionWidget(qt.QGroupBox):
     def _userSetDim0(self):
         """callback when the user modify the dim 0 QDSP"""
         with block_signals(self):
-            self._dim0Value = self._dim0ValueQLE.value() * self.unit().value
+            self._dim0Value = self._dim0ValueQLE.value() * self._displayUnit
         self.valuesChanged.emit()
 
     def _userSetDim1(self):
         """callback when the user modify the dim 1 QDSP"""
         with block_signals(self):
-            self._dim1Value = self._dim1ValueQLE.value() * self.unit().value
+            self._dim1Value = self._dim1ValueQLE.value() * self._displayUnit
         self.valuesChanged.emit()
 
     def _userSetDim2(self):
         """callback when the user modify the dim 2 QDSP"""
         with block_signals(self):
-            self._dim2Value = self._dim2ValueQLE.value() * self.unit().value
+            self._dim2Value = self._dim2ValueQLE.value() * self._displayUnit
         self.valuesChanged.emit()

tomwer/gui/reconstruction/sacommon.py

@@ -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

@@ -5,6 +5,7 @@ contains gui to select a slice in a volume
 from __future__ import annotations
 
 import logging
+import pint
 import os
 import weakref
 from contextlib import AbstractContextManager
@@ -247,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)
 
@@ -670,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
@@ -739,7 +740,9 @@ class ScorePlot(qt.QWidget):
         self._plot.getPlotWidget().clear()
         self._varValueWidget.setImgWidth(None)
 
-    def setVoxelSize(self, dim0, dim1, dim2, unit: str | float):
+    def setVoxelSize(
+        self, dim0: pint.Quantity, dim1: pint.Quantity, dim2: pint.Quantity
+    ):
         """
 
         :param dim0:
@@ -747,9 +750,11 @@ class ScorePlot(qt.QWidget):
         :param dim2:
         :param unit:
         """
-        self._voxelSizeW.setValues(dim0=dim0, dim1=dim1, dim2=dim2, unit=unit)
+        self._voxelSizeW.setQuantities(dim0=dim0, dim1=dim1, dim2=dim2)
 
-    def setVolumeSize(self, dim0, dim1, dim2, unit: str | float):
+    def setVolumeSize(
+        self, dim0: pint.Quantity, dim1: pint.Quantity, dim2: pint.Quantity
+    ):
         """
 
         :param dim0:
@@ -757,14 +762,15 @@ class ScorePlot(qt.QWidget):
         :param dim2:
         :param unit:
         """
-        self._volumeSizeW.setValues(dim0=dim0, dim1=dim1, dim2=dim2, unit=unit)
+        self._volumeSizeW.setQuantities(dim0=dim0, dim1=dim1, dim2=dim2)
 
     def getDim0N(self):
         """return the number of elements in dimension 0 according to voxel
         size and volume size"""
         return int(
             numpy.ceil(
-                self._volumeSizeW.getDim0Value()[0] / self._voxelSizeW.getDim0Value()[0]
+                self._volumeSizeW.getDim0Quantity().to_base_units().magnitude
+                / self._voxelSizeW.getDim0Quantity().to_base_units().magnitude
             )
         )
 
@@ -773,7 +779,8 @@ class ScorePlot(qt.QWidget):
         size and volume size"""
         return int(
             numpy.ceil(
-                self._volumeSizeW.getDim1Value()[0] / self._voxelSizeW.getDim1Value()[0]
+                self._volumeSizeW.getDim1Quantity().to_base_units().magnitude
+                / self._voxelSizeW.getDim1Quantity().to_base_units().magnitude
             )
         )
 
@@ -782,7 +789,8 @@ class ScorePlot(qt.QWidget):
         size and volume size"""
         return int(
             numpy.ceil(
-                self._volumeSizeW.getDim2Value()[0] / self._voxelSizeW.getDim2Value()[0]
+                self._volumeSizeW.getDim2Quantity().to_base_units().magnitude
+                / self._voxelSizeW.getDim2Quantity().to_base_units().magnitude
             )
         )
 

tomwer/gui/reconstruction/tests/test_saaxis.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 
 import os
+import pint
 import shutil
 import tempfile
 
@@ -12,7 +13,6 @@ import pytest
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
-from pyunitsystem.metricsystem import MetricSystem
 
 from tomwer.core.process.reconstruction.saaxis.params import (
     ReconstructionMode,
@@ -26,6 +26,9 @@ from tomwer.gui.reconstruction.saaxis.saaxis import SAAxisWindow
 from tomwer.tests.utils import skip_gui_test
 
 
+_ureg = pint.get_application_registry()
+
+
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
 class TestDimensionWidget(TestCaseQt):
     """Test that the axis widget work correctly"""
@@ -39,51 +42,50 @@ class TestDimensionWidget(TestCaseQt):
 
     def testDimension(self):
         """Insure setting dimensions values and unit are correct"""
-        self.assertTrue(self._window.unit() is MetricSystem.MILLIMETER)
         # check initial values
         self.assertEqual(
-            self._window.getValues(),
-            (0.001, 0.001, 0.001, MetricSystem.METER),
+            self._window.getQuantities(),
+            (1.0 * _ureg.millimeter, 1.0 * _ureg.millimeter, 1.0 * _ureg.millimeter),
         )
         # set dim 0 to 20 mm
         self._window._dim0ValueQLE.setValue(20)
         self._window._dim0ValueQLE.editingFinished.emit()
         self.qapp.processEvents()
         self.assertEqual(
-            self._window.getValues(),
-            (0.02, 0.001, 0.001, MetricSystem.METER),
+            self._window.getQuantities(cast_unit_to=_ureg.meter),
+            (0.02 * _ureg.meter, 0.001 * _ureg.meter, 0.001 * _ureg.meter),
         )
         # set dim 1 to 0.6 millimeter
         self._window._dim1ValueQLE.setValue(0.6)
         self._window._dim1ValueQLE.editingFinished.emit()
         self.qapp.processEvents()
         self.assertEqual(
-            self._window.getValues(),
-            (0.02, 0.0006, 0.001, MetricSystem.METER),
+            self._window.getQuantities(cast_unit_to=_ureg.meter),
+            (0.02 * _ureg.meter, 0.0006 * _ureg.meter, 0.001 * _ureg.meter),
         )
         # change display to micrometer
-        self._window.setUnit(MetricSystem.MICROMETER)
+        self._window.setUnit(_ureg.millimeter)
         self.assertEqual(
-            self._window.getValues(),
-            (0.02, 0.0006, 0.001, MetricSystem.METER),
+            self._window.getQuantities(cast_unit_to=_ureg.meter),
+            (0.02 * _ureg.meter, 0.0006 * _ureg.meter, 0.001 * _ureg.meter),
         )
         self.assertEqual(
-            self._window._dim0ValueQLE.value(),
-            20 * MetricSystem.MILLIMETER.value / MetricSystem.MICROMETER.value,
+            self._window._dim0Value,
+            20 * _ureg.millimeter,
         )
         self._window._dim2ValueQLE.setValue(500)
         self._window._dim2ValueQLE.editingFinished.emit()
         self.qapp.processEvents()
         self.assertEqual(
-            self._window.getValues(),
-            (0.02, 0.0006, 0.0005, MetricSystem.METER),
+            self._window.getQuantities(cast_unit_to=_ureg.meter),
+            (0.02 * _ureg.meter, 0.0006 * _ureg.meter, 0.5 * _ureg.meter),
         )
 
     def testConstructorWithColors(self):
         """Insure passing colors works"""
         DimensionWidget(title="title", dims_colors=("#ffff5a", "#62efff", "#ff5bff"))
 
-    def testConstructorWithdimNames(self):
+    def testConstructorWithDimNames(self):
         """Insure passing colors works"""
         DimensionWidget(title="title", dims_name=("x", "y", "z"))
 

tomwer/gui/stitching/SingleAxisStitchingWidget.py

@@ -54,7 +54,7 @@ class SingleAxisStitchingWidget(qt.QWidget, _SingleAxisMixIn):
         # filter stitching types that does belong to the axis (GUI is specific to a given axis. The other have no sense at this level)
         stitching_types = filter(
             lambda s_type: s_type.lower().startswith(self.axis_alias(axis).lower()),
-            StitchingType.values(),
+            [item.value for item in StitchingType],
         )
         for mode in stitching_types:
             self._stitchingTypeCB.addItem(mode)
@@ -84,10 +84,10 @@ class SingleAxisStitchingWidget(qt.QWidget, _SingleAxisMixIn):
         self.sigStitchingTypeChanged.emit(self.getStitchingType().value)
 
     def getStitchingType(self):
-        return StitchingType.from_value(self._stitchingTypeCB.currentText())
+        return StitchingType(self._stitchingTypeCB.currentText())
 
     def setStitchingType(self, mode):
-        mode = StitchingType.from_value(mode)
+        mode = StitchingType(mode)
         idx = self._stitchingTypeCB.findText(mode.value)
         if idx >= 0:
             self._stitchingTypeCB.setCurrentIndex(idx)
@@ -102,7 +102,7 @@ class SingleAxisStitchingWidget(qt.QWidget, _SingleAxisMixIn):
                 ],
             )
         )
-        return tuple([StitchingType.from_value(mode) for mode in pre_proc_modes])
+        return tuple([StitchingType(mode) for mode in pre_proc_modes])
 
     def get_available_post_processing_stitching_mode(self):
         post_proc_modes: tuple[str] = tuple(
@@ -114,7 +114,7 @@ class SingleAxisStitchingWidget(qt.QWidget, _SingleAxisMixIn):
                 ],
             )
         )
-        return tuple([StitchingType.from_value(mode) for mode in post_proc_modes])
+        return tuple([StitchingType(mode) for mode in post_proc_modes])
 
     def addTomoObj(self, tomo_obj: TomwerObject):
         self._mainWidget.addTomoObj(tomo_obj)
@@ -132,10 +132,10 @@ class SingleAxisStitchingWidget(qt.QWidget, _SingleAxisMixIn):
             for tomo_obj in tomo_objs:
                 if (
                     isinstance(tomo_obj, NXtomoScan)
-                    and tomo_obj.x_pixel_size is not None
-                    and tomo_obj.y_pixel_size is not None
+                    and tomo_obj.sample_x_pixel_size is not None
+                    and tomo_obj.sample_y_pixel_size is not None
                 ):
-                    return tomo_obj.x_pixel_size, tomo_obj.y_pixel_size
+                    return tomo_obj.sample_x_pixel_size, tomo_obj.sample_y_pixel_size
                 elif (
                     isinstance(tomo_obj, TomwerVolumeBase)
                     and tomo_obj.voxel_size is not None

tomwer/gui/stitching/StitchingOptionsWidget.py

@@ -272,7 +272,7 @@ class StitchingOptionsWidget(qt.QWidget):
             self._normalizationBySampleWidget.setConfiguration(normalization_by_sample)
 
     def _stitchingTypeChanged(self, stitching_type: str):
-        stitching_type = StitchingType.from_value(stitching_type)
+        stitching_type = StitchingType(stitching_type)
         self._alignmentGroup.setAlignmentAxis1Enabled(
             stitching_type is StitchingType.Z_POSTPROC
         )

tomwer/gui/stitching/alignment.py

@@ -33,8 +33,8 @@ class _AlignmentGroupBox(qt.QGroupBox):
 
         # alignment axis 1
         self._alignmentAxis1CB = qt.QComboBox(self)
-        for alignment in AlignmentAxis1.values():
-            self._alignmentAxis1CB.addItem(alignment)
+        for alignment in AlignmentAxis1:
+            self._alignmentAxis1CB.addItem(alignment.value)
         self.layout().addRow("Axis 1 alignment", self._alignmentAxis1CB)
         self._alignmentAxis1CB.setToolTip(
             f"Alignment to do in case of volumes with different size over axis 1. Only possible for post-processing (reconstructed volume). See {self.ALIGNMENT_DOC} for details."
@@ -42,8 +42,8 @@ class _AlignmentGroupBox(qt.QGroupBox):
 
         # alignment axis 2
         self._alignmentAxis2CB = qt.QComboBox(self)
-        for alignment in AlignmentAxis2.values():
-            self._alignmentAxis2CB.addItem(alignment)
+        for alignment in AlignmentAxis2:
+            self._alignmentAxis2CB.addItem(alignment.value)
         self.layout().addRow("Axis 2 alignment", self._alignmentAxis2CB)
         self._alignmentAxis2CB.setToolTip(
             f"Alignment to do in case of frames with different size over axis 2. See {self.ALIGNMENT_DOC} for details."
@@ -61,19 +61,19 @@ class _AlignmentGroupBox(qt.QGroupBox):
         self.setAlignmentAxis2(self.DEFAULT_ALIGNMENT_AXIS_2)
 
     def getAlignmentAxis1(self) -> AlignmentAxis1:
-        return AlignmentAxis1.from_value(self._alignmentAxis1CB.currentText())
+        return AlignmentAxis1(self._alignmentAxis1CB.currentText())
 
     def setAlignmentAxis1(self, alignment: AlignmentAxis1):
-        alignment = AlignmentAxis1.from_value(alignment)
+        alignment = AlignmentAxis1(alignment)
         self._alignmentAxis1CB.setCurrentIndex(
             self._alignmentAxis1CB.findText(alignment.value)
         )
 
     def getAlignmentAxis2(self) -> AlignmentAxis2:
-        return AlignmentAxis2.from_value(self._alignmentAxis2CB.currentText())
+        return AlignmentAxis2(self._alignmentAxis2CB.currentText())
 
     def setAlignmentAxis2(self, alignment: AlignmentAxis2):
-        alignment = AlignmentAxis2.from_value(alignment)
+        alignment = AlignmentAxis2(alignment)
         self._alignmentAxis2CB.setCurrentIndex(
             self._alignmentAxis2CB.findText(alignment.value)
         )

tomwer/gui/stitching/config/axisparams.py

@@ -80,10 +80,10 @@ class StitcherAxisParams(qt.QWidget):
         return self._axis
 
     def getShiftSearchMethod(self) -> StitchShiftAlgorithm:
-        return StitchShiftAlgorithm.from_value(self._shiftSearchMethodCB.currentText())
+        return StitchShiftAlgorithm(self._shiftSearchMethodCB.currentText())
 
     def setShiftSearchMethod(self, method: StitchShiftAlgorithm | str) -> None:
-        method = StitchShiftAlgorithm.from_value(method)
+        method = StitchShiftAlgorithm(method)
         idx = self._shiftSearchMethodCB.findText(method.value)
         self._shiftSearchMethodCB.setCurrentIndex(idx)
 

tomwer/gui/stitching/config/output.py

@@ -85,7 +85,7 @@ class StitchingOutput(qt.QWidget):
         self._updateOutputForStitchingType(StitchingType.Z_PREPROC)
 
     def _updateOutputForStitchingType(self, stitching_type):
-        self.__stitching_type = StitchingType.from_value(stitching_type)
+        self.__stitching_type = StitchingType(stitching_type)
         self._preProcOutput.setVisible(self.__stitching_type is StitchingType.Z_PREPROC)
         self._postProcOutput.setVisible(
             self.__stitching_type is StitchingType.Z_POSTPROC

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/stitching/config/stitchingstrategies.py

@@ -51,8 +51,8 @@ class StitchingStrategies(qt.QWidget, _SingleAxisMixIn):
         super().__init__(parent)
         self.setLayout(qt.QFormLayout())
         self._stitchingStrategyCG = QComboBox(parent=self)
-        for strategy in OverlapStitchingStrategy.values():
-            self._stitchingStrategyCG.addItem(strategy)
+        for strategy in OverlapStitchingStrategy:
+            self._stitchingStrategyCG.addItem(strategy.value)
         self._stitchingStrategyCG.setToolTip(
             "stitcher behavior is also know as stitching strategy. It define the behavior to have on overlaping areas"
         )
@@ -76,12 +76,10 @@ class StitchingStrategies(qt.QWidget, _SingleAxisMixIn):
         self.sigChanged.emit()
 
     def getStitchingStrategy(self) -> OverlapStitchingStrategy:
-        return OverlapStitchingStrategy.from_value(
-            self._stitchingStrategyCG.currentText()
-        )
+        return OverlapStitchingStrategy(self._stitchingStrategyCG.currentText())
 
     def setStitchingStrategy(self, strategy: OverlapStitchingStrategy | str):
-        strategy = OverlapStitchingStrategy.from_value(strategy)
+        strategy = OverlapStitchingStrategy(strategy)
         idx = self._stitchingStrategyCG.findText(strategy.value)
         if idx >= 0:
             self._stitchingStrategyCG.setCurrentIndex(idx)