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

tomwer/gui/edit/tests/test_nx_editor.py

@@ -1,13 +1,13 @@
+from __future__ import annotations
+
 import os
 import h5py
 
 import numpy
 import pytest
+import pint
 from silx.gui import qt
 
-from pyunitsystem.energysystem import EnergySI
-from pyunitsystem.metricsystem import MetricSystem
-
 from nxtomo.application.nxtomo import NXtomo
 from nxtomo.nxobject.nxdetector import ImageKey, FOV
 from nxtomo.utils.transformation import (
@@ -22,41 +22,63 @@ from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.edit.nxtomoeditor import NXtomoEditor, _TranslationMetricEntry
 from tomwer.tests.conftest import qtapp  # noqa F401
 
+_ureg = pint.get_application_registry()
 
-@pytest.mark.parametrize("x_pixel_size", (None, 0.12))
-@pytest.mark.parametrize("y_pixel_size", (None, 0.0065))
+
+@pytest.mark.parametrize("detector_x_pixel_size", (0.12 * _ureg.millimeter,))
+@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("distance", (None, 1.2))
-@pytest.mark.parametrize("energy", (None, 23.5))
-@pytest.mark.parametrize("x_flipped", (True, False))
+@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,))
+@pytest.mark.parametrize("energy", (None, 23.5 * _ureg.keV))
+@pytest.mark.parametrize("x_flipped", (False,))
 @pytest.mark.parametrize("y_flipped", (True, False))
-@pytest.mark.parametrize("x_translation", (None, numpy.ones(12), numpy.arange(12)))
-@pytest.mark.parametrize("z_translation", (None, numpy.zeros(12), numpy.arange(12, 24)))
+@pytest.mark.parametrize(
+    "x_translation",
+    (None, numpy.ones(12) * _ureg.meter, numpy.arange(12) * _ureg.meter),
+)
+@pytest.mark.parametrize(
+    "z_translation",
+    (None, numpy.zeros(12) * _ureg.meter, numpy.arange(12, 24) * _ureg.meter),
+)
 def test_nx_editor(
     tmp_path,
     qtapp,  # noqa F811
-    x_pixel_size,
-    y_pixel_size,
+    detector_x_pixel_size: pint.Quantity | None,
+    detector_y_pixel_size: pint.Quantity | None,
+    sample_x_pixel_size: pint.Quantity | None,
+    sample_y_pixel_size: pint.Quantity | None,
+    propagation_distance: pint.Quantity | None,
+    sample_source_distance: pint.Quantity | None,
     field_of_view,
-    distance,
-    energy,
+    sample_detector_distance: pint.Quantity,
+    energy: pint.Quantity,
     x_flipped,
     y_flipped,
-    x_translation,
-    z_translation,
+    x_translation: pint.Quantity,
+    z_translation: pint.Quantity,
 ):
     # 1.0 create nx tomo with raw data
     nx_tomo = NXtomo()
-    nx_tomo.instrument.detector.x_pixel_size = x_pixel_size
-    nx_tomo.instrument.detector.y_pixel_size = y_pixel_size
-    nx_tomo.instrument.detector.field_of_view = field_of_view
-    nx_tomo.instrument.detector.distance = distance
     nx_tomo.energy = energy
-    nx_tomo.sample.x_translation = x_translation
-    nx_tomo.sample.z_translation = z_translation
+    nx_tomo.instrument.detector.x_pixel_size = detector_x_pixel_size
+    nx_tomo.instrument.detector.y_pixel_size = detector_y_pixel_size
+    nx_tomo.instrument.detector.field_of_view = field_of_view
+    nx_tomo.instrument.detector.distance = sample_detector_distance
     nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
-    nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+
+    nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12) * _ureg.degree
+    nx_tomo.sample.x_translation = x_translation
+    nx_tomo.sample.z_translation = z_translation
+    nx_tomo.sample.x_pixel_size = sample_x_pixel_size
+    nx_tomo.sample.y_pixel_size = sample_y_pixel_size
+    nx_tomo.sample.propagation_distance = propagation_distance
+
+    nx_tomo.instrument.source.distance = sample_source_distance
 
     nx_tomo.instrument.detector.transformations.add_transformation(
         DetZFlipTransformation(flip=x_flipped)
@@ -82,16 +104,32 @@ def test_nx_editor(
     def check_metric(expected_value, current_value):
         if expected_value is None:
             return current_value is None
-        return numpy.isclose(expected_value, float(current_value))
-
-    assert check_metric(x_pixel_size, widget._xPixelSizeMetricEntry.getValue())
-    assert widget._xPixelSizeMetricEntry._qcbUnit.currentText() == "m"
-    assert check_metric(y_pixel_size, widget._yPixelSizeMetricEntry.getValue())
-    assert widget._yPixelSizeMetricEntry._qcbUnit.currentText() == "m"
-
-    assert check_metric(distance, widget._distanceMetricEntry.getValue())
-    assert widget._distanceMetricEntry._qcbUnit.currentText() == "m"
+        return numpy.isclose(expected_value, current_value)
 
+    assert check_metric(
+        detector_x_pixel_size, widget._xDetectorPixelSizeMetricEntry.getValue()
+    )
+    assert widget._xDetectorPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        detector_y_pixel_size, widget._yDetectorPixelSizeMetricEntry.getValue()
+    )
+    assert widget._yDetectorPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        sample_detector_distance, widget._sampleDetectorDistanceMetricEntry.getValue()
+    )
+    assert widget._sampleDetectorDistanceMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        sample_x_pixel_size, widget._xSamplePixelSizeMetricEntry.getValue()
+    )
+    assert check_metric(
+        sample_y_pixel_size, widget._ySamplePixelSizeMetricEntry.getValue()
+    )
+    assert check_metric(
+        sample_source_distance, widget._sampleSourceDistanceMetricEntry.getValue()
+    )
+    assert check_metric(
+        propagation_distance, widget._propagationDistanceMetricEntry.getValue()
+    )
     assert field_of_view == widget._fieldOfViewCB.currentText()
     assert x_flipped == widget._xFlippedCB.isChecked()
     assert y_flipped == widget._yFlippedCB.isChecked()
@@ -99,12 +137,18 @@ def test_nx_editor(
     if energy is None:
         assert widget._energyEntry.getValue() is None
     else:
-        assert numpy.isclose(energy, widget._energyEntry.getValue())
+        assert numpy.isclose(
+            energy.to(_ureg.keV).magnitude, widget._energyEntry.getValue()
+        )
 
     def check_translation(expected_value, current_value):
         if expected_value is None:
             return current_value is None
         else:
+            expected_value = expected_value.to_base_units().magnitude
+            assert current_value is not None
+            if isinstance(current_value, pint.Quantity):
+                current_value = current_value.to_base_units().magnitude
             u_values = numpy.unique(expected_value)
             if u_values.size == 1:
                 return float(current_value) == u_values[0]
@@ -118,15 +162,18 @@ def test_nx_editor(
 
     # 4.0 edit some parameters
     widget._energyEntry.setText("23.789")
-    widget._xPixelSizeMetricEntry.setUnit("nm")
-    widget._yPixelSizeMetricEntry.setValue(2.1e-7)
-    widget._distanceMetricEntry.setValue("unknown")
+    widget._xDetectorPixelSizeMetricEntry.setUnit(_ureg.nanometer)
+    widget._yDetectorPixelSizeMetricEntry.setValue(2.1e-7)
+    widget._xSamplePixelSizeMetricEntry.setValue(value_m=5.6e-6)
+    widget._sampleDetectorDistanceMetricEntry.setValue("unknown")
+    widget._sampleSourceDistanceMetricEntry.setValue(-99)
+    widget._propagationDistanceMetricEntry.setValue(88)
     widget._fieldOfViewCB.setCurrentText(FOV.HALF.value)
     widget._xFlippedCB.setChecked(not x_flipped)
     widget._xTranslationQLE.setValue(1.8)
-    widget._xTranslationQLE.setUnit("mm")
+    widget._xTranslationQLE.setUnit(_ureg.millimeter)
     widget._zTranslationQLE.setValue(2.8)
-    widget._zTranslationQLE.setUnit("m")
+    widget._zTranslationQLE.setUnit(_ureg.meter)
 
     # 5.0
     task = NXtomoEditorTask(
@@ -143,19 +190,18 @@ def test_nx_editor(
         data_path=entry,
     )
 
-    assert overwrite_nx_tomo.energy.value == 23.789
-    assert overwrite_nx_tomo.energy.unit == EnergySI.KILOELECTRONVOLT
+    assert overwrite_nx_tomo.energy == 23.789 * _ureg.keV
 
-    if x_pixel_size is None:
-        assert overwrite_nx_tomo.instrument.detector.x_pixel_size.value is None
+    if detector_x_pixel_size is None:
+        assert overwrite_nx_tomo.instrument.detector.x_pixel_size is None
     else:
         assert numpy.isclose(
-            overwrite_nx_tomo.instrument.detector.x_pixel_size.si_value,
-            x_pixel_size * MetricSystem.NANOMETER.value,
+            overwrite_nx_tomo.instrument.detector.x_pixel_size,
+            0.12 * _ureg.nanometer,
         )
-    assert overwrite_nx_tomo.instrument.detector.y_pixel_size.si_value == 2.1e-7
+    assert overwrite_nx_tomo.instrument.detector.y_pixel_size == 2.1e-7 * _ureg.meter
 
-    assert overwrite_nx_tomo.instrument.detector.distance.value is None
+    assert overwrite_nx_tomo.instrument.detector.distance is None
     assert overwrite_nx_tomo.instrument.detector.field_of_view is FOV.HALF
 
     final_transformation = NXtransformations()
@@ -172,15 +218,13 @@ def test_nx_editor(
     )
 
     numpy.testing.assert_array_almost_equal(
-        overwrite_nx_tomo.sample.x_translation.si_value,
-        numpy.array([1.8 * MetricSystem.MILLIMETER.value] * 12),
+        overwrite_nx_tomo.sample.x_translation,
+        (numpy.array([1.8] * 12) * _ureg.millimeter).to_base_units(),
     )
-    assert overwrite_nx_tomo.sample.x_translation.unit is MetricSystem.METER
     numpy.testing.assert_array_almost_equal(
-        overwrite_nx_tomo.sample.z_translation.si_value,
-        numpy.array([2.8 * MetricSystem.METER.value] * 12),
+        overwrite_nx_tomo.sample.z_translation,
+        numpy.array([2.8] * 12) * _ureg.meter,
     )
-    assert overwrite_nx_tomo.sample.z_translation.unit is MetricSystem.METER
     # end
     widget.setAttribute(qt.Qt.WA_DeleteOnClose)
     widget.close()
@@ -194,16 +238,20 @@ def test_nx_editor_lock(
     """test the pad lock buttons of the NXtomo editor"""
     # 1.0 create nx tomos with raw data
     nx_tomo_1 = NXtomo()
-    nx_tomo_1.instrument.detector.x_pixel_size = 0.023
-    nx_tomo_1.instrument.detector.y_pixel_size = 0.025
+    nx_tomo_1.instrument.source.distance = 54.8 * _ureg.meter
+    nx_tomo_1.instrument.detector.x_pixel_size = 0.023 * _ureg.meter
+    nx_tomo_1.instrument.detector.y_pixel_size = 0.025 * _ureg.meter
     nx_tomo_1.instrument.detector.field_of_view = "full"
-    nx_tomo_1.instrument.detector.distance = 2.4
+    nx_tomo_1.instrument.detector.distance = 2.4 * _ureg.meter
     nx_tomo_1.instrument.detector.x_flipped = False
     nx_tomo_1.instrument.detector.y_flipped = True
-    nx_tomo_1.energy = 5.9
+    nx_tomo_1.energy = 5.9 * _ureg.keV
     nx_tomo_1.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo_1.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
-    nx_tomo_1.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+    nx_tomo_1.sample.rotation_angle = numpy.linspace(0, 20, num=12) * _ureg.degree
+    nx_tomo_1.sample.propagation_distance = 22.0 * _ureg.meter
+    nx_tomo_1.sample.x_pixel_size = 0.023 * _ureg.millimeter
+    nx_tomo_1.sample.y_pixel_size = 0.025 * _ureg.millimeter
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0000"
@@ -215,20 +263,21 @@ def test_nx_editor_lock(
     scan_1 = NXtomoScan(file_path, entry)
 
     nx_tomo_2 = NXtomo()
-    nx_tomo_2.instrument.detector.x_pixel_size = 4.023
-    nx_tomo_2.instrument.detector.y_pixel_size = 6.025
+    nx_tomo_2.instrument.source.distance = 8 * _ureg.meter
+    nx_tomo_2.instrument.detector.x_pixel_size = 4.023 * _ureg.meter
+    nx_tomo_2.instrument.detector.y_pixel_size = 6.025 * _ureg.meter
     nx_tomo_2.instrument.detector.field_of_view = "full"
-    nx_tomo_2.instrument.detector.distance = 2.89
+    nx_tomo_2.instrument.detector.distance = 2.89 * _ureg.meter
     nx_tomo_2.instrument.detector.x_flipped = (
         not nx_tomo_1.instrument.detector.x_flipped
     )
     nx_tomo_2.instrument.detector.y_flipped = (
         not nx_tomo_1.instrument.detector.y_flipped
     )
-    nx_tomo_2.energy = 5.754
+    nx_tomo_2.energy = 5.754 * _ureg.keV
     nx_tomo_2.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo_2.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
-    nx_tomo_2.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+    nx_tomo_2.sample.rotation_angle = numpy.linspace(0, 20, num=12) * _ureg.degree
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0001"
@@ -249,12 +298,16 @@ def test_nx_editor_lock(
     widget.setScan(scan=scan_2)
     # widget values must be the same (NXtomo field value not loaded if the lockers are active)
     assert widget._energyEntry.getValue() == 5.9
-    assert widget._xPixelSizeMetricEntry.getValue() == 0.023
-    assert widget._yPixelSizeMetricEntry.getValue() == 0.025
-    assert widget._distanceMetricEntry.getValue() == 2.4
+    assert widget._xDetectorPixelSizeMetricEntry.getValue() == 0.023 * _ureg.meter
+    assert widget._yDetectorPixelSizeMetricEntry.getValue() == 0.025 * _ureg.meter
+    assert widget._sampleDetectorDistanceMetricEntry.getValue() == 2.4 * _ureg.meter
+    assert widget._propagationDistanceMetricEntry.getValue() == 22.0 * _ureg.meter
     assert widget._fieldOfViewCB.currentText() == "Full"
     assert not widget._xFlippedCB.isChecked()
     assert widget._yFlippedCB.isChecked()
+    assert widget._xSamplePixelSizeMetricEntry.getValue() == 0.023 * _ureg.millimeter
+    assert widget._ySamplePixelSizeMetricEntry.getValue() == 0.025 * _ureg.millimeter
+    assert widget._sampleSourceDistanceMetricEntry.getValue() == 54.8 * _ureg.meter
 
     # 3.0 save the nxtomo
     task = NXtomoEditorTask(
@@ -271,20 +324,20 @@ def test_nx_editor_lock(
         data_path=entry,
     )
     assert (
-        overwrite_nx_tomo.instrument.detector.x_pixel_size.value
-        == nx_tomo_1.instrument.detector.x_pixel_size.value
+        overwrite_nx_tomo.instrument.detector.x_pixel_size
+        == nx_tomo_1.instrument.detector.x_pixel_size
     )
     assert (
-        overwrite_nx_tomo.instrument.detector.y_pixel_size.value
-        == nx_tomo_1.instrument.detector.y_pixel_size.value
+        overwrite_nx_tomo.instrument.detector.y_pixel_size
+        == nx_tomo_1.instrument.detector.y_pixel_size
     )
     assert (
         overwrite_nx_tomo.instrument.detector.field_of_view
         == nx_tomo_1.instrument.detector.field_of_view
     )
     assert (
-        overwrite_nx_tomo.instrument.detector.distance.value
-        == nx_tomo_1.instrument.detector.distance.value
+        overwrite_nx_tomo.instrument.detector.distance
+        == nx_tomo_1.instrument.detector.distance
     )
     assert (
         overwrite_nx_tomo.instrument.detector.x_flipped
@@ -294,8 +347,17 @@ def test_nx_editor_lock(
         overwrite_nx_tomo.instrument.detector.y_flipped
         == nx_tomo_1.instrument.detector.y_flipped
     )
-    assert overwrite_nx_tomo.energy.value == nx_tomo_1.energy.value
-
+    assert overwrite_nx_tomo.energy == nx_tomo_1.energy
+    assert (
+        overwrite_nx_tomo.sample.propagation_distance
+        == nx_tomo_1.sample.propagation_distance
+    )
+    assert overwrite_nx_tomo.sample.x_pixel_size == nx_tomo_1.sample.x_pixel_size
+    assert overwrite_nx_tomo.sample.y_pixel_size == nx_tomo_1.sample.y_pixel_size
+    assert (
+        overwrite_nx_tomo.instrument.source.distance
+        == nx_tomo_1.instrument.source.distance
+    )
     assert widget.getConfiguration() == {
         "instrument.beam.energy": (5.9, True),
         "instrument.detector.distance": (2.4, True),
@@ -304,6 +366,10 @@ def test_nx_editor_lock(
         "instrument.detector.y_pixel_size": (0.025, True),
         "instrument.detector.x_flipped": (False, True),
         "instrument.detector.y_flipped": (True, True),
+        "instrument.source.distance": (54.8, True),
+        "sample.propagation_distance": (22.0, True),
+        "sample.x_pixel_size": (2.3e-5, True),
+        "sample.y_pixel_size": (2.5e-5, True),
         "sample.x_translation": (None,),
         "sample.z_translation": (None,),
     }
@@ -319,6 +385,12 @@ def test_nx_editor_lock(
         "instrument.detector.y_pixel_size": (0.025, False),
         "instrument.detector.x_flipped": (False, False),
         "instrument.detector.y_flipped": (True, False),
+        "instrument.source.distance": (54.8, False),
+        "sample.x_translation": (None,),
+        "sample.z_translation": (None,),
+        "sample.propagation_distance": (22.0, False),
+        "sample.x_pixel_size": (2.3e-5, False),
+        "sample.y_pixel_size": (2.5e-5, False),
         "sample.x_translation": (None,),
         "sample.z_translation": (None,),
     }
@@ -336,7 +408,7 @@ def test_nxtomo_editor_with_missing_paths(
     nx_tomo = NXtomo()
     nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
-    nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+    nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12) * _ureg.degree
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0000"
@@ -361,10 +433,10 @@ def test_nxtomo_editor_with_missing_paths(
 
     widget.setScan(scan=scan)
 
-    widget._distanceMetricEntry.setValue(0.05)
-    widget._energyEntry.setValue(50)
-    widget._xPixelSizeMetricEntry.setValue(0.02)
-    widget._yPixelSizeMetricEntry.setValue(0.03)
+    widget._sampleDetectorDistanceMetricEntry.setValue(0.05)
+    widget._energyEntry.setValue(50.0)
+    widget._xDetectorPixelSizeMetricEntry.setValue(0.02)
+    widget._yDetectorPixelSizeMetricEntry.setValue(0.03)
 
     # overwrite the NXtomo
     task = NXtomoEditorTask(
@@ -380,7 +452,7 @@ def test_nxtomo_editor_with_missing_paths(
         file_path=file_path,
         data_path=entry,
     )
-    assert overwrite_nx_tomo.instrument.detector.x_pixel_size.value == 0.02
-    assert overwrite_nx_tomo.instrument.detector.y_pixel_size.value == 0.03
-    assert overwrite_nx_tomo.energy.value == 50
-    assert overwrite_nx_tomo.instrument.detector.distance.value == 0.05
+    assert overwrite_nx_tomo.instrument.detector.x_pixel_size == 0.02 * _ureg.meter
+    assert overwrite_nx_tomo.instrument.detector.y_pixel_size == 0.03 * _ureg.meter
+    assert overwrite_nx_tomo.energy == 50 * _ureg.keV
+    assert overwrite_nx_tomo.instrument.detector.distance == 0.05 * _ureg.meter

tomwer/gui/reconstruction/axis/CalculationWidget.py

@@ -212,5 +212,5 @@ class CalculationWidget(qt.QWidget):
             self.setMode(self._axis_params.mode)
 
     def setScan(self, scan: TomwerScanBase | None):
-        self._estimatedCorWidget.setPixelSize(pixel_size_m=scan.x_pixel_size)
+        self._estimatedCorWidget.setPixelSize(pixel_size_m=scan.sample_x_pixel_size)
         self._estimatedCorWidget.setImageWidth(image_width=scan.dim_1)

tomwer/gui/reconstruction/axis/EstimatedCORWidget.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import pint
 from silx.gui import qt
 from processview.gui.DropDownWidget import DropDownWidget
 from tomwer.synctools.axis import QAxisRP
@@ -10,7 +11,8 @@ from tomwer.core.process.reconstruction.axis.side import Side
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.gui.fonts import FONT_SMALL
 from tomwer.gui.utils.scrollarea import QDoubleSpinBoxIgnoreWheel
-from pyunitsystem.metricsystem import MetricSystem
+
+_ureg = pint.get_application_registry()
 
 
 class EstimatedCORWidget(qt.QGroupBox):
@@ -345,19 +347,19 @@ class _OffsetCalibration(qt.QGroupBox):
     def _motorOffsetChanged(self):
         """Recalculate the offset when the motor offset changes."""
         if self._pixelSizeSB.value() and self._motorOffsetSB.value():
-            pixel_size_m = self._pixelSizeSB.value() * MetricSystem.MICROMETER.value
-            motor_offset_m = self._motorOffsetSB.value() * MetricSystem.MILLIMETER.value
+            pixel_size = self._pixelSizeSB.value() * _ureg.micrometer
+            motor_offset = self._motorOffsetSB.value() * _ureg.millimeter
             with block_signals(self):
-                self.setOffset(motor_offset_m / pixel_size_m)
+                self.setOffset((motor_offset / pixel_size).to_base_units().magnitude)
             self.sigOffsetChanged.emit()
 
     def _pixelSizeChanged(self):
         """Recalculate the offset when the pixel size changes."""
         if self._pixelSizeSB.value() and self._motorOffsetSB.value():
-            pixel_size_m = self._pixelSizeSB.value() * MetricSystem.MICROMETER.value
-            motor_offset_m = self._motorOffsetSB.value() * MetricSystem.MILLIMETER.value
+            pixel_size = self._pixelSizeSB.value() * _ureg.micrometer
+            motor_offset = self._motorOffsetSB.value() * _ureg.millimeter
             with block_signals(self):
-                self.setOffset(motor_offset_m / pixel_size_m)
+                self.setOffset((motor_offset / pixel_size).to_base_units().magnitude)
             self.sigOffsetChanged.emit()
 
     def _xRotationAxisPixelPositionEdited(self):
@@ -387,7 +389,9 @@ class _OffsetCalibration(qt.QGroupBox):
         if pixel_size_m is None:
             self._pixelSizeSB.clear()
         else:
-            self._pixelSizeSB.setValue(pixel_size_m / MetricSystem.MICROMETER.value)
+            self._pixelSizeSB.setValue(
+                (pixel_size_m * _ureg.meter).to(_ureg.micrometer).magnitude
+            )
 
     def _togglePixelSizeLock(self, locked: bool):
         """Lock or unlock the pixel size spin box."""

tomwer/gui/reconstruction/darkref/darkrefwidget.py

@@ -125,7 +125,7 @@ class _WhatCheckBox(qt.QWidget):
 
     def getMode(self) -> dkrf.ReduceMethod:
         if self._checkbox.isChecked():
-            return dkrf.ReduceMethod.from_value(self._modeCB.currentText())
+            return dkrf.ReduceMethod(self._modeCB.currentText())
         else:
             return dkrf.ReduceMethod.NONE
 
@@ -136,7 +136,7 @@ class _WhatCheckBox(qt.QWidget):
         self.sigChanged.emit(self.getMode())
 
     def setMode(self, mode):
-        mode = dkrf.ReduceMethod.from_value(mode)
+        mode = dkrf.ReduceMethod(mode)
         assert mode in dkrf.ReduceMethod
         self._checkbox.toggled.disconnect(self._modeChange)
         self._modeCB.currentIndexChanged.disconnect(self._modeChange)

tomwer/gui/reconstruction/nabu/castvolume.py

@@ -130,7 +130,11 @@ class CastVolumeWidget(qt.QWidget):
         # overwrite
         self._overwriteCB = qt.QCheckBox("overwrite", self)
         self._overwriteCB.setChecked(True)
-        self.layout().addWidget(self._overwriteCB, 16, 0, 1, 1)
+        self.layout().addWidget(self._overwriteCB, 16, 0, 1, 2)
+        # remove input volume
+        self._removeInputvolumeCB = qt.QCheckBox("remove input volume", self)
+        self._removeInputvolumeCB.setChecked(False)
+        self.layout().addWidget(self._removeInputvolumeCB, 17, 0, 1, 2)
         # spacer
         self._spacer = qt.QWidget(self)
         self._spacer.setSizePolicy(
@@ -156,6 +160,7 @@ class CastVolumeWidget(qt.QWidget):
         self._maxPixValue.textChanged.connect(self._configChanged)
         self._lowPercentileQSB.valueChanged.connect(self._configChanged)
         self._highPercentileQSB.valueChanged.connect(self._configChanged)
+        self._removeInputvolumeCB.toggled.connect(self._configChanged)
 
     def _updateCRatiosVis(self, *args, **kwargs):
         self._cRatiosLabel.setVisible(
@@ -200,6 +205,12 @@ class CastVolumeWidget(qt.QWidget):
     def setOverwrite(self, remove) -> None:
         self._overwriteCB.setChecked(remove)
 
+    def isRemoveInputVolume(self) -> bool:
+        return self._removeInputvolumeCB.isChecked()
+
+    def setRemoveInputVolume(self, remove: bool) -> None:
+        self._removeInputvolumeCB.setChecked(remove)
+
     def getDataMin(self) -> float | None:
         if (
             self._minMaxAuto.isChecked()
@@ -281,6 +292,7 @@ class CastVolumeWidget(qt.QWidget):
             "data_min": data_min,
             "data_max": data_max,
             "compression_ratios": self.getCompressionRatios(),
+            "remove_input_volume": self.isRemoveInputVolume(),
         }
 
     def setConfiguration(self, config: dict) -> None:
@@ -306,6 +318,9 @@ class CastVolumeWidget(qt.QWidget):
             self.setDataMax(config["data_max"])
         if "compression_ratios" in config:
             self.setCompressionRatios(config["compression_ratios"])
+        remove_input_volume = config.get("remove_input_volume", None)
+        if remove_input_volume is not None:
+            self.setRemoveInputVolume(remove=remove_input_volume)
 
     def _configChanged(self, *args, **kwargs):
         self.sigConfigChanged.emit()

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

@@ -38,7 +38,7 @@ class _NabuStageConfigBase:
         if stage is None:
             self.__stage = None
         else:
-            self.__stage = _NabuStages.from_value(stage)
+            self.__stage = _NabuStages(stage)
         self._registeredWidgets = {}
         # list required widgets. Key is widget, value is the configuration
         # level

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

@@ -135,7 +135,7 @@ class NabuConfiguration(qt.QWidget):
             ):
                 widget.setVisible(True)
         else:
-            stage = _NabuStages.from_value(stage)
+            stage = _NabuStages(stage)
             self._preProcessingGB.setVisible(stage is _NabuStages.PRE)
             self._reconstructionGB.setVisible(stage is _NabuStages.PROC)
             self._outputGB.setVisible(stage is _NabuStages.POST)

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

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

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)