tomwer 1.3.27__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/gui/reconstruction/nabu/platform.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from silx.gui import qt
+
+from tomwer.gui.reconstruction.nabu.nabuconfig.base import _NabuStageConfigBase
+from tomwer.gui.utils.gpu import SelectGPUGroupBox
+
+
+class NabuPlatformSettings(qt.QWidget, _NabuStageConfigBase):
+    """define settings to be used for the local reconstruction like gpu..."""
+
+    sigConfigChanged = qt.Signal()
+
+    DEFAULT_GPU_FRACTION = 90
+    DEFAULT_CPU_FRACTION = 90
+
+    def __init__(self, parent: qt.QWidget | None = None) -> None:
+        qt.QWidget.__init__(self, parent, stage=None)
+        _NabuStageConfigBase.__init__(self, stage=None)
+
+        self.setLayout(qt.QFormLayout())
+        self._gpuSelWidget = SelectGPUGroupBox()
+        self._gpuSelWidget.setChecked(False)
+        # keep default behavior: don't set any default gpu
+        self.layout().addRow(self._gpuSelWidget)
+
+        # gpu percentage
+        self._GPUFractionLabel = qt.QLabel("GPU percentage usage", self)
+        self.registerWidget(self._GPUFractionLabel, "advanced")
+        self._GPUFractionSB = qt.QSpinBox(self)
+        self._GPUFractionSB.setSingleStep(10)
+        self._GPUFractionSB.setSuffix("%")
+        self._GPUFractionSB.setMinimum(1)
+        self._GPUFractionSB.setMaximum(100)
+        self._GPUFractionSB.setToolTip("Which fraction of GPU memory to use.")
+        self.registerWidget(self._GPUFractionSB, "advanced")
+        self.layout().addRow(self._GPUFractionLabel, self._GPUFractionSB)
+
+        # cpu percentage
+        self._CPUFractionLabel = qt.QLabel("CPU percentage usage", self)
+        self.registerWidget(self._CPUFractionLabel, "advanced")
+        self._CPUFractionSB = qt.QSpinBox(self)
+        self._CPUFractionSB.setSingleStep(10)
+        self._CPUFractionSB.setSuffix("%")
+        self._CPUFractionSB.setMinimum(1)
+        self._CPUFractionSB.setMaximum(100)
+        self._CPUFractionSB.setToolTip("Which fraction of CPU memory to use.")
+        self.registerWidget(self._CPUFractionSB, "advanced")
+        self.layout().addRow(self._CPUFractionLabel, self._CPUFractionSB)
+
+        # set up
+        self._GPUFractionSB.setValue(NabuPlatformSettings.DEFAULT_GPU_FRACTION)
+        self._CPUFractionSB.setValue(NabuPlatformSettings.DEFAULT_CPU_FRACTION)
+
+        # connect signal / slot
+        self._gpuSelWidget.sigGPUChanged.connect(self.sigConfigChanged)
+        self._GPUFractionSB.valueChanged.connect(self._triggerSigConfChanged)
+        self._CPUFractionSB.valueChanged.connect(self._triggerSigConfChanged)
+
+    def getCPUFraction(self) -> float:
+        return self._CPUFractionSB.value() / 100.0
+
+    def setCPUFraction(self, value: float):
+        return self._CPUFractionSB.setValue(int(value * 100.0))
+
+    def getGPUFraction(self) -> float:
+        return self._GPUFractionSB.value() / 100.0
+
+    def setGPUFraction(self, value: float):
+        return self._GPUFractionSB.setValue(int(value * 100.0))
+
+    def _triggerSigConfChanged(self, *args, **kwargs) -> None:
+        self.sigConfigChanged.emit()
+
+    def getConfiguration(self) -> dict:
+        config = {
+            "gpu_mem_fraction": self.getGPUFraction(),
+            "cpu_mem_fraction": self.getCPUFraction(),
+        }
+        selected_gpu_id = self._gpuSelWidget.getSelectedGPUId()
+        if selected_gpu_id is not None:
+            config["resources"] = {
+                "gpu_id": selected_gpu_id,
+            }
+        return config
+
+    def setConfiguration(self, config: dict) -> None:
+        gpu_id = config.get("resources", {}).get("gpu_id", None)
+        if gpu_id not in (None, ""):
+            self._gpuSelWidget.setSelectedGPUId(value=gpu_id)
+            self._gpuSelWidget.setChecked(True)
+        if "gpu_mem_fraction" in config:
+            self.setGPUFraction(config["gpu_mem_fraction"])
+        if "cpu_mem_fraction" in config:
+            self.setCPUFraction(config["cpu_mem_fraction"])

tomwer/gui/reconstruction/nabu/slices.py

@@ -1,31 +1,6 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "04/03/2019"
+from __future__ import annotations
+
 
 import logging
 
@@ -38,11 +13,14 @@ from silx.gui import qt
 from silx.utils.enum import Enum as _Enum
 from nxtomo.nxobject.nxdetector import FOV
 
+from tomwer.core.utils.dictutils import concatenate_dict
 from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui import icons as tomwer_icons
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowArea
+from tomwer.gui.reconstruction.nabu.platform import NabuPlatformSettings
 from tomwer.gui.utils.buttons import PadlockButton
+from tomwer.gui.settings import TAB_LABEL_PLATFORM_SETTINGS
 
 from ...utils.flow import FlowDirection
 from tomwer.gui.configuration.action import (
@@ -153,15 +131,15 @@ class _NabuConfiguration(qt.QWidget):
     def filter(self, stage=None, process=None):
         """Apply a filter on the options to show
 
-        :param str stage:
-        :param str process:
+        :param stage:
+        :param process:
         """
         pass
 
     def setStages(self, stages: dict) -> None:
         """
 
-        :param dict stages: contains stages the user can edit and for each
+        :param stages: contains stages the user can edit and for each
                             stages the associated processes.
         """
         self.clear()
@@ -213,7 +191,7 @@ class NabuWindow(qt.QMainWindow):
         qt.QMainWindow.__init__(self, parent=parent)
         self.setWindowFlags(qt.Qt.Widget)
 
-        self._mainWidget = NabuWidget(parent=self, flow_direction=flow_direction)
+        self._mainWidget = NabuTabWidget(parent=self, flow_direction=flow_direction)
         self.setCentralWidget(self._mainWidget)
         style = qt.QApplication.style()
 
@@ -279,14 +257,6 @@ class NabuWindow(qt.QMainWindow):
         self.__tSpacer.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Preferred)
         toolbar.addWidget(self.__tSpacer)
 
-        # expose API
-        self.setOutputDir = self._mainWidget.setOutputDir
-        self.setScan = self._mainWidget.setScan
-        self.getMode = self._mainWidget.getMode
-        self.setMode = self._mainWidget.setMode
-        self.hideSlicesInterface = self._mainWidget.hideSlicesInterface
-        self.hidePaganinInterface = self._mainWidget.hidePaganinInterface
-
         # connect signal / slot
         self._mainWidget.sigConfigChanged.connect(self.sigConfigChanged)
 
@@ -348,8 +318,9 @@ class NabuWindow(qt.QMainWindow):
         )
 
     def _resetParameters(self):
+        # reset nabu settings
         default_config = get_default_nabu_config(nabu_fullfield_default_config)
-        self._mainWidget._configuration._preProcessingWidget._sinoRingsOpts.resetConfiguration()
+        self._mainWidget.nabuSettingsWidget._configuration._preProcessingWidget._sinoRingsOpts.resetConfiguration()
         default_config["tomwer_slices"] = "middle"
         default_config["preproc"]["ccd_filter_enabled"] = False
         default_config["preproc"]["double_flatfield_enabled"] = False
@@ -427,11 +398,31 @@ class NabuWindow(qt.QMainWindow):
         else:
             raise ValueError("Level not recognize")
 
+    # expose API
+
     def setModeLocked(self, locked: bool):
-        self._mainWidget.setModeLocked(locked)
+        self._mainWidget.nabuSettingsWidget.setModeLocked(locked)
 
     def isModeLocked(self):
-        return self._mainWidget.isModeLocked()
+        return self._mainWidget.nabuSettingsWidget.isModeLocked()
+
+    def setOutputDir(self, dir: str):
+        self._mainWidget.nabuSettingsWidget.setOutputDir(dir=dir)
+
+    def setScan(self, scan: TomwerScanBase):
+        self._mainWidget.nabuSettingsWidget.setScan(scan=scan)
+
+    def getMode(self):
+        return self._mainWidget.nabuSettingsWidget.getMode()
+
+    def setMode(self, mode):
+        self._mainWidget.nabuSettingsWidget.setMode(mode=mode)
+
+    def hideSlicesInterface(self):
+        self._mainWidget.nabuSettingsWidget.hideSlicesInterface()
+
+    def hidePaganinInterface(self):
+        self._mainWidget.nabuSettingsWidget.hidePaganinInterface()
 
 
 class NabuWidget(qt.QWidget):
@@ -484,9 +475,7 @@ class NabuWidget(qt.QWidget):
         # nabu configuration
         self._configurationScrollArea = qt.QScrollArea(self)
         self._configurationScrollArea.setWidgetResizable(True)
-        self._configuration = NabuConfiguration(
-            parent=self, scrollArea=self._configurationScrollArea
-        )
+        self._configuration = NabuConfiguration(parent=self)
         self._configurationScrollArea.setWidget(self._configuration)
         self._configurationScrollArea.setHorizontalScrollBarPolicy(
             qt.Qt.ScrollBarAlwaysOff
@@ -622,3 +611,50 @@ class NabuWidget(qt.QWidget):
     def setFilteringActive(self, active):
         self._filteringActive = active
         self.updateConfigurationFilter()
+
+
+class NabuTabWidget(qt.QTabWidget):
+    """
+    Widget that group Nabu reconstruction settings and (local) platform settings
+    """
+
+    sigConfigChanged = qt.Signal()
+
+    def __init__(self, parent=None, flow_direction: str = "vertical"):
+        super().__init__(parent=parent)
+        self._nabuSettingsWidget = NabuWidget(
+            parent=self, flow_direction=flow_direction
+        )
+        self.addTab(self._nabuSettingsWidget, "reconstruction settings")
+        self._platformSettingsWidget = NabuPlatformSettings(parent=self)
+        self.addTab(self._platformSettingsWidget, TAB_LABEL_PLATFORM_SETTINGS)
+
+        # connect signal / slot
+        self._nabuSettingsWidget.sigConfigChanged.connect(self.sigConfigChanged)
+        self._platformSettingsWidget.sigConfigChanged.connect(self.sigConfigChanged)
+
+    def getConfiguration(self) -> dict:
+        config = self._nabuSettingsWidget.getConfiguration()
+        config = concatenate_dict(
+            config, self._platformSettingsWidget.getConfiguration()
+        )
+        return config
+
+    def setConfiguration(self, config: dict):
+        self._nabuSettingsWidget.setConfiguration(config=config)
+        self._platformSettingsWidget.setConfiguration(config=config)
+
+    def setConfigurationLevel(self, level):
+        self._nabuSettingsWidget.setConfigurationLevel(level=level)
+        self._platformSettingsWidget.setConfigurationLevel(level=level)
+
+    def getConfigurationLevel(self):
+        return self._nabuSettingsWidget.getConfigurationLevel()
+
+    @property
+    def nabuSettingsWidget(self):
+        return self._nabuSettingsWidget
+
+    @property
+    def platformSettings(self):
+        return self._platformSettingsWidget

tomwer/gui/reconstruction/nabu/slurm.py

@@ -1,31 +1,5 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "11/10/2021"
+from __future__ import annotations
 
 
 from silx.gui import qt

tomwer/gui/reconstruction/nabu/test/test_cast_volume.py

@@ -0,0 +1,82 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.reconstruction.nabu.castvolume import CastVolumeWidget
+
+
+def test_CastVolumeWidget(qtapp):  # noqa F811
+    """simple test of the CastVolumeWidget"""
+    widget = CastVolumeWidget(parent=None)
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": None,
+        "data_min": None,
+        "output_data_type": "uint16",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "tiff",
+        "overwrite": True,
+        "rescale_max_percentile": 90,
+        "rescale_min_percentile": 10,
+    }
+
+    widget._minMaxAuto.setChecked(False)
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 0.0,
+        "data_min": 0.0,
+        "output_data_type": "uint16",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "tiff",
+        "overwrite": True,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+    }
+
+    widget.setDataMin(1.0)
+    widget.setDataMax(10.0)
+
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 10.0,
+        "data_min": 1.0,
+        "output_data_type": "uint16",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "tiff",
+        "overwrite": True,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+    }
+    widget.setOutputFileformat("edf")
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 10.0,
+        "data_min": 1.0,
+        "output_data_type": "uint16",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "edf",
+        "overwrite": True,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+    }
+    widget.setOverwrite(False)
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 10.0,
+        "data_min": 1.0,
+        "output_data_type": "uint16",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "edf",
+        "overwrite": False,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+    }
+    widget.setOutputDataType("float32")
+    assert widget.getConfiguration() == {
+        "compression_ratios": None,
+        "data_max": 10.0,
+        "data_min": 1.0,
+        "output_data_type": "float32",
+        "output_dir": "{volume_data_parent_folder}/cast_volume",
+        "output_file_format": "edf",
+        "overwrite": False,
+        "rescale_max_percentile": None,
+        "rescale_min_percentile": None,
+    }

tomwer/gui/reconstruction/nabu/test/test_check.py

@@ -0,0 +1,66 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import os
+
+import pytest
+from nxtomo.nxobject.nxdetector import ImageKey
+
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+from tomwer.gui.reconstruction.nabu import check
+
+
+def test_check_dark_series(tmpdir):
+    """test check.check_dark_series function"""
+    full_edf_path = os.path.join(tmpdir, "my", "aquisition", "folder")
+    MockEDF.fastMockAcquisition(full_edf_path)
+    edf_scan = EDFTomoScan(full_edf_path)
+    with pytest.raises(TypeError):
+        assert check.check_dark_series(edf_scan)
+
+    full_hdf5_scan = os.path.join(tmpdir, "hdf5_scan")
+    scan = MockNXtomo(
+        scan_path=full_hdf5_scan,
+        n_proj=20,
+        n_ini_proj=20,
+        dim=10,
+    ).scan
+    scan._image_keys = (
+        [ImageKey.DARK_FIELD] * 2
+        + [ImageKey.PROJECTION] * 4
+        + [ImageKey.DARK_FIELD] * 2
+    )
+    assert check.check_dark_series(scan, logger=None, user_input=False) is False
+    scan._image_keys = [ImageKey.DARK_FIELD] * 2 + [ImageKey.PROJECTION] * 4
+    assert check.check_dark_series(scan, logger=None, user_input=False) is True
+    scan._image_keys = [ImageKey.PROJECTION] * 4
+    assert check.check_dark_series(scan, logger=None, user_input=False) is False
+
+
+def test_check_flat_series(tmpdir):
+    """test check.check_flat_series function"""
+    full_edf_path = os.path.join(tmpdir, "my", "aquisition", "folder")
+    MockEDF.fastMockAcquisition(full_edf_path)
+    edf_scan = EDFTomoScan(full_edf_path)
+    with pytest.raises(TypeError):
+        assert check.check_flat_series(edf_scan)
+
+    full_hdf5_scan = os.path.join(tmpdir, "hdf5_scan")
+    scan = MockNXtomo(
+        scan_path=full_hdf5_scan,
+        n_proj=20,
+        n_ini_proj=20,
+        dim=10,
+    ).scan
+    scan._image_keys = (
+        [ImageKey.FLAT_FIELD] * 2
+        + [ImageKey.PROJECTION] * 4
+        + [ImageKey.FLAT_FIELD] * 2
+    )
+    assert check.check_flat_series(scan, logger=None, user_input=False) is True
+    scan._image_keys = [ImageKey.FLAT_FIELD] * 2 + [ImageKey.PROJECTION] * 4
+    assert check.check_flat_series(scan, logger=None, user_input=False) is True
+    scan._image_keys = [ImageKey.PROJECTION] * 4
+    assert check.check_flat_series(scan, logger=None, user_input=False) is False

tomwer/gui/reconstruction/nabu/test/test_ctf.py

@@ -0,0 +1,46 @@
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.reconstruction.nabu.nabuconfig.ctf import CTFConfig
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestFutureSupervisorOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._widget = CTFConfig()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        return super().tearDown()
+
+    def test_configuration(self):
+        """
+        test configuration setter and getter
+        """
+        self._widget.show()
+        config = self._widget.getConfiguration()
+        assert isinstance(config, dict)
+
+        assert config == {
+            "ctf_geometry": " z1_v=None; z1_h=None; detec_pixel_size=None; magnification=True",
+            "ctf_advanced_params": " length_scale=1e-05; lim1=1e-05; lim2=0.2; normalize_by_mean=True",
+            "ctf_translations_file": "",
+            "beam_shape": "parallel",
+        }
+
+        config["beam_shape"] = "cone"
+        config["ctf_translations_file"] = "my_file.txt"
+        config["ctf_geometry"] = (
+            " z1_v=10.2; z1_h=3.6; detec_pixel_size=1e-05; magnification=False"
+        )
+        config["ctf_advanced_params"] = (
+            " length_scale=2e-05; lim1=1e-08; lim2=0.1; normalize_by_mean=False"
+        )
+
+        self._widget.setConfiguration(config)
+        assert self._widget.getConfiguration() == config

tomwer/gui/reconstruction/nabu/test/test_helical.py

@@ -0,0 +1,21 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.reconstruction.nabu.helical import HelicalPrepareWeightsDouble
+
+
+def test_DeltaBetaSelector(
+    qtapp,  # noqa F811
+):
+    """simple test of the _DeltaBetaSelectorDialog"""
+    widget = HelicalPrepareWeightsDouble()
+    assert widget.getConfiguration() == {
+        "processes_file": "{scan_parent_dir_basename}/{scan_dir_name}/map_and_doubleff.hdf5",
+        "transition_width_vertical": 50.0,
+        "transition_width_horizontal": 50.0,
+    }
+    config = {
+        "processes_file": "test.hdf5",
+        "transition_width_vertical": 12.5,
+        "transition_width_horizontal": 11.5,
+    }
+    widget.setConfiguration(config=config)
+    assert widget.getConfiguration() == config

tomwer/gui/reconstruction/nabu/test/test_nabu_preprocessing.py

@@ -0,0 +1,81 @@
+from tomwer.gui.reconstruction.nabu.nabuconfig.preprocessing import (
+    SinoRingsOptions,
+    TiltCorrection,
+    RingCorrectionMethod,
+)
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_tilt_correction_widget(qtapp):  # noqa F811
+    """
+    Test of TiltCorrection
+    """
+    widget = TiltCorrection(text="")
+    assert not widget._tiltManualRB.isChecked()
+    assert widget._autoManualRB.isChecked()
+    assert widget.getTiltCorrection() == ("1d-correlation", "")
+    widget.setTiltCorrection(0.0)
+    assert widget.getTiltCorrection() == (0.0, "")
+    assert widget._tiltManualRB.isChecked()
+    assert not widget._autoManualRB.isChecked()
+    widget.setTiltCorrection("fft-polar", auto_tilt_options="low_pass=10")
+    assert widget.getTiltCorrection() == ("fft-polar", "low_pass=10")
+    assert not widget._tiltManualRB.isChecked()
+    assert widget._autoManualRB.isChecked()
+
+
+def test_sino_rings_options(qtapp):  # noqa F811
+    """
+    Test of SinoRingsOptions
+    """
+    widget = SinoRingsOptions()
+    # test munch options
+    assert widget.getOptions() == {
+        "sigma": 1.0,
+        "levels": 10,
+        "padding": False,
+    }
+
+    widget.setOptions(
+        {
+            "sigma": 3.25,
+            "levels": 564,
+            "padding": True,
+        }
+    )
+    assert widget.getOptions() == {
+        "sigma": 3.25,
+        "levels": 564,
+        "padding": True,
+    }
+    # test mean division
+    widget.setMethod(method=RingCorrectionMethod.MEAN_DIVISION)
+    assert widget.getOptions() == {
+        "filter_cutoff": (0, 30),
+    }
+
+    # test VO deringer
+    widget.setMethod(method=RingCorrectionMethod.VO.value)
+    assert widget.getOptions() == {
+        "dim": 1,
+        "la_size": 51,
+        "sm_size": 21,
+        "snr": 3.0,
+    }
+    new_vo_options = {
+        "dim": 2,
+        "la_size": 42,
+        "sm_size": 22,
+        "snr": 6.3,
+    }
+    widget.setOptions(new_vo_options)
+    assert widget.getOptions() == new_vo_options
+
+    # test mean division
+    new_mean_division_options = {
+        "filter_cutoff": (10, 23),
+    }
+
+    widget.setMethod(method=RingCorrectionMethod.MEAN_DIVISION)
+    widget.setOptions(new_mean_division_options)
+    assert widget.getOptions() == new_mean_division_options