tomwer 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

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

@@ -0,0 +1,92 @@
+# 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__ = "02/12/2021"
+
+
+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

tomwer/gui/reconstruction/normalization/test/test_intensity.py

@@ -0,0 +1,119 @@
+# 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__ = "23/06/2021"
+
+
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.reconstruction.normalization.params import (
+    Method as NormalizationMethod,
+)
+from tomwer.core.process.reconstruction.normalization.params import (
+    _ValueSource as NormalizationSource,
+)
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.gui.reconstruction.normalization.intensity import SinoNormWindow
+
+
+class TestNormIntensityWindow(TestCaseQt):
+    def setUp(self):
+        super(TestNormIntensityWindow, self).setUp()
+        self._widget = SinoNormWindow(parent=None)
+        self._tmp_dir = tempfile.mkdtemp()
+        scan_path = os.path.join(self._tmp_dir, "my_scan_2")
+        self.scan = MockNXtomo(
+            scan_path=scan_path,
+            n_ini_proj=10,
+            n_proj=10,
+            n_alignement_proj=2,
+            create_final_flat=False,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            n_refs=1,
+        ).scan
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self.qapp.processEvents()
+        self._widget = None
+        shutil.rmtree(self._tmp_dir)
+        super(TestNormIntensityWindow, self).tearDown()
+
+    def test(self):
+        self._widget.setScan(self.scan)
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        self._widget.setCurrentMethod(NormalizationMethod.NONE)
+        self.qapp.processEvents()
+        assert self._widget.getConfiguration() == {"source": "none", "method": "none"}
+
+        self._widget.setCurrentMethod(NormalizationMethod.CHEBYSHEV)
+        self.qapp.processEvents()
+        assert self._widget.getConfiguration() == {
+            "method": "chebyshev",
+            "source": "none",
+        }
+
+        self._widget.setCurrentMethod(NormalizationMethod.SUBTRACTION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.MANUAL_ROI)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "subtraction"
+        assert output_configuration["source"] == "manual ROI"
+        assert "start_x" in output_configuration
+        assert "end_x" in output_configuration
+        assert "start_y" in output_configuration
+        assert "end_y" in output_configuration
+        assert "calc_fct" in output_configuration
+        self._widget.setCurrentMethod(NormalizationMethod.DIVISION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.DATASET)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "division"
+        assert output_configuration["source"] == "from dataset"
+        assert "dataset_url" in output_configuration
+
+        self._widget.setCurrentMethod(NormalizationMethod.DIVISION)
+        self.qapp.processEvents()
+        self._widget.setCurrentSource(NormalizationSource.MANUAL_SCALAR)
+        self.qapp.processEvents()
+        output_configuration = self._widget.getConfiguration()
+        assert output_configuration["method"] == "division"
+        assert output_configuration["source"] == "scalar"
+        assert "value" in output_configuration

tomwer/gui/stitching/config/tests/test_axisparams.py

@@ -0,0 +1,25 @@
+import pytest
+
+from tomwer.gui.stitching.config.axisparams import StitcherAxisParams
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_StitcherAxisParams(
+    qtapp,  # noqa F811
+):
+    """test the StitcherAxisParams widget"""
+    with pytest.raises(TypeError):
+        widget = StitcherAxisParams(axis="toto")
+    widget = StitcherAxisParams(axis=0)
+    assert widget.getConfiguration() == {
+        "stitching": {
+            "axis_0_params": "img_reg_method=nabu-fft;window_size=400",
+        }
+    }
+    new_config = {
+        "stitching": {
+            "axis_0_params": "img_reg_method=skimage;window_size=50",
+        },
+    }
+    widget.setConfiguration(new_config)
+    assert widget.getConfiguration() == new_config

tomwer/gui/stitching/tests/test_axis_ordered_list.py

@@ -0,0 +1,21 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.gui.stitching.axisorderedlist import EditableZOrderedTomoObjWidget
+
+
+def test_axis_ordered_list_widget(
+    qtapp,  # noqa F811
+):
+    widget = EditableZOrderedTomoObjWidget()
+    volumes = tuple(
+        HDF5Volume(
+            file_path=f"my_volume{i}.hdf5",
+            data_path="my_volume",
+        )
+        for i in range(5)
+    )
+    [widget.addTomoObj(volume) for volume in volumes]
+
+    widget.setSelectedTomoObjs([volumes[1], volumes[-1]])
+    widget._callbackRemoveSelectedTomoObj()
+    assert widget.getTomoObjsZOrdered() == (volumes[0], volumes[2], volumes[3])

tomwer/gui/stitching/tests/test_normalization.py

@@ -0,0 +1,27 @@
+from tomwer.gui.stitching.normalization import NormalizationBySampleGroupBox
+
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_FrameNormalizationWidget(
+    qtapp,  # noqa F811
+):
+    widget = NormalizationBySampleGroupBox()
+    assert widget.getConfiguration() == {
+        "active": True,
+        "side": "left",
+        "method": "median",
+        "width": 30,
+        "margin": 0,
+    }
+
+    new_config = {
+        "active": False,
+        "side": "left",
+        "method": "median",
+        "width": 30,
+        "margin": 0,
+    }
+
+    widget.setConfiguration(new_config)
+    assert widget.getConfiguration() == new_config

tomwer/gui/stitching/tests/test_preview.py

@@ -0,0 +1,85 @@
+import os
+import shutil
+import tempfile
+
+import numpy
+from nabu.stitching.config import PreProcessedZStitchingConfiguration
+from nabu.stitching.z_stitching import PreProcessZStitcher
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from silx.image.phantomgenerator import PhantomGenerator
+
+from tomwer.gui.stitching.stitching_preview import PreviewStitchingPlot
+from tomwer.gui.stitching.tests.utils import create_scans_z_serie
+
+
+class TestPreview(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.axis_0_positions = (90, 0.0, -90.0)
+        self.axis_2_positions = (0.0, 0.0, 0.0)
+        pixel_size = 1.0
+
+        self.output_file_path = os.path.join(self._tmp_path, "output", "stitched.nx")
+        self._input_dir = os.path.join(self._tmp_path, "input")
+
+        self._scans = create_scans_z_serie(
+            output_dir=self._input_dir,
+            z_positions_m=self.axis_0_positions,
+            x_positions_m=self.axis_2_positions,
+            shifts=((0.0, 0.0), (-90.0, 0.0), (-180.0, 0.0)),
+            pixel_size=pixel_size,
+            raw_frame_width=280,
+            final_frame_width=100,
+        )
+        self._stitching_config = PreProcessedZStitchingConfiguration(
+            output_file_path=self.output_file_path,
+            output_data_path="entry_stitched",
+            overwrite_results=True,
+            slurm_config=None,
+            axis_0_pos_mm=numpy.array(self.axis_0_positions) / 1000,
+            axis_2_pos_mm=numpy.array(self.axis_2_positions) / 1000,
+            axis_0_pos_px=None,
+            axis_1_pos_px=None,
+            axis_2_pos_px=None,
+            input_scans=self._scans,
+            pixel_size=pixel_size,
+        )
+        self.widget = PreviewStitchingPlot()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self._tmp_path)
+
+    def test(self):
+        """
+        test the PreviewStitchingPlot
+        """
+        self.widget.show()
+        self.widget._backGroundAction.toggle()
+        self.qapp.processEvents()
+
+        stitcher = PreProcessZStitcher(configuration=self._stitching_config)
+        stitched_id = stitcher.stitch(store_composition=True)
+        assert stitched_id is not None
+        composition = stitcher.frame_composition
+        assert composition is not None
+
+        self.widget.setStitchedTomoObj(
+            tomo_obj_id=stitched_id.to_str(), composition=composition
+        )
+        self.qapp.processEvents()
+        assert self.widget.stitched_image is not None
+        assert self.widget.composition_background is not None
+
+        numpy.testing.assert_almost_equal(
+            self.widget.stitched_image,
+            PhantomGenerator.get2DPhantomSheppLogan(n=280).astype(numpy.float32)
+            * 256.0,
+        )
+
+        self.widget._backGroundAction.toggle()
+        self.qapp.processEvents()

tomwer/gui/stitching/tests/test_stitching_raw.py

@@ -0,0 +1,110 @@
+import os
+import shutil
+import tempfile
+
+import numpy
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.gui.stitching.metadataholder import QStitchingMetadata
+from tomwer.gui.stitching.stitching_raw import RawStitchingPlot, AlphaValuesTableWidget
+
+
+def _createVolumes(axis_0_positions: tuple, root_dir: str):
+    volumes = []
+    for i_volume, axis_0_position in enumerate(axis_0_positions):
+        data = numpy.random.random(20 * 20).reshape(1, 20, 20)
+        volume = HDF5Volume(
+            file_path=os.path.join(root_dir, f"volume_{i_volume}.hdf5"),
+            data_path=f"entry_{i_volume}",
+            data=data,
+        )
+        volume.stitching_metadata = QStitchingMetadata(tomo_obj=volume)
+        volume.stitching_metadata.setPxPos(axis=0, value=axis_0_position)
+        volumes.append(volume)
+    return volumes
+
+
+def _createScans(axis_0_positions: tuple, root_dir: str):
+    scans = []
+    for i_scan, axis_0_position in enumerate(axis_0_positions):
+        scan = MockNXtomo(
+            scan_path=os.path.join(root_dir, f"scan_{i_scan}"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+        scan.stitching_metadata = QStitchingMetadata(tomo_obj=scan)
+        scan.stitching_metadata.setPxPos(axis=0, value=axis_0_position)
+        scans.append(scan)
+    return scans
+
+
+class TestPlotRawStitching(TestCaseQt):
+    """Test RawStitchingPlot widget"""
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.widget = RawStitchingPlot(alpha_values=True)
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self._tmp_path)
+
+    def testWithVolumes(self):
+        axis_0_positions = (0, 12, 50)
+        volumes = _createVolumes(
+            axis_0_positions=axis_0_positions, root_dir=self._tmp_path
+        )
+        assert len(volumes) == 3
+        self.widget.addTomoObj(volumes[0])
+        images = self.widget.getAllImages()
+        assert len(images) == 1
+
+        self.widget.setTomoObjs(volumes)
+        images = self.widget.getAllImages()
+        assert len(images) == len(volumes)
+        # silx is storing origins as x, y
+        origins = tuple([image.getOrigin()[1] for image in images])
+        assert tuple(sorted(origins)) == axis_0_positions
+
+    def testWithScans(self):
+        axis_0_positions = (0, 10, 20, 34)
+        scans = _createScans(axis_0_positions=axis_0_positions, root_dir=self._tmp_path)
+        self.widget.setActive(False)
+        self.widget.setTomoObjs(scans)
+        assert len(self.widget.getAllImages()) == 0
+        self.widget.setActive(True)
+        self.qapp.processEvents()
+        assert len(self.widget.getAllImages()) == len(scans)
+
+
+class TestAlphaValuesTableWidget(TestCaseQt):
+    """test AlphaValuesTableWidget"""
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.widget = AlphaValuesTableWidget()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self._tmp_path)
+
+    def testSettingTomoObj(self):
+        self.widget.setTomoObjs(
+            _createVolumes(axis_0_positions=(0, 12, 50), root_dir=self._tmp_path),
+        )
+
+        assert len(self.widget._sliders) == 3
+        self.widget.setTomoObjs(
+            _createScans(axis_0_positions=(89, 78), root_dir=self._tmp_path)
+        )
+        assert len(self.widget._sliders) == 2