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

tomwer/gui/stitching/preview.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from silx.gui import qt
+from nabu.stitching.config import dict_to_config_obj
+from nabu.stitching.stitcher.z_stitcher import (
+    PreProcessingZStitcher,
+    PostProcessingZStitcher,
+)
+from nabu.stitching.stitcher.y_stitcher import PreProcessingYStitcher
+
+
+class PreviewThread(qt.QThread):
+    """
+    Thread to compute an overview of the stitching
+    """
+
+    def __init__(self, stitching_config: dict, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._stitching_config = dict_to_config_obj(stitching_config)
+        self._output_identifier = None
+        self._frame_composition = None
+        self._final_tomo_objs_positions = None
+        # store position of all the tomo objects (scan, volumes) used for the final stitching (after shift refinement)
+
+    @property
+    def stitching_config(self):
+        return self._stitching_config
+
+    @property
+    def output_identifier(self):
+        return self._output_identifier
+
+    @property
+    def frame_composition(self):
+        return self._frame_composition
+
+    @property
+    def final_tomo_objs_positions(self) -> dict:
+        """
+        :return: dict with tomo object identifier (str) as key and a tuple of position in pixel (axis_0_pos, axis_1_pos, axis_2_pos)
+        """
+        return self._final_tomo_objs_positions
+
+    def run(self):
+        stitching_type = self.stitching_config.stitching_type
+        if stitching_type.value == "z-preproc":
+            stitcher = PreProcessingZStitcher(configuration=self.stitching_config)
+        elif stitching_type.value == "z-postproc":
+            stitcher = PostProcessingZStitcher(configuration=self.stitching_config)
+        elif stitching_type.value == "y-preproc":
+            stitcher = PreProcessingYStitcher(configuration=self.stitching_config)
+        else:
+            raise NotImplementedError
+        self._output_identifier = stitcher.stitch()
+        if self._output_identifier is not None:
+            self._output_identifier = self._output_identifier.to_str()
+        # store in cache the frame composition to be able to provide them to the PreviewPlot
+        self._frame_composition = stitcher.frame_composition
+        self._final_tomo_objs_positions = stitcher.get_final_axis_positions_in_px()

tomwer/gui/stitching/singleaxis.py

@@ -0,0 +1,57 @@
+"""Define Interface for widget handling stitching over one axis"""
+
+from __future__ import annotations
+
+from silx.gui import qt
+
+
+class _SingleAxisMixIn:
+    """Common API for widget able to handle stitching over one axis (no matter if it is 0, 1, 2 (aka z, y, x))"""
+
+    @property
+    def first_axis(self) -> int:
+        """
+        Axis along which stitching is done. For stitching along z will return 0...
+        """
+        return self._axis
+
+    @property
+    def second_axis(self) -> int:
+        """
+        second axis involved in the stitching. In case of stitching along axis 0 the axis 1can also be involved (axis present in the camera reference)
+        """
+        if self._axis == 0:
+            return 1
+        elif self._axis == 1:
+            return 0
+        else:
+            raise NotImplementedError
+
+    @property
+    def third_axis(self):
+        all_axis = {(0, 1, 2)}
+        all_axis.remove(self.first_axis)
+        all_axis.remove(self.second_axis)
+        return all_axis.pop()
+
+    @staticmethod
+    def axis_alias(axis: int):
+        if axis == 0:
+            return "z"
+        elif axis == 1:
+            return "y"
+        elif axis == 2:
+            return "z"
+        else:
+            raise ValueError(f"axis should be in (0, 1, 2). {axis} given")
+
+
+class SingleAxisMetaClass(type(qt.QMainWindow), type(_SingleAxisMixIn)):
+    """
+    Metaclass for single axis stitcher in order to aggregate dumper class and axis
+    """
+
+    def __new__(mcls, name, bases, attrs, axis: int | None = None):
+        mcls = super().__new__(mcls, name, bases, attrs)
+        mcls._axis = axis  # used from _SingleAxisMixIn interface
+        return mcls

tomwer/gui/stitching/stitchandbackground.py

@@ -1,4 +1,5 @@
-from typing import Optional
+from __future__ import annotations
+
 from silx.gui import qt
 from silx.gui.colors import Colormap
 from tomwer.gui import icons as tomwer_icons
@@ -89,7 +90,7 @@ class StitchAndBackgroundAlphaMixIn:
         else:
             return 1.0
 
-    def getBackgroundImgAlpha(self) -> Optional[float]:
+    def getBackgroundImgAlpha(self) -> float | None:
         """return 0.0 if there is no background image"""
         if self._backGroundAction.isChecked():
             return self._alphaChannelWidget.getAlphaBackgroundImg()

tomwer/gui/stitching/stitching_preview.py

@@ -1,8 +1,14 @@
+from __future__ import annotations
+
 import logging
-from typing import Union
 
 import numpy
-from nabu.stitching.frame_composition import ZFrameComposition
+
+try:
+    # nabu 2024
+    from nabu.stitching.frame_composition import ZFrameComposition as FrameComposition
+except ImportError:
+    from nabu.stitching.frame_composition import FrameComposition
 from silx.gui import qt
 from tomwer.gui.utils.buttons import TapeMeasureToolButton
 from tomoscan.esrf.scan.utils import get_data
@@ -61,12 +67,13 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
     DEFAULT_STITCHED_IMG_ALPHA = 0.95
     DEFAULT_BACKGROUND_IMG_ALPHA = 0.20
 
-    def __init__(self, parent=None) -> None:
+    def __init__(self, axis: int, parent=None) -> None:
         super().__init__(parent=parent)  # pylint: disable=E1123
         self._waitingOverlay = WaitingOverlay(self)
         self._waitingOverlay.setIconSize(qt.QSize(30, 30))
         self._stitched_image = None
         self._composition_background = None
+        self._axis = axis
 
         # tune plot
         self.setYAxisInverted(settings.Y_AXIS_DOWNWARD)
@@ -82,7 +89,7 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
         self.setKeepDataAspectRatio(True)
         self.getColorBarWidget().hide()
 
-        # tape mesure action
+        # tape measure action
         self._tapeMeasureButton = TapeMeasureToolButton(parent=self, plot=self)
         self._tapeMeasureButton.setCheckable(True)
         self.toolBar().addWidget(self._tapeMeasureButton)
@@ -107,6 +114,10 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
         # connect signal / slot
         self._backGroundAction.toggled.connect(self._update)
 
+    @property
+    def axis(self) -> int:
+        return self._axis
+
     def _popCurrentImageFullScreen(self):
         from tomwer.gui.visualization.fullscreenplot import FullScreenStitching
 
@@ -119,40 +130,39 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
         new_plot.setAlphaStitchedImg(self.getStitchedImgAlpha())
         new_plot.setWindowTitle("Stitching")
 
-        # reuse the same colormap for conveniance (user modification on it will be applied everywhere)
+        # reuse the same colormap for convenience (user modification on it will be applied everywhere)
         new_plot.setDefaultColormap(self.getDefaultColormap())
         new_plot.showFullScreen()
 
-    def setComposition(self, composition: dict, frame_width: int, update=True):
+    def setComposition(self, composition: dict, shape: tuple, update=True):
         self._composition_background = self.buildCompositionBackground(
-            composition, frame_width=frame_width
+            composition,
+            shape=shape,
+            axis=self.axis,
         )
         if update:
             self._updatePlot()
 
     @staticmethod
-    def buildCompositionBackground(composition, frame_width):
-        if "raw_compositon" not in composition:
+    def buildCompositionBackground(composition, shape: tuple, axis: int):
+        assert axis in (0, 1, 2)
+        if "raw_composition" not in composition:
             raise KeyError(
-                "composition is expected to have a 'raw_compositon' key with {ZFrameComposition} describing raw composition as key"
+                "composition is expected to have a 'raw_composition' key with {FrameComposition} describing raw composition as key"
             )
         else:
-            raw_compositon = composition["raw_compositon"]
-            assert isinstance(raw_compositon, ZFrameComposition)
-        if "overlap_compositon" not in composition:
+            raw_composition = composition["raw_composition"]
+            assert isinstance(raw_composition, FrameComposition)
+        if "overlap_composition" not in composition:
             raise KeyError(
-                "composition is expected to have a 'overlap_compositon' key with {ZFrameComposition} describing overlap composition as key"
+                "composition is expected to have a 'overlap_composition' key with {FrameComposition} describing overlap composition as key"
             )
         else:
-            overlap_compositon = composition["overlap_compositon"]
-            assert isinstance(overlap_compositon, ZFrameComposition)
+            overlap_composition = composition["overlap_composition"]
+            assert isinstance(overlap_composition, FrameComposition)
 
         background = numpy.zeros(
-            shape=(
-                (raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0]),
-                frame_width,
-                4,
-            ),
+            shape=shape,
         )
         assert background.ndim == 3
 
@@ -165,30 +175,26 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
                 yield magenta.red(), magenta.green(), magenta.blue(), 255
                 yield blue.red(), blue.green(), blue.blue(), 255
 
+        # composition is always done along y (in image space). So for stitching along y (in nxtomo space) we need to flip the two axis to apply the composition
+        print("shape is", shape)
         colors_raw_frames = []
-        for _, color in zip(raw_compositon.local_end_y, get_next_color()):
+        for _, color in zip(raw_composition.local_end, get_next_color()):
             colored_frame = numpy.full(
-                shape=(
-                    raw_compositon.global_end_y[-1] - raw_compositon.global_start_y[0],
-                    frame_width,
-                    4,
-                ),
+                shape=shape,
                 fill_value=color,
             )
             colors_raw_frames.append(colored_frame)
 
-        overlap_compositon.compose(
+        overlap_composition.compose(
             background,
             colors_raw_frames,
         )
         return background
 
-    def setStitchedTomoObj(
-        self, tomo_obj_id: Union[BaseIdentifier, str], composition: dict
-    ):
+    def setStitchedTomoObj(self, tomo_obj_id: BaseIdentifier | str, composition: dict):
         """
-        :param BaseIdentifier tomo_obj_id: identifier of the stitched object (scan of volume)
-        :param dict composition: composition used to create the stitched object
+        :param tomo_obj_id: identifier of the stitched object (scan of volume)
+        :param composition: composition used to create the stitched object
         """
         if not isinstance(tomo_obj_id, (BaseIdentifier, str)):
             raise TypeError(
@@ -207,7 +213,7 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
                 pass
 
         if scan is not None:
-            if len(scan.projections) == 0:
+            if scan.projections is None or len(scan.projections) == 0:
                 _logger.error(
                     f"stitched scan {tomo_obj_id} doesn't contains any projections"
                 )
@@ -229,7 +235,9 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
 
         assert self._stitched_image.ndim == 2
         self._composition_background = self.buildCompositionBackground(
-            composition=composition, frame_width=self._stitched_image.shape[1]
+            composition=composition,
+            shape=(self._stitched_image.shape[0], self._stitched_image.shape[1], 4),
+            axis=self.axis,
         )
         self._update()
 
@@ -241,6 +249,6 @@ class PreviewStitchingPlot(Plot2D, StitchAndBackgroundAlphaMixIn):
     def stitched_image(self):
         return self._stitched_image
 
-    def setPixelSize(self, pixel_size: Union[tuple, float]):
+    def setPixelSize(self, pixel_size: tuple | float):
         """set the pixel size to be used by the ruler"""
         self._tapeMeasureButton.setPixelSize(pixel_size_m=pixel_size)

tomwer/gui/stitching/stitching_raw.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import logging
 import weakref
 import numpy
-from typing import Any, Union, Optional
+from typing import Any
 from contextlib import AbstractContextManager
 
 from silx.gui import qt
@@ -109,7 +111,7 @@ class RawStitchingPlot(PlotWindow):
             self._flipudFrames = flip
             self._updateImages()
 
-    def setSliceForPreview(self, slice_for_preview: Union[str, int]):
+    def setSliceForPreview(self, slice_for_preview: str | int):
         if self._slice_for_preview != slice_for_preview:
             self._slice_for_preview = slice_for_preview
             self._updateImages()
@@ -127,7 +129,7 @@ class RawStitchingPlot(PlotWindow):
         return self._activated
 
     @staticmethod
-    def getMinAxisPosition(tomo_obj: Optional[TomwerObject], axis):
+    def getMinAxisPosition(tomo_obj: TomwerObject | None, axis):
         if tomo_obj is None or tomo_obj.stitching_metadata is None:
             return 0
         else:

tomwer/gui/stitching/tests/test_ZStitchingWindow.py

@@ -0,0 +1,88 @@
+import os
+import tempfile
+
+from tomoscan.series import Series
+
+from tomwer.gui.stitching.StitchingWindow import ZStitchingWindow
+from tomwer.gui.stitching.tests.utils import create_scans_z_series
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_ZStitchingWindow(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    """
+    Test ZStitchingWindow
+
+    * adding tom objects
+    * saving and loading settings (nabu-stitching configuration)
+    * editing tomo objects positions over stitching axis
+    * reset tomo objects positions
+    """
+
+    window = ZStitchingWindow()
+
+    axis_0_positions = (90, 0.0, -90.0)
+    axis_2_positions = (0.0, 0.0, 0.0)
+    pixel_size = 1.0
+
+    input_dir = os.path.join(tmp_path, "input")
+
+    scans = create_scans_z_series(
+        output_dir=input_dir,
+        z_positions_m=axis_0_positions,
+        x_positions_m=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,
+    )
+    series = Series("z-series", scans)
+
+    window.show()
+    for scan in scans:
+        window.addTomoObj(scan)
+    window.clean()
+    window.setSeries(series)
+
+    # test dumping and loading configuration to a file
+    with tempfile.TemporaryDirectory() as dump_dir:
+        config_file = os.path.join(dump_dir, "configuration.cfg")
+        window._saveSettings(file_path=config_file)
+        assert os.path.exists(config_file)
+        window._loadSettings(config_file)
+        # remove configuration
+        window.clean()
+        assert len(window._widget._mainWidget.getTomoObjs()) == 0
+        # reload it
+        window._loadSettings(file_path=config_file)
+        assert len(window._widget._mainWidget.getTomoObjs()) == len(series)
+
+    assert window.getConfiguration()["stitching"]["axis_0_pos_px"] == [90, 0, -90]
+
+    # test editing axis position
+    widget_tomo_obj_0 = (
+        window._editTomoObjFirstAxisPositionsWidget._tomoObjtoTomoObjPosWidget[
+            scans[0].get_identifier().to_str()
+        ]
+    )
+
+    window._editTomoObjFirstAxisPositionsWidget.setEditionMode("free")
+    widget_tomo_obj_0.setValue(10)
+    assert window.getConfiguration()["stitching"]["axis_0_pos_px"] == [10, 0, -90]
+    window._editTomoObjFirstAxisPositionsWidget.setEditionMode("downstream")
+    widget_tomo_obj_0.setValue(30)
+    assert window.getConfiguration()["stitching"]["axis_0_pos_px"] == [30, 20, -70]
+    window._editTomoObjFirstAxisPositionsWidget.setEditionMode("upstream")
+    widget_tomo_obj_2 = (
+        window._editTomoObjFirstAxisPositionsWidget._tomoObjtoTomoObjPosWidget[
+            scans[2].get_identifier().to_str()
+        ]
+    )
+    widget_tomo_obj_2.setValue(-120)
+    assert window.getConfiguration()["stitching"]["axis_0_pos_px"] == [-20, -30, -120]
+
+    # test reset positions to initial positions
+    window._editTomoObjFirstAxisPositionsWidget._resetPositions()
+    assert window.getConfiguration()["stitching"]["axis_0_pos_px"] == [90, 0, -90]

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 EditableOrderedTomoObjWidget
+
+
+def test_axis_ordered_list_widget(
+    qtapp,  # noqa F811
+):
+    widget = EditableOrderedTomoObjWidget(axis=0)
+    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.getTomoObjsAxisOrdered() == (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,68 @@
+import os
+
+import numpy
+import pytest
+from nabu.stitching.config import PreProcessedZStitchingConfiguration
+from nabu.stitching.z_stitching import PreProcessZStitcher
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+from silx.image.phantomgenerator import PhantomGenerator
+
+from tomwer.gui.stitching.stitching_preview import PreviewStitchingPlot
+from tomwer.gui.stitching.tests.utils import create_scans_z_series
+
+
+@pytest.mark.parametrize("flip_lr", (True, False))
+@pytest.mark.parametrize("flip_ud", (True, False))
+def test_preview(tmp_path, flip_lr, flip_ud, qtapp):  # noqa F401
+    axis_0_positions = (90, 0.0, -90.0)
+    axis_2_positions = (0.0, 0.0, 0.0)
+    pixel_size = 1.0
+
+    output_file_path = os.path.join(str(tmp_path), "output", "stitched.nx")
+    input_dir = os.path.join(tmp_path, "input")
+
+    scans = create_scans_z_series(
+        output_dir=input_dir,
+        z_positions_m=axis_0_positions,
+        x_positions_m=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,
+        flip_lr=flip_lr,
+        flip_ud=flip_ud,
+    )
+    stitching_config = PreProcessedZStitchingConfiguration(
+        output_file_path=output_file_path,
+        output_data_path="entry_stitched",
+        overwrite_results=True,
+        slurm_config=None,
+        axis_0_pos_mm=numpy.array(axis_0_positions) / 1000,
+        axis_2_pos_mm=numpy.array(axis_2_positions) / 1000,
+        axis_0_pos_px=None,
+        axis_1_pos_px=None,
+        axis_2_pos_px=None,
+        input_scans=scans,
+        pixel_size=pixel_size,
+    )
+    widget = PreviewStitchingPlot(axis=0)
+
+    widget._backGroundAction.toggle()
+
+    stitcher = PreProcessZStitcher(configuration=stitching_config)
+    stitched_id = stitcher.stitch(store_composition=True)
+    assert stitched_id is not None
+    composition = stitcher.frame_composition
+    assert composition is not None
+
+    widget.setStitchedTomoObj(tomo_obj_id=stitched_id.to_str(), composition=composition)
+    assert widget.stitched_image is not None
+    assert widget.composition_background is not None
+
+    numpy.testing.assert_almost_equal(
+        widget.stitched_image,
+        PhantomGenerator.get2DPhantomSheppLogan(n=280).astype(numpy.float32) * 256.0,
+    )
+
+    widget._backGroundAction.toggle()

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