tomwer 2.0.0.dev8__tar.gz → 2.0.1.dev0__tar.gz

{tomwer-2.0.0.dev8/src/tomwer.egg-info → tomwer-2.0.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tomwer
-Version: 2.0.0.dev8
+Version: 2.0.1.dev0
 Summary: Tomography workflow tools
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 License: MIT
@@ -61,12 +61,12 @@ Requires-Dist: pyicat_plus; extra == "full-base"
 Requires-Dist: blissdata; extra == "full-base"
 Provides-Extra: full-no-cuda
 Requires-Dist: tomwer[full_base]; extra == "full-no-cuda"
-Requires-Dist: nabu>=2024.2.0; extra == "full-no-cuda"
+Requires-Dist: nabu<2026.2,>=2026.1.0; extra == "full-no-cuda"
 Requires-Dist: PyQt6; extra == "full-no-cuda"
 Requires-Dist: qtawesome; extra == "full-no-cuda"
 Provides-Extra: full-no-qt
 Requires-Dist: tomwer[full_base]; extra == "full-no-qt"
-Requires-Dist: nabu[full]>=2024.2.0; extra == "full-no-qt"
+Requires-Dist: nabu[full]<2026.2,>=2026.1.0; extra == "full-no-qt"
 Requires-Dist: pycuda<2024.1.1; extra == "full-no-qt"
 Requires-Dist: scikit-cuda; extra == "full-no-qt"
 Requires-Dist: PyQt6; extra == "full-no-qt"

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/pyproject.toml

@@ -67,13 +67,13 @@ full_base = [
 ]
 full_no_cuda = [
     "tomwer[full_base]",
-    "nabu>=2024.2.0",
+    "nabu>=2026.1.0,<2026.2",
     "PyQt6",
     'qtawesome',             # For icons
 ]
 full_no_qt = [
     "tomwer[full_base]",
-    "nabu[full]>=2024.2.0",
+    "nabu[full]>=2026.1.0,<2026.2",
     "pycuda<2024.1.1",
     "scikit-cuda",
     "PyQt6",

tomwer-2.0.1.dev0/src/orangecontrib/tomwer/tutorials/darks and flats copy - method 2.ows

@@ -0,0 +1,42 @@
+<?xml version='1.0' encoding='utf-8'?>
+<scheme version="2.0" title="darks and flats copy - method 2" description="">
+	<nodes>
+		<node id="0" name="scan selector" qualified_name="orangecontrib.tomwer.widgets.control.DataSelectorOW.DataSelectorOW" project_name="tomwer" version="" title="scan selector" position="(-519.0, -209.0)" />
+		<node id="1" name="image-key-upgrader" qualified_name="orangecontrib.tomwer.widgets.edit.ImageKeyUpgraderOW.ImageKeyUpgraderOW" project_name="tomwer" version="" title="image-key-upgrader" position="(-293.0, -209.0)" />
+		<node id="2" name="scan selector" qualified_name="orangecontrib.tomwer.widgets.control.DataSelectorOW.DataSelectorOW" project_name="tomwer" version="" title="scan selector (1)" position="(291.0, -211.0)" />
+		<node id="3" name="copy reduced darks and flats" qualified_name="orangecontrib.tomwer.widgets.reconstruction.CopyReducedDarkAndFlatOW.CopyReducedDarkAndFlatOW" project_name="tomwer" version="" title="copy reduced darks and flats" position="(61.0, -213.0)" />
+	</nodes>
+	<links>
+		<link id="0" source_node_id="0" sink_node_id="1" source_channel="data" sink_channel="data" enabled="true" source_channel_id="data" sink_channel_id="data" />
+		<link id="1" source_node_id="1" sink_node_id="3" source_channel="data" sink_channel="data" enabled="true" source_channel_id="data" sink_channel_id="data" />
+		<link id="2" source_node_id="3" sink_node_id="2" source_channel="data" sink_channel="data" enabled="true" source_channel_id="data" sink_channel_id="data" />
+	</links>
+	<annotations>
+		<text id="0" type="text/plain" rect="(-597.0, -79.0, 150.0, 126.0)" font-family="Sans" font-size="16">step2: provide scans for which we need to copy reduced darks and flats</text>
+		<arrow id="1" start="(-522.0, -87.0)" end="(-523.0, -151.0)" fill="#C1272D" />
+		<text id="2" type="text/plain" rect="(-379.0, -87.0, 236.0, 111.0)" font-family="Sans" font-size="16">invalid any existing darks or flats frames (else reduced darks and flats will use them instead of making the copy)</text>
+		<arrow id="3" start="(-293.0, -97.0)" end="(-290.0, -158.0)" fill="#C1272D" />
+		<text id="4" type="text/plain" rect="(-70.0, -81.0, 270.0, 80.0)" font-family="Sans" font-size="16">will copy reduced darks / flats to `dataset_{darks|flats}.hdf5` to be used for reconstruction</text>
+		<arrow id="5" start="(61.99999999999998, -91.0)" end="(61.99999999999998, -142.0)" fill="#C1272D" />
+		<text id="6" type="text/plain" rect="(-141.0, -427.0, 464.0, 85.0)" font-family="Sans" font-size="16">step1: provide reduced darks and flats from the 'copy' tab,
+unselecting auto and setting them through `select darks url` and `select flats url`</text>
+		<arrow id="7" start="(57.0, -334.0)" end="(58.99999999999997, -259.00000000000006)" fill="#C1272D" />
+		<text id="8" type="text/plain" rect="(241.0, -94.0, 150.0, 88.0)" font-family="Sans" font-size="16">result: scans with copied reduced darks / flats</text>
+		<text id="9" type="text/plain" rect="(-601.0, -590.0, 932.0, 68.0)" font-family="Sans" font-size="16">Context: on this workflow we want to copy reduced flats / darks from a dataset to others.
+This one of the various way to do this.
+</text>
+		<text id="10" type="text/plain" rect="(-593.0, 94.0, 919.0, 84.0)" font-family="Sans" font-size="16">Note: reduced darks / flats can be saved to disk from another python script using the `silx.io.dictdump` dicttoh5 function.
+Reduced darks and flats are dictionary with index in the sequence as key (so index==0 if the dark / flat serie is done at the beginning) and the reduced darks / flats as value (2D numpy array) </text>
+		<arrow id="11" start="(291.0, -109.0)" end="(290.0, -158.0)" fill="#C1272D" />
+	</annotations>
+	<thumbnail />
+	<node_properties>
+		<properties node_id="0" format="literal">{'_scanIDs': [], 'controlAreaVisible': True, 'savedWidgetGeometry': None, '__version__': 1}</properties>
+		<properties node_id="1" format="literal">{'_ewoks_default_inputs': {'operations': {}}, '_ewoks_execinfo': {}, '_ewoks_task_options': {}, '_ewoks_varinfo': {}, 'controlAreaVisible': True, 'default_inputs': {}, 'savedWidgetGeometry': None, '__version__': 1}</properties>
+		<properties node_id="2" format="literal">{'_scanIDs': [], 'controlAreaVisible': True, 'savedWidgetGeometry': None, '__version__': 1}</properties>
+		<properties node_id="3" format="literal">{'_auto_mode': True, '_ewoks_default_inputs': {}, '_ewoks_execinfo': {}, '_ewoks_task_options': {}, '_ewoks_varinfo': {}, 'controlAreaVisible': True, 'default_inputs': {}, 'savedWidgetGeometry': None, '__version__': 1}</properties>
+	</node_properties>
+	<session_state>
+		<window_groups />
+	</session_state>
+</scheme>

tomwer-2.0.1.dev0/src/orangecontrib/tomwer/tutorials/untitled.ows

@@ -0,0 +1,15 @@
+<?xml version='1.0' encoding='utf-8'?>
+<scheme version="2.0" title="" description="">
+	<nodes>
+		<node id="0" name="nabu volume reconstruction" qualified_name="orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW.NabuVolumeOW" project_name="tomwer" version="" title="nabu volume reconstruction" position="(440.0, 214.0)" />
+	</nodes>
+	<links />
+	<annotations />
+	<thumbnail />
+	<node_properties>
+		<properties node_id="0" format="literal">{'_ewoks_default_inputs': {'data': None, 'nabu_volume_params': None, 'nabu_params': None}, 'controlAreaVisible': True, 'savedWidgetGeometry': b'\x01\xd9\xd0\xcb\x00\x03\x00\x00\x00\x00\x03\x08\x00\x00\x01o\x00\x00\x04\xd1\x00\x00\x03\xe5\x00\x00\x03\x08\x00\x00\x01\x94\x00\x00\x04\xd1\x00\x00\x03\xe5\x00\x00\x00\x00\x00\x00\x00\x00\x07\x80\x00\x00\x03\x08\x00\x00\x01\x94\x00\x00\x04\xd1\x00\x00\x03\xe5', '__version__': 1}</properties>
+	</node_properties>
+	<session_state>
+		<window_groups />
+	</session_state>
+</scheme>

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/orangecontrib/tomwer/widgets/reconstruction/CastNabuVolumeOW.py

@@ -161,21 +161,13 @@ class CastNabuVolumeOW(
         self.set_dynamic_input("cluster_config", cluster_config.to_dict())
 
     def _process(self, data: TomwerScanBase | None, volume: TomwerVolumeBase | None):
-        if not _check_volume_to_reconstruct(data=data, volume=volume):
+
+        can_process, volume = _check_volume_to_reconstruct(data=data, volume=volume)
+        if not can_process:
             return
+
         self._last_data = data
         self._last_volume = volume
-        # check types
-        if data is not None and not isinstance(data, TomwerScanBase):
-            raise TypeError(
-                f"scan is expected to be an instance of {TomwerScanBase} not {type(data)}"
-            )
-        if volume is not None and not isinstance(volume, TomwerVolumeBase):
-            raise TypeError(
-                f"volume is expected to be an instance of {TomwerVolumeBase} not {type(volume)}"
-            )
-        if data is None and volume is None:
-            raise ValueError("The scan of the volume should be given. Not both")
 
         if self._window.isInteractive():
             # handling when in interactive mode

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/orangecontrib/tomwer/widgets/reconstruction/MultiPagOW.py

@@ -318,10 +318,12 @@ class MultiPagOW(
     def _updateAccordingToResult(self):
         scan = self.get_task_output_value("data", None)
 
-        if not isinstance(scan, TomwerScanBase):
-            raise TypeError("scan is expected to be an instance of TomwerScanBase")
         if scan is None:
             return
+        if not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"scan is expected to be an instance of TomwerScanBase. Got {type(scan)}"
+            )
 
         self._widget.setDBScores(
             scan.multipag_params.scores,

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/core/reconstruction/common/ringcorrection.py

@@ -9,3 +9,5 @@ class RingCorrectionMethod(_Enum):
     VO = "vo"
     MEAN_SUBTRACTION = "mean-subtraction"
     MEAN_DIVISION = "mean-division"
+    WAVELETS_MEDIAN = "wavelets-median"
+    VSNR = "vsnr"

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/edit/nxtomoeditor.py

@@ -489,7 +489,7 @@ class NXtomoEditor(qt.QWidget):
                     scan.field_of_view is not None and scan.field_of_view is FOV.HALF
                 )
             else:
-                is_half_acq: None | bool = self.get_half_acquisition_or_fov()
+                is_half_acq: None | bool = scan.get_half_acquisition_or_fov()
             if is_half_acq is None:
                 return
             elif is_half_acq:

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/edit/tests/test_nx_editor.py

@@ -73,7 +73,7 @@ def test_nx_editor(
     nx_tomo.energy = energy
     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.half_acquisition = FOV(field_of_view) is FOV.HALF
     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))

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/cor/CoRWidget.py

@@ -230,7 +230,8 @@ class CoRWidget(qt.QMainWindow):
 
         # update visualization
         self._scan = _scan
-        self._settingsWidget.setScan(scan=self._scan)
+        with block_signals(self._settingsWidget):
+            self._settingsWidget.setScan(scan=self._scan)
         self._updatePlot()
         self.getPlot().getPlot().resetZoom()
 
@@ -245,7 +246,6 @@ class CoRWidget(qt.QMainWindow):
             if self._scan is None:
                 return
             cor_params = self._scan.cor_params
-            print("scan is", self._scan.get_identifier())
             if coreAngleMode is CoRAngleMode.manual_selection:
                 manual_sel_widget = (
                     self._settingsWidget._mainWidget._inputWidget._angleModeWidget._manualFrameSelection

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/castvolume/_HistogramLoader.py

@@ -5,6 +5,7 @@ import logging
 from silx.gui import qt
 from nabu.io.cast_volume import find_histogram
 from silx.io.utils import get_data
+from tomwer.core.volume.volumebase import TomwerVolumeBase
 
 _logger = logging.Logger(__file__)
 
@@ -15,7 +16,7 @@ class _HistogramLoader(qt.QThread):
     sigHistogramLoaded = qt.Signal(object, object)
     """Emitted with (counts, edges) arrays on success, or (None, None) on failure"""
 
-    def __init__(self, volume, parent=None):
+    def __init__(self, volume: TomwerVolumeBase, parent=None):
         super().__init__(parent=parent)
         self._volume = volume
 

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/castvolume/_HistogramWidget.py

@@ -14,6 +14,9 @@ _HISTOGRAM_COLOR = "#2166ac"  # blue
 _MIN_COLOR = "#1a9641"  # green  – left boundary
 _MAX_COLOR = "#d73027"  # red    – right boundary
 
+_MOVE_THROTTLE_MS = 100
+"""Minimum delay between two 'sigRangeChanged' emissions while a marker is being dragged."""
+
 
 class HistogramWidget(qt.QWidget):
     """Silx PlotWidget showing a volume histogram with draggable min/max markers.
@@ -32,6 +35,7 @@ class HistogramWidget(qt.QWidget):
         self.setLayout(qt.QVBoxLayout())
         self.layout().setContentsMargins(0, 0, 0, 0)
         self._plot = PlotWidget(self)
+        self._plot.setGraphTitle("Input Volume Histogram")
         self._plot.setYAxisLogarithmic(True)
         self._plot.getYAxis().setLabel("counts")
         self._plot.getXAxis().setLabel("value")
@@ -42,6 +46,10 @@ class HistogramWidget(qt.QWidget):
         self._waitingOverlay.hide()
         self.__minMarker = None
         self.__maxMarker = None
+        self.__moveTimer = qt.QTimer(self)
+        self.__moveTimer.setSingleShot(True)
+        self.__moveTimer.timeout.connect(self._onMoveTimerTimeout)
+        self.__pendingEmit = False
 
     def setLoading(self, loading: bool) -> None:
         self._waitingOverlay.setVisible(loading)
@@ -110,11 +118,27 @@ class HistogramWidget(qt.QWidget):
         if label not in ("min", "max"):
             return
         if event_type == "markerMoving":
-            self._emitCurrentRange()
+            self._throttledEmitCurrentRange()
         elif event_type == "markerMoved":
+            self.__moveTimer.stop()
+            self.__pendingEmit = False
             self._enforceOrder()
             self._emitCurrentRange()
 
+    def _throttledEmitCurrentRange(self):
+        """Emit at most once every `_MOVE_THROTTLE_MS` while a marker is being dragged."""
+        if self.__moveTimer.isActive():
+            self.__pendingEmit = True
+            return
+        self._emitCurrentRange()
+        self.__moveTimer.start(_MOVE_THROTTLE_MS)
+
+    def _onMoveTimerTimeout(self):
+        if self.__pendingEmit:
+            self.__pendingEmit = False
+            self._emitCurrentRange()
+            self.__moveTimer.start(_MOVE_THROTTLE_MS)
+
     def _enforceOrder(self):
         """If the min marker is to the right of the max marker, swap their positions."""
         min_marker = self._getMinMarker()

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/castvolume/_SettingsWidget.py

@@ -237,7 +237,7 @@ class CastVolumeSettingsWidget(qt.QWidget):
             with blockSignals(self._minMaxAuto):
                 self._minMaxAuto.setChecked(False)
             with blockSignals(self._minPixValue):
-                self._minPixValue.setText(str(value))
+                self._minPixValue.setText(f"{value:.4f}")
         self._updatePixMinMaxVis()
 
     def getDataMax(self) -> float | None:
@@ -253,7 +253,7 @@ class CastVolumeSettingsWidget(qt.QWidget):
             with blockSignals(self._minMaxAuto):
                 self._minMaxAuto.setChecked(False)
             with blockSignals(self._maxPixValue):
-                self._maxPixValue.setText(str(value))
+                self._maxPixValue.setText(f"{value:.4f}")
         self._updatePixMinMaxVis()
 
     def setCompressionRatios(self, c_ratios: list | tuple | None) -> None:

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/castvolume/_SlicePreviewWidget.py

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 import logging
 import numpy
+from functools import lru_cache as cache
 from silx.gui import qt
 from silx.gui.widgets.WaitingOverlay import WaitingOverlay
 
 from tomwer.gui.visualization.TomoPlot2D import TomoPlot2D as _TomoPlot2D
+from tomwer.gui.utils._ProcessingOverlay import ProcessingOverlay as _ProcessingOverlay
 from tomwer.gui.utils.slice_selector import SliceIndexLineEdit as _SliceIndexLineEdit
 from nabu.io.cast_volume import clamp_and_rescale_data
 
@@ -19,10 +21,16 @@ class _SliceLoader(qt.QThread):
     """Emitted with the rescaled numpy array, or None on failure."""
 
     def __init__(
-        self, volume, index, output_data_type, data_min, data_max, parent=None
+        self,
+        get_raw_slice,
+        index,
+        output_data_type,
+        data_min,
+        data_max,
+        parent=None,
     ):
         super().__init__(parent=parent)
-        self._volume = volume
+        self._get_raw_slice = get_raw_slice
         self._index = index
         self._output_data_type = output_data_type
         self._data_min = data_min
@@ -30,7 +38,7 @@ class _SliceLoader(qt.QThread):
 
     def run(self):
         try:
-            slice_data = self._volume.get_slice(index=self._index, axis=0)
+            slice_data = self._get_raw_slice(self._index)
             if slice_data is None:
                 self.sigSliceLoaded.emit(None)
                 return
@@ -87,6 +95,12 @@ class _SlicePreviewWidget(qt.QWidget):
         self._waitingOverlay = WaitingOverlay(self._plot)
         self._waitingOverlay.setIconSize(qt.QSize(30, 30))
         self._waitingOverlay.hide()
+        # Overlay to notify during fast axis reading
+        self._processingOverlay = _ProcessingOverlay(
+            self._plot, img_size=qt.QSize(30, 35)
+        )
+        self._processingOverlay.setAlignmentOffsets((-10, 10))
+        self._processingOverlay.setVisible(False)
 
         # internal state
         self._volume = None
@@ -104,6 +118,7 @@ class _SlicePreviewWidget(qt.QWidget):
 
     def setVolume(self, volume) -> None:
         self._volume = volume
+        self._getRawSlice.cache_clear()
         self._requestUpdate()
 
     def setOutputDataType(self, dtype_str: str) -> None:
@@ -126,6 +141,12 @@ class _SlicePreviewWidget(qt.QWidget):
     def _getSliceIndex(self):
         return self._sliceSelector.sliceIndex()
 
+    @cache(maxsize=1)
+    def _getRawSlice(self, volume_identifier: str, index):
+        """Cache of a single raw (pre-rescale) slice, avoids re-reading the same
+        slice from disk when only output_data_type / data_min / data_max change."""
+        return self._volume.get_slice(index=index, axis=0)
+
     def _requestUpdate(self):
         if self._volume is None:
             return
@@ -139,8 +160,13 @@ class _SlicePreviewWidget(qt.QWidget):
             self._sliceLoader.quit()
             self._sliceLoader = None
         self._waitingOverlay.show()
+        self._processingOverlay.setVisible(True)
+        try:
+            volume_identifier = self._volume.get_identifier().to_str()
+        except Exception:
+            volume_identifier = None
         self._sliceLoader = _SliceLoader(
-            volume=self._volume,
+            get_raw_slice=lambda index: self._getRawSlice(volume_identifier, index),
             index=self._getSliceIndex(),
             output_data_type=self._outputDataType,
             data_min=self._dataMin,
@@ -152,5 +178,6 @@ class _SlicePreviewWidget(qt.QWidget):
 
     def _onSliceLoaded(self, data) -> None:
         self._waitingOverlay.hide()
+        self._processingOverlay.setVisible(False)
         if data is not None:
             self._plot.addImage(data, legend="preview", resetzoom=True)

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/castvolume/_check.py

@@ -5,24 +5,44 @@ from silx.gui import qt
 from tomwer.core.scan.scanbase import TomwerScanBase as _TomwerScanBase
 from tomwer.core.volume.volumebase import TomwerVolumeBase as _TomwerVolumeBase
 from tomwer.core.volume.rawvolume import RawVolume
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.volume.volumefactory import VolumeFactory
 
 _raw_volume_warning_dialog: qt.QMessageBox | None = None
 
 
 def check_volume_to_reconstruct(
-    data: _TomwerScanBase, volume: _TomwerVolumeBase
+    data: _TomwerScanBase | None, volume: _TomwerVolumeBase | None
 ) -> bool:
+    if data is None and volume is None:
+        return False, None
+
+    # check types
+    if data is not None and not isinstance(data, TomwerScanBase):
+        raise TypeError(
+            f"scan is expected to be an instance of {TomwerScanBase} not {type(data)}"
+        )
+    if volume is not None and not isinstance(volume, TomwerVolumeBase):
+        raise TypeError(
+            f"volume is expected to be an instance of {TomwerVolumeBase} not {type(volume)}"
+        )
+
+    if volume is None and data is None:
+        return False, volume
     if volume is None and data.latest_vol_reconstructions:
-        volume = data.latest_vol_reconstructions[0]
+        volume = VolumeFactory.create_tomo_object_from_identifier(
+            data.latest_vol_reconstructions[0]
+        )
 
     if volume is None:
-        return False
+        return False, volume
 
     if isinstance(volume, RawVolume):
         _warn_raw_volume_not_supported(volume=volume)
-        return False
+        return False, volume
 
-    return True
+    return True, volume
 
 
 def _warn_raw_volume_not_supported(volume: _TomwerVolumeBase):

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/nabuconfig/preprocessing.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 
 import sys
+import numpy
 from silx.gui import qt
 from enum import Enum as _Enum
 
@@ -217,8 +218,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._sinoRingCorrectionMthd.currentIndexChanged.connect(
             self._sinoRingCorrectionChanged
         )
-        self._sinoRingsOpts._levelsMunch.valueChanged.connect(self._sinoRingOptsChanged)
-        self._sinoRingsOpts._sigmaMunch.valueChanged.connect(self._sinoRingOptsChanged)
+        self._sinoRingsOpts.sigChanged.connect(self._sinoRingOptsChanged)
 
         self._tiltCorrection.toggled.connect(self._tiltCorrectionChanged)
         self._tiltCorrection.sigChanged.connect(self._tiltCorrectionChanged)
@@ -436,6 +436,9 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
 class SinoRingsOptions(qt.QWidget):
     _VO_DIMS = ("horizontaly", "horizontaly and vertically")
 
+    sigChanged = qt.Signal()
+    """Signal emitted when any option returned by getOptions() may have changed."""
+
     def __init__(self, parent=None, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         self._method = None
@@ -453,8 +456,9 @@ class SinoRingsOptions(qt.QWidget):
         self._levelsMunch.setRange(0, 2147483647)
         self.layout().addRow(self._levelsMunchLabel, self._levelsMunch)
 
-        self._paddingMunch = qt.QCheckBox("padding", self)
-        self.layout().addWidget(self._paddingMunch)
+        self._paddingMunchOrWavelets = qt.QCheckBox("padding", self)
+        # padding can be turned on / off only for 'Munch' and 'wavelets-median'.
+        self.layout().addWidget(self._paddingMunchOrWavelets)
 
         # vo parameters
         self._snrVOLabel = qt.QLabel("snr", self)
@@ -503,6 +507,35 @@ class SinoRingsOptions(qt.QWidget):
         self._sigmaHigh.setToolTip(tooltip)
         self._sigmaLow.setToolTip(tooltip)
         self.layout().addRow(self._sigmaHighLabel, self._sigmaHigh)
+
+        # vsnr parameters
+        vnsr_tooltip = (
+            "Rings removal on sinogram based on Variational Signal-to-Noise Ratio (VSNR) approach.\n"
+            "It uses the 'pyvsnr' library.\n"
+            "'noise_level' is more likely to be in [10, 40] range.\n"
+            "warning: Even on a GPU, this is expected to take a long time."
+        )
+        self._noiseLevelLabel = qt.QLabel("noise level")
+        self._noiseLevelLabel.setToolTip(vnsr_tooltip)
+
+        self._noiseLevel = qt.QSpinBox()
+        self._noiseLevel.setRange(1, numpy.iinfo(numpy.uint16).max)
+        self._noiseLevel.setToolTip(vnsr_tooltip)
+        self._noiseLevel.setValue(10)
+        self.layout().addRow(self._noiseLevelLabel, self._noiseLevel)
+
+        # connect signal / slot
+        self._sigmaMunch.valueChanged.connect(self.sigChanged)
+        self._levelsMunch.valueChanged.connect(self.sigChanged)
+        self._paddingMunchOrWavelets.toggled.connect(self.sigChanged)
+        self._snrVO.valueChanged.connect(self.sigChanged)
+        self._laSizeVO.valueChanged.connect(self.sigChanged)
+        self._smSizeVO.valueChanged.connect(self.sigChanged)
+        self._dimVO.currentIndexChanged.connect(self.sigChanged)
+        self._sigmaLow.valueChanged.connect(self.sigChanged)
+        self._sigmaHigh.valueChanged.connect(self.sigChanged)
+        self._noiseLevel.valueChanged.connect(self.sigChanged)
+
         # set up
         self.resetConfiguration()
 
@@ -510,7 +543,7 @@ class SinoRingsOptions(qt.QWidget):
         self.setMethod(method=RingCorrectionMethod.MUNCH)
         self._levelsMunch.setValue(10)
         self._sigmaMunch.setValue(1.0)
-        self._paddingMunch.setChecked(False)
+        self._paddingMunchOrWavelets.setChecked(True)
 
         self._sigmaHigh.setValue(30.0)
         self._sigmaLow.setValue(0.0)
@@ -518,6 +551,7 @@ class SinoRingsOptions(qt.QWidget):
         self._snrVO.setValue(3.0)
         self._laSizeVO.setValue(51)
         self._smSizeVO.setValue(21)
+        self._noiseLevel.setValue(10)
 
     def getVoDim(self):
         if self._dimVO.currentText() == self._VO_DIMS[0]:
@@ -525,7 +559,9 @@ class SinoRingsOptions(qt.QWidget):
         elif self._dimVO.currentText() == self._VO_DIMS[1]:
             return 2
         else:
-            raise NotImplementedError
+            raise ValueError(
+                f"Vo dimension is expected to be in (1, 2). Got {self._dimVO.currentText()}."
+            )
 
     def setVoDim(self, dim: int | str):
         if dim in ("1", 1, self._VO_DIMS[0]):
@@ -533,7 +569,7 @@ class SinoRingsOptions(qt.QWidget):
         elif dim in ("2", 2, self._VO_DIMS[1]):
             self._dimVO.setCurrentText(self._VO_DIMS[1])
         else:
-            raise NotImplementedError(f"dim {dim} not handled")
+            raise ValueError(f"Vo dimension is expected to be in (1, 2). Got {dim}.")
 
     def getOptions(self) -> dict:
         if self.getMethod() is RingCorrectionMethod.NONE:
@@ -542,7 +578,16 @@ class SinoRingsOptions(qt.QWidget):
             return {
                 "sigma": self._sigmaMunch.value(),
                 "levels": self._levelsMunch.value(),
-                "padding": self._paddingMunch.isChecked(),
+                "padding": self._paddingMunchOrWavelets.isChecked(),
+            }
+        elif self._method is RingCorrectionMethod.WAVELETS_MEDIAN:
+            return {
+                "padding": self._paddingMunchOrWavelets.isChecked(),
+            }
+        elif self._method is RingCorrectionMethod.VSNR:
+            return {
+                "padding": self._paddingMunchOrWavelets.isChecked(),
+                "noise_level": self._noiseLevel.value(),
             }
         elif self.getMethod() is RingCorrectionMethod.VO:
             return {
@@ -569,7 +614,7 @@ class SinoRingsOptions(qt.QWidget):
             self._levelsMunch.setValue(int(options["levels"]))
         padding = options.get("padding")
         if padding is not None:
-            self._paddingMunch.setChecked(padding in (True, 1, "1", "True"))
+            self._paddingMunchOrWavelets.setChecked(padding in (True, 1, "1", "True"))
         # handle VO properties
         snr = options.get("snr")
         if snr is not None:
@@ -589,6 +634,9 @@ class SinoRingsOptions(qt.QWidget):
             low_pass, high_pass = filter_cutoff
             self._sigmaLow.setValue(string_to_float(low_pass))
             self._sigmaHigh.setValue(string_to_float(high_pass))
+        noise_level = options.get("noise_level")
+        if noise_level is not None:
+            self._noiseLevel.setValue(int(noise_level))
 
     def setMethod(self, method: RingCorrectionMethod):
         method = RingCorrectionMethod(method)
@@ -598,7 +646,14 @@ class SinoRingsOptions(qt.QWidget):
         self._sigmaMunchLabel.setVisible(method is RingCorrectionMethod.MUNCH)
         self._levelsMunch.setVisible(method is RingCorrectionMethod.MUNCH)
         self._levelsMunchLabel.setVisible(method is RingCorrectionMethod.MUNCH)
-        self._paddingMunch.setVisible(method is RingCorrectionMethod.MUNCH)
+        self._paddingMunchOrWavelets.setVisible(
+            method
+            in (
+                RingCorrectionMethod.MUNCH,
+                RingCorrectionMethod.WAVELETS_MEDIAN,
+                RingCorrectionMethod.VSNR,
+            )
+        )
         # handle VO options
         self._snrVO.setVisible(method is RingCorrectionMethod.VO)
         self._snrVOLabel.setVisible(method is RingCorrectionMethod.VO)
@@ -637,6 +692,9 @@ class SinoRingsOptions(qt.QWidget):
                 RingCorrectionMethod.MEAN_SUBTRACTION,
             )
         )
+        # VSNR option
+        self._noiseLevel.setVisible(method is RingCorrectionMethod.VSNR)
+        self._noiseLevelLabel.setVisible(method is RingCorrectionMethod.VSNR)
 
     def getMethod(self) -> RingCorrectionMethod:
         return self._method

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/reconstruction/nabu/test/test_nabu_preprocessing.py

@@ -33,20 +33,20 @@ def test_sino_rings_options(qtapp):  # noqa F811
     assert widget.getOptions() == {
         "sigma": 1.0,
         "levels": 10,
-        "padding": False,
+        "padding": True,
     }
 
     widget.setOptions(
         {
             "sigma": 3.25,
             "levels": 564,
-            "padding": True,
+            "padding": False,
         }
     )
     assert widget.getOptions() == {
         "sigma": 3.25,
         "levels": 564,
-        "padding": True,
+        "padding": False,
     }
     # test mean division
     widget.setMethod(method=RingCorrectionMethod.MEAN_DIVISION)

{tomwer-2.0.0.dev8 → tomwer-2.0.1.dev0}/src/tomwer/gui/utils/buttons.py

@@ -153,7 +153,7 @@ class TapeMeasureToolButton(PlotToolButton):
         if plot is None:
             return
         self._roiManager = RegionOfInterestManager(plot)
-        self._roiManager.setColor("yellow")  # Set the color of ROI
+        self._roiManager.setColor("orange")  # Set the color of ROI
         self._roiManager.sigRoiAdded.connect(self._registerCurrentROI)
 
     def _disconnectPlot(self, plot):