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

tomwer/gui/utils/unitsystem.py

@@ -9,14 +9,14 @@ from __future__ import annotations
 
 
 import logging
+import pint
 
 from silx.gui import qt
-from pyunitsystem.metricsystem import MetricSystem
-
-from tomwer.core.utils.char import MU_CHAR
 
 _logger = logging.getLogger(__name__)
 
+_ureg = pint.get_application_registry()
+
 
 class PixelEntry(qt.QWidget):
     valueChanged = qt.Signal()
@@ -69,6 +69,17 @@ class MetricEntry(qt.QWidget):
     editingFinished = qt.Signal()
     """emit when editing is finished"""
 
+    valueChanged = qt.Signal()
+    """emit when the metric value change"""
+
+    _ExposedUnits: set[_ureg.Unit] = {
+        _ureg.nanometer,
+        _ureg.micrometer,
+        _ureg.mm,
+        _ureg.cm,
+        _ureg.m,
+    }
+
     class DoubleValidator(qt.QDoubleValidator):
         def __init__(self, *args, **kwargs):
             super().__init__(*args, **kwargs)
@@ -80,22 +91,15 @@ class MetricEntry(qt.QWidget):
             else:
                 return super().validate(a0, a1)
 
-    _CONVERSION = {
-        "nm": MetricSystem.NANOMETER.value,
-        f"{MU_CHAR}m": MetricSystem.MICROMETER.value,
-        "mm": MetricSystem.MILLIMETER.value,
-        "cm": MetricSystem.CENTIMETER.value,
-        "m": MetricSystem.METER.value,
-    }
-
-    valueChanged = qt.Signal()
-    """emit when the metric value change"""
-
-    def __init__(self, name, value=0.0, default_unit="m", parent=None):
+    def __init__(
+        self, name, value=0.0, default_unit: pint.Unit = _ureg.meter, parent=None
+    ):
         qt.QWidget.__init__(self, parent)
-        assert type(default_unit) is str
-        assert default_unit in ("nm", "mm", "cm", "m", f"{MU_CHAR}m")
-        self._base_unit = default_unit
+        if default_unit not in self._ExposedUnits:
+            raise ValueError(
+                f"Unable to use {default_unit} as default unit. Must be in {self._ExposedUnits}"
+            )
+        self._base_unit: pint.Unit = default_unit
 
         self.setLayout(qt.QHBoxLayout())
         self._label = qt.QLabel(name, parent=self)
@@ -105,11 +109,9 @@ class MetricEntry(qt.QWidget):
         self.layout().addWidget(self._qlePixelSize)
 
         self._qcbUnit = qt.QComboBox(parent=self)
-        self._qcbUnit.addItem("nm")
-        self._qcbUnit.addItem(f"{MU_CHAR}m")
-        self._qcbUnit.addItem("mm")
-        self._qcbUnit.addItem("cm")
-        self._qcbUnit.addItem("m")
+        for unit in self._ExposedUnits:
+            self._qcbUnit.addItem(f"{unit:~}")
+
         self.layout().addWidget(self._qcbUnit)
         self._resetBaseUnit()
 
@@ -128,10 +130,9 @@ class MetricEntry(qt.QWidget):
         self._label.setText(text)
 
     def getCurrentUnit(self):
-        assert self._qcbUnit.currentText() in self._CONVERSION
-        return self._CONVERSION[self._qcbUnit.currentText()]
+        return _ureg.Unit(self._qcbUnit.currentText())
 
-    def setValue(self, value_m, displayed_unit: str = "m"):
+    def setValue(self, value_m, displayed_unit: pint.Unit = _ureg.meter):
         """
 
         :param value: pixel size in international metric system (meter)
@@ -155,16 +156,20 @@ class MetricEntry(qt.QWidget):
         self._qlePixelSize.setText(txt)
         self._resetBaseUnit(displayed_unit=displayed_unit)
 
-    def _resetBaseUnit(self, displayed_unit=None):
+    def _resetBaseUnit(self, displayed_unit: pint.Unit | None = None):
         """Simple reset of the combobox according to the base_unit"""
+        if displayed_unit is not None and not isinstance(displayed_unit, pint.Unit):
+            raise TypeError(
+                f"'displayed_unit' should be a {pint.Unit}. Got {type(displayed_unit)}"
+            )
         displayed_unit = displayed_unit or self._base_unit
-        index = self._qcbUnit.findText(displayed_unit)
-        if index is None:
+        index = self._qcbUnit.findText(f"{displayed_unit:~}")
+        if index < 0:
             raise ValueError("unrecognized base unit")
         else:
             self._qcbUnit.setCurrentIndex(index)
 
-    def getValue(self) -> float:
+    def getValue(self) -> pint.Quantity | None:
         """
 
         :return: the value in meter
@@ -177,7 +182,13 @@ class MetricEntry(qt.QWidget):
     def setValidator(self, validator):
         self._qlePixelSize.setValidator(validator)
 
-    def setUnit(self, unit):
-        unit = str(MetricSystem.from_value(unit))
+    def setUnit(self, unit: pint.Unit):
+        assert isinstance(
+            unit, pint.Unit
+        ), f"unit is expected to be a pint.Unit. Got {type(unit)}"
+        unit = f"{unit:~}"
         idx = self._qcbUnit.findText(unit)
-        self._qcbUnit.setCurrentIndex(idx)
+        if idx >= 0:
+            self._qcbUnit.setCurrentIndex(idx)
+        else:
+            _logger.error(f"Unhandled unit ({unit})")

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/diffviewer/diffviewer.py

@@ -7,13 +7,13 @@ from __future__ import annotations
 import functools
 import logging
 import os
+from enum import Enum
 
 import numpy
 from processview.core.dataset import DatasetIdentifier
 from silx.gui import icons as silx_icons
 from silx.gui import qt
 from silx.io.url import DataUrl
-from silx.utils.enum import Enum as _Enum
 
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -55,7 +55,7 @@ class _FrameSelector(qt.QWidget):
     sigSelectedUrlChanged = qt.Signal()
     """signal emitted when the selected url changed"""
 
-    class FrameType(_Enum):
+    class FrameType(Enum):
         DARKS = "darks"
         FLATS = "flats"
         PROJ = "projections"
@@ -110,10 +110,10 @@ class _FrameSelector(qt.QWidget):
             return None
 
     def getTypeSelected(self):
-        return self.FrameType.from_value(self._frameTypeCB.currentText())
+        return self.FrameType(self._frameTypeCB.currentText())
 
     def _typeChanged(self, *args, **kwargs):
-        type_selected = self.FrameType.from_value(self.getTypeSelected())
+        type_selected = self.FrameType(self.getTypeSelected())
         self._proj_normalized.setVisible(
             type_selected in (self.FrameType.PROJ, self.FrameType.ALIGN_PROJ)
         )

tomwer/gui/visualization/diffviewer/shiftwidget.py

@@ -5,11 +5,11 @@ contains gui for diffviewer shift
 """
 from __future__ import annotations
 
+from enum import Enum
 
 import sys
 
 from silx.gui import qt
-from silx.utils.enum import Enum as _Enum
 
 from tomwer.utils import docstring
 
@@ -54,7 +54,7 @@ class TwoFramesShiftTab(qt.QTabWidget, _FrameShiftsBase):
      lrflip is a boolean notifying if we should flip image or not before applying the shift
     """
 
-    class ShiftMode(_Enum):
+    class ShiftMode(Enum):
         RELATIVE = "relative shift"
         ABSOLUTE = "absolute shift"
 
@@ -206,7 +206,7 @@ class Relative2FramesShift(qt.QWidget, _FrameShiftsBase):
         self._controlWidget.setFocus(qt.Qt.OtherFocusReason)
 
     def move(self, direction: str):
-        direction = _ControlArrowWidget.Direction.from_value(direction)
+        direction = _ControlArrowWidget.Direction(direction)
         shift = self._shiftStepSize.value()
         if direction is _ControlArrowWidget.Direction.RIGHT:
             self._xShiftQLE.setValue(self._xShiftQLE.value() + shift)
@@ -290,14 +290,12 @@ class _ControlArrowWidget(qt.QWidget):
     sigMoved = qt.Signal(str)
     """signal emit when one direction is activated. Will contain the direction in which we want to move"""
 
-    class Direction(_Enum):
+    class Direction(Enum):
         LEFT = "left"
         RIGHT = "right"
         UP = "up"
         DOWN = "down"
 
-    VALID_DIRECTIONS = Direction.members()
-
     ARROW_BUTTON_SIZE = 30
 
     QKEY_TO_DIR = {

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 = (

tomwer/gui/visualization/scanoverview.py

@@ -47,10 +47,10 @@ class ScanOverviewWidget(qt.QWidget):
         self._estimatedCOR = qt.QTreeWidgetItem(self._frames)
         self._estimatedCOR.setText(0, "estimated cor")
 
-        self._x_pixel_size = qt.QTreeWidgetItem(self._instrument)
-        self._x_pixel_size.setText(0, "x pixel size")
-        self._y_pixel_size = qt.QTreeWidgetItem(self._instrument)
-        self._y_pixel_size.setText(0, "y pixel size")
+        self._detector_x_pixel_size = qt.QTreeWidgetItem(self._instrument)
+        self._detector_x_pixel_size.setText(0, "x pixel size")
+        self._detector_y_pixel_size = qt.QTreeWidgetItem(self._instrument)
+        self._detector_y_pixel_size.setText(0, "y pixel size")
 
         # 2: define sample
         self._sample = qt.QTreeWidgetItem(self._tree)
@@ -58,6 +58,11 @@ class ScanOverviewWidget(qt.QWidget):
         self._sample_name = qt.QTreeWidgetItem(self._sample)
         self._sample_name.setText(0, "name")
 
+        self._sample_x_pixel_size = qt.QTreeWidgetItem(self._sample)
+        self._sample_x_pixel_size.setText(0, "x pixel size")
+        self._sample_y_pixel_size = qt.QTreeWidgetItem(self._sample)
+        self._sample_y_pixel_size.setText(0, "y pixel size")
+
         # 3: other hight level items
         self._startTime = qt.QTreeWidgetItem(self._tree)
         self._startTime.setText(0, "start_time")
@@ -96,6 +101,7 @@ class ScanOverviewWidget(qt.QWidget):
             "times": self._updateTimes,
             "names": self._updateNames,
             "scan-range": self._updateScanRange,
+            "sample": self._updateSample,
         }
         for part_name, fct in parts.items():
             try:
@@ -107,7 +113,7 @@ class ScanOverviewWidget(qt.QWidget):
     def _updateInstrument(self, scan: TomwerScanBase):
         self._updateFrames(scan=scan)
         self._updateEnergy(scan=scan)
-        self._updatePixelSize(scan=scan)
+        self._updateDetectorPixelSize(scan=scan)
 
     def _setColoredTxt(
         self, item, text, column=1, hightlight_red=False, hightlight_orange=False
@@ -125,7 +131,18 @@ class ScanOverviewWidget(qt.QWidget):
         item.setBackground(0, qt.QBrush(bkg_color))
 
     def _updateSample(self, scan: TomwerScanBase):
-        pass
+        x_pixel_size = scan.sample_x_pixel_size
+        y_pixel_size = scan.sample_y_pixel_size
+        self._setColoredTxt(
+            item=self._sample_x_pixel_size,
+            text=f"{x_pixel_size} (m)",
+            hightlight_red=x_pixel_size in (None, 0.0, 1.0),
+        )
+        self._setColoredTxt(
+            item=self._sample_y_pixel_size,
+            text=f"{y_pixel_size} (m)",
+            hightlight_red=y_pixel_size in (None, 0.0, 1.0),
+        )
 
     def _updateTimes(self, scan: TomwerScanBase):
         self._startTime.setText(1, str(scan.start_time))
@@ -213,20 +230,20 @@ class ScanOverviewWidget(qt.QWidget):
             text=str(scan_range),
         )
 
-    def _updatePixelSize(self, scan: TomwerScanBase):
+    def _updateDetectorPixelSize(self, scan: TomwerScanBase):
         assert isinstance(scan, TomwerScanBase)
         if isinstance(scan, EDFTomoScan):
             x_pixel_size = y_pixel_size = scan.pixel_size
         else:
-            x_pixel_size = scan.x_pixel_size
-            y_pixel_size = scan.y_pixel_size
+            x_pixel_size = scan.detector_x_pixel_size
+            y_pixel_size = scan.detector_y_pixel_size
         self._setColoredTxt(
-            item=self._x_pixel_size,
+            item=self._detector_x_pixel_size,
             text=f"{x_pixel_size} (m)",
             hightlight_red=x_pixel_size in (None, 0.0, 1.0),
         )
         self._setColoredTxt(
-            item=self._y_pixel_size,
+            item=self._detector_y_pixel_size,
             text=f"{y_pixel_size} (m)",
             hightlight_red=y_pixel_size in (None, 0.0, 1.0),
         )

tomwer/gui/visualization/test/test_nx_tomo_metadata_viewer.py

@@ -1,6 +1,7 @@
 import os
 
 import numpy
+import pint
 from nxtomo.application.nxtomo import NXtomo
 from silx.gui import qt
 from nxtomo.nxobject.nxdetector import ImageKey
@@ -9,6 +10,8 @@ from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.visualization.nxtomometadata import NXtomoMetadataViewer
 from tomwer.tests.conftest import qtapp  # noqa F401
 
+_ureg = pint.get_application_registry()
+
 
 def test_nx_editor(
     tmp_path,
@@ -16,18 +19,18 @@ def test_nx_editor(
 ):
     # 1.0 create nx tomo with raw data
     nx_tomo = NXtomo()
-    nx_tomo.instrument.detector.x_pixel_size = 2.6e-6
-    nx_tomo.instrument.detector.y_pixel_size = 2.5e-6
+    nx_tomo.instrument.detector.x_pixel_size = 2.6e-6 * _ureg.meter
+    nx_tomo.instrument.detector.y_pixel_size = 2.5e-6 * _ureg.meter
     nx_tomo.instrument.detector.field_of_view = "Half"
-    nx_tomo.instrument.detector.distance = 59.0
+    nx_tomo.instrument.detector.distance = 59.0 * _ureg.meter
     nx_tomo.instrument.detector.x_flipped = True
     nx_tomo.instrument.detector.y_flipped = False
-    nx_tomo.energy = 12.8
-    nx_tomo.sample.x_translation = numpy.arange(12)
-    nx_tomo.sample.z_translation = numpy.arange(2, 14)
+    nx_tomo.energy = 12.8 * _ureg.keV
+    nx_tomo.sample.x_translation = numpy.arange(12) * _ureg.meter
+    nx_tomo.sample.z_translation = numpy.arange(2, 14) * _ureg.meter
     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, 180, num=12)
+    nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=12) * _ureg.degree
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0000"
@@ -49,13 +52,22 @@ def test_nx_editor(
             return current_value is None
         return expected_value == current_value
 
-    assert check_metric(2.6e-6, widget._xPixelSizeMetricEntry.getValue())
-    assert widget._xPixelSizeMetricEntry._qcbUnit.currentText() == "m"
-    assert check_metric(2.5e-6, widget._yPixelSizeMetricEntry.getValue())
-    assert widget._yPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        2.6e-6,
+        widget._xDetectorPixelSizeMetricEntry.getValue().to(_ureg.meter).magnitude,
+    )
+    assert widget._xDetectorPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        2.5e-6,
+        widget._yDetectorPixelSizeMetricEntry.getValue().to(_ureg.meter).magnitude,
+    )
+    assert widget._yDetectorPixelSizeMetricEntry._qcbUnit.currentText() == "m"
 
-    assert check_metric(59, widget._distanceMetricEntry.getValue())
-    assert widget._distanceMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(
+        59,
+        widget._sampleDetectorDistanceMetricEntry.getValue().to(_ureg.meter).magnitude,
+    )
+    assert widget._sampleDetectorDistanceMetricEntry._qcbUnit.currentText() == "m"
 
     assert "Half" == widget._fieldOfViewCB.currentText()
     assert widget._xFlippedCB.isChecked()

tomwer/gui/visualization/test/test_reconstruction_parameters.py

@@ -46,8 +46,8 @@ def test_ReconstructionParameters(qtapp, phase_method):  # noqa F401
     assert window._methodQLE.text() == "FBP"
     assert window._paganinQLE.text() == phase_method
     assert window._deltaBetaQLE.text() == "110.0"
-    assert window._distanceQLE.text() == "0.4"
-    assert window._pixelSizeQLE.text() == "0.2"
+    assert window._sampleDetectorDistanceQLE.text() == "0.4"
+    assert window._voxelSizeQLE.text() == "0.2x0.2x0.2"
     assert window._corQLE.text() == "104.00"
     assert window._halfTomoCB.isChecked()
     assert window._fbpFilterQLE.text() == "Hilbert"

tomwer/synctools/utils/scanstages.py

@@ -10,7 +10,7 @@ import os
 import shutil
 
 from silx.io.url import DataUrl
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.nxtomoscan import NXtomoScan
@@ -59,7 +59,7 @@ class ScanStages:
         :param stage:
         :param dest_dir:
         """
-        stage = ScanStages.AcquisitionStage.from_value(stage)
+        stage = ScanStages.AcquisitionStage(stage)
         if not dest_dir.endswith(os.path.basename(self.scan.path)):
             dest_dir = os.path.join(dest_dir, os.path.basename(self.scan.path))
         for t_stage in ScanStages.AcquisitionStage:
@@ -75,7 +75,7 @@ class ScanStages:
         """
         if not dest_dir.endswith(os.path.basename(self.scan.path)):
             dest_dir = os.path.join(dest_dir, os.path.basename(self.scan.path))
-        stage = ScanStages.AcquisitionStage.from_value(stage)
+        stage = ScanStages.AcquisitionStage(stage)
         if stage is ScanStages.AcquisitionStage.ACQUI_NOT_STARTED:
             return
         elif stage is ScanStages.AcquisitionStage.ACQUI_STARTED:

tomwer/tasks/reconstruction/cleardarkflat.py

@@ -0,0 +1,42 @@
+"""
+Contains task to clear reduced dark and flat frames
+"""
+
+from __future__ import annotations
+
+from tomoscan.scanbase import TomoScanBase as TomoscanScanBase
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+
+from tomwer.tasks.task import Task
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.reconstruction.darkflat import params as dkrf_reconsparams
+from tomwer.utils import docstring
+
+
+class ClearReducedDarkAndFlat(
+    Task,
+    SuperviseProcess,
+    input_names=("data",),
+    output_names=("data",),
+):
+    """
+    Task to clear reduced darks and flats. Both on disk and on the object cache.
+    th goal of this task is to make sure the scan is cleared of any reduced frames to reprocess it later.
+    """
+
+    def run(self):
+        scan = self.inputs.data
+        if not isinstance(scan, TomoscanScanBase):
+            raise TypeError(
+                f"scan should be an instance of {TomoscanScanBase}. Got {type(scan)}"
+            )
+        scan.set_reduced_flats(None)
+        scan.reduced_flats_infos = None
+        scan.set_reduced_darks(None)
+        scan.reduced_darks_infos = None
+
+        self.outputs.data = scan

tomwer/tests/app/test_stitching.py

@@ -32,7 +32,7 @@ def _create_objects_for_stitching(stitching_type: StitchingType, output_dir) ->
             ]
         )
 
-    stitching_type = StitchingType.from_value(stitching_type)
+    stitching_type = StitchingType(stitching_type)
     if stitching_type is StitchingType.Y_PREPROC:
         nxtomos, positions, _ = test_y_preprocessing_stitching.build_nxtomos(
             output_dir=output_dir, flip_lr=False, flip_ud=False