tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

tomwer/gui/utils/lineselector/lineselector.py

@@ -31,7 +31,7 @@ __date__ = "15/09/2017"
 import logging
 from silx.gui import qt
 from silx.gui.plot import PlotWidget
-from typing import Union
+from typing import Union, Optional
 from collections.abc import Iterable
 from collections import OrderedDict
 import numpy
@@ -50,7 +50,6 @@ class QSliceSelectorDialog(qt.QDialog):
 
     def __init__(self, parent, n_required_slice=None):
         qt.QDialog.__init__(self, parent=parent)
-        self.__selection = None
         self.setLayout(qt.QVBoxLayout())
         self.setWindowTitle("select slices on radio")
 
@@ -87,14 +86,11 @@ class QSliceSelectorDialog(qt.QDialog):
             selection = selection.replace(")", "")
             selection = selection.replace(" ", "")
             selection = selection.replace(",", ";")
-            self.__selection = []
-            for val in selection.split(";"):
-                try:
-                    self.__selection.append(int(val))
-                except ValueError:
-                    pass
-        else:
-            self.__selection = selection
+            try:
+                selection = [int(item) for item in selection.split(";")]
+            except Exception as e:
+                logger.error(f"Fail to set selection. Error is {e}")
+        self.mainWidget.setSelection(selection)
 
     def getSelection(self) -> tuple:
         """
@@ -102,7 +98,7 @@ class QSliceSelectorDialog(qt.QDialog):
         :return: the selection of slices to use
         :rtype: tuple
         """
-        return self.__selection
+        return self.mainWidget.getSelection()
 
     def exec_(self):
         if not self.mainWidget._has_data:
@@ -111,13 +107,9 @@ class QSliceSelectorDialog(qt.QDialog):
             qt.QMessageBox.warning(self, "Selection tool not available", mess)
             self.reject()
         else:
-            self.mainWidget.setSelection(self.__selection)
-            res = qt.QDialog.exec_(self)
-            if res == qt.QDialog.Accepted:
-                self.setSelection(self.mainWidget.getSelection())
-            return res
+            return qt.QDialog.exec_(self)
 
-    def nRequiredSlice(self) -> Union[None, int]:
+    def nRequiredSlice(self) -> Optional[int]:
         return self.mainWidget.nRequiredSlice()
 
 
@@ -139,7 +131,7 @@ class QLineSelector(qt.QWidget):
         # connect signal / slot
         self._plot.sigPlotSignal.connect(self._plotDrawEvent)
 
-    def nRequiredSlice(self) -> Union[None, int]:
+    def nRequiredSlice(self) -> Optional[int]:
         return self._n_required_slice
 
     def setData(self, data: numpy.ndarray):
@@ -160,7 +152,7 @@ class QLineSelector(qt.QWidget):
         :rtype: tuple
         """
         res = []
-        for legend, marker in self.__selection.items():
+        for _, marker in self.__selection.items():
             res.append(int(marker.getPoints()[0][1]))
         return tuple(sorted(res))
 
@@ -200,8 +192,8 @@ class QLineSelector(qt.QWidget):
                 logger.warning("requested slice out of the data, ignored")
                 return
 
-        while self.nSelected() >= self.nRequiredSlice():
-            self.removeSlice(row=int(list(self.__selection.items())[0][0]))
+        # while self.nSelected() >= self.nRequiredSlice():
+        #     self.removeSlice(row=int(list(self.__selection.items())[0][0]))
 
         inf = 10000
         legend = self._getLegend(row_n=row_n)

tomwer/gui/utils/scandescription.py

@@ -29,8 +29,6 @@ __date__ = "04/02/2020"
 
 from typing import Optional
 from silx.gui import qt
-import os
-
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 
@@ -66,8 +64,8 @@ class ScanNameLabelAndShape(qt.QWidget):
             self.clear()
         else:
             assert isinstance(scan, TomwerScanBase)
-            self._scanNameLabel.setText(os.path.basename(scan.path))
-            self._scanNameLabel.setToolTip(scan.path)
+            self._scanNameLabel.setText(scan.get_identifier().short_description())
+            self._scanNameLabel.setToolTip(scan.get_identifier().to_str())
 
             shape_x = scan.dim_1 if scan.dim_1 is not None else "?"
             shape_y = scan.dim_2 if scan.dim_2 is not None else "?"

tomwer/gui/utils/slider.py

@@ -29,8 +29,8 @@ __license__ = "MIT"
 __date__ = "17/02/2021"
 
 
-from silx.gui import qt
 import numpy
+from silx.gui import qt
 
 
 class LogSlider(qt.QWidget):
@@ -92,104 +92,3 @@ class LogSlider(qt.QWidget):
 
     def setValue(self, value):
         self._valueQBSB.setValue(value)
-
-
-class _TickBar(qt.QWidget):
-    _FONT_SIZE = 6
-
-    def __init__(self, parent=None):
-        qt.QWidget.__init__(self, parent)
-        self._min = 1
-        self._max = 100
-        self._ticks = {}
-
-    def setRange(self, min_, max_):
-        self._min = min_
-        self._max = max_
-        tick_names = self._ticks.values()
-        for tick_name in tick_names:
-            tick_value = self._ticks[tick_name]
-            self._ticks[tick_name] = min(max(self._min, tick_value), self._max)
-
-    def addTick(self, name, value):
-        value = min(max(self._valueQBSB.minimum(), value), self._valueQBSB.maximum())
-        self._ticks[name] = value
-
-    def paintEvent(self, event):
-        painter = qt.QPainter(self)
-        font = painter.font()
-        font.setPixelSize(_TickBar._FONT_SIZE)
-        painter.setFont(font)
-
-        # paint ticks
-        for tick_name, tick_value in self._ticks.items():
-            self._paintTick(tick_value, painter, majorTick=True)
-
-    def _getRelativePosition(self, val):
-        """Return the relative position of val according to min and max value"""
-        if self._normalizer is None:
-            return 0.0
-        normMin, normMax, normVal = self._normalizer.apply(
-            [self._vmin, self._vmax, val], self._vmin, self._vmax
-        )
-
-        if normMin == normMax:
-            return 0.0
-        else:
-            return 1.0 - (normVal - normMin) / (normMax - normMin)
-
-    def _paintTick(self, val, painter, majorTick=True):
-        """
-
-        :param bool majorTick: if False will never draw text and will set a line
-            with a smaller width
-        """
-        fm = qt.QFontMetrics(painter.font())
-        viewportHeight = self.rect().height() - self.margin * 2 - 1
-        relativePos = self._getRelativePosition(val)
-        height = int(viewportHeight * relativePos + self.margin)
-        lineWidth = _TickBar._LINE_WIDTH
-        if majorTick is False:
-            lineWidth /= 2
-
-        painter.drawLine(
-            qt.QLine(int(self.width() - lineWidth), height, self.width(), height)
-        )
-
-        if self.displayValues and majorTick is True:
-            painter.drawText(
-                qt.QPoint(0, int(height + fm.height() / 2)), self.form.format(val)
-            )
-
-
-class LogSliderWithTick(LogSlider):
-    def __init__(self, parent=None):
-        super().__init__(parent=parent)
-        # register ticks to be displayed with name as key and value as value
-        # Double spin box
-        self._ticksBar = _TickBar(self)
-        self.layout().addWidget(self._ticksBar, 1, 0, 1, 1)
-
-    def addTick(self, name, value):
-        self._ticksBar.addTick(name, value)
-
-    def setRange(self, min_: float, max_: float) -> None:
-        super().setRange(min_=min_, max_=max_)
-        if hasattr(self, "_ticksBar"):
-            self._ticksBar.setRange(min_=min_, max_=max_)
-
-    def clearTicks(self):
-        self._ticks.clear()
-
-
-if __name__ == "__main__":
-    app = qt.QApplication([])
-    slider = LogSliderWithTick()
-    slider.setFixedWidth(250)
-    # slider.addTick("toto", 1)
-    # slider.addTick("tata", 10)
-    # slider.addTick("titi", 100)
-    slider.setRange(0.01, 1000)
-    slider.setValue(10)
-    slider.show()
-    app.exec_()

tomwer/gui/utils/unitsystem.py

@@ -34,6 +34,7 @@ __date__ = "21/09/2018"
 
 from silx.gui import qt
 from tomoscan.unitsystem import metricsystem
+from tomwer.core.utils.char import MU_CHAR
 import logging
 
 _logger = logging.getLogger(__name__)
@@ -48,8 +49,20 @@ class MetricEntry(qt.QWidget):
     :param str: base_unit. Default way to present a value when setted
     """
 
+    class DoubleValidator(qt.QDoubleValidator):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.setNotation(qt.QDoubleValidator.ScientificNotation)
+
+        def validate(self, a0: str, a1: int):
+            if a0 == "unknown":
+                return (qt.QDoubleValidator.Acceptable, a0, a1)
+            else:
+                return super().validate(a0, a1)
+
     _CONVERSION = {
         "nm": metricsystem.nanometer.value,
+        f"{MU_CHAR}m": metricsystem.micrometer.value,
         "mm": metricsystem.millimeter.value,
         "cm": metricsystem.centimeter.value,
         "m": metricsystem.meter.value,
@@ -58,24 +71,29 @@ class MetricEntry(qt.QWidget):
     def __init__(self, name, default_unit="m", parent=None):
         qt.QWidget.__init__(self, parent)
         assert type(default_unit) is str
-        assert default_unit in ("nm", "mm", "cm", "m")
+        assert default_unit in ("nm", "mm", "cm", "m", f"{MU_CHAR}m")
         self._base_unit = default_unit
 
         self.setLayout(qt.QHBoxLayout())
         self._label = qt.QLabel(name, parent=self)
         self.layout().addWidget(self._label)
         self._qlePixelSize = qt.QLineEdit("0.0", parent=self)
-        self._qlePixelSize.setValidator(qt.QDoubleValidator(self._qlePixelSize))
+        self._qlePixelSize.setValidator(self.DoubleValidator(self._qlePixelSize))
         self.layout().addWidget(self._qlePixelSize)
 
         self._qcbUnit = qt.QComboBox(parent=self)
         self._qcbUnit.addItem("nm")
+        self._qcbUnit.addItem(f"{MU_CHAR}m")
         self._qcbUnit.addItem("mm")
         self._qcbUnit.addItem("cm")
         self._qcbUnit.addItem("m")
         self.layout().addWidget(self._qcbUnit)
         self._resetBaseUnit()
 
+    def setReadOnly(self, a0: bool):
+        self._qlePixelSize.setReadOnly(a0)
+        self._qcbUnit.setEnabled(not a0)
+
     def getCurrentUnit(self):
         assert self._qcbUnit.currentText() in self._CONVERSION
         return self._CONVERSION[self._qcbUnit.currentText()]
@@ -86,14 +104,22 @@ class MetricEntry(qt.QWidget):
         :param float value: pixel size in international metric system (meter)
         """
         _value = value
-        if type(_value) is str:
-            try:
-                _value = float(_value)
-            except Exception as error:
-                raise ValueError("Given string does not represent a float", error)
-                return
-        assert isinstance(_value, float)
-        self._qlePixelSize.setText(str(_value))
+        if _value in (None, "unknown"):
+            txt = "unknown"
+        elif isinstance(_value, str):
+            if "..." in _value:
+                txt = _value
+            else:
+                try:
+                    _value = float(_value)
+                except Exception as error:
+                    raise ValueError("Given string does not represent a float", error)
+                else:
+                    assert isinstance(_value, float)
+                    txt = str(_value)
+        else:
+            txt = str(_value)
+        self._qlePixelSize.setText(txt)
         self._resetBaseUnit()
 
     def _resetBaseUnit(self):
@@ -110,7 +136,18 @@ class MetricEntry(qt.QWidget):
         :return: the value in meter
         :rtype: float
         """
-        return float(self._qlePixelSize.text()) * self.getCurrentUnit()
+        if self._qlePixelSize.text() in ("unknown", ""):
+            return None
+        else:
+            return float(self._qlePixelSize.text()) * self.getCurrentUnit()
+
+    def setValidator(self, validator):
+        self._qlePixelSize.setValidator(validator)
+
+    def setUnit(self, unit):
+        unit = str(metricsystem.MetricSystem.from_value(unit))
+        idx = self._qcbUnit.findText(unit)
+        self._qcbUnit.setCurrentIndex(idx)
 
 
 class CentimeterEntry(MetricEntry):

tomwer/gui/visualization/dataviewer.py

@@ -45,14 +45,14 @@ from tomwer.core.volume.volumefactory import VolumeFactory
 
 try:
     from PIL import Image
-except ImportError:
-    has_PIL = False
+except ImportError:  # pragma: no cover
+    has_PIL = False  # pragma: no cover
 else:
     has_PIL = True
 try:
-    import cv2
-except ImportError:
-    has_cv2 = False
+    import cv2  # pragma: no cover
+except ImportError:  # pragma: no cover
+    has_cv2 = False  # pragma: no cover
 else:
     has_cv2 = True
 import numpy
@@ -97,8 +97,10 @@ class DataViewer(qt.QMainWindow):
         self._controls = DisplayControl(parent=self)
         self._controlsDW = qt.QDockWidget(self)
         self._controlsDW.setWidget(self._controls)
-        self._controlsDW.setFeatures(qt.QDockWidget.DockWidgetMovable)
+        self._controlsDW.setWindowTitle("infos")
         self.addDockWidget(qt.Qt.TopDockWidgetArea, self._controlsDW)
+        self._controlsDW.setTitleBarWidget(qt.QWidget(self))
+        self._controlsDW.setFloating(False)
 
         # connect signal / slot
         self._controls.sigDisplayModeChanged.connect(self._updateDisplay)
@@ -220,6 +222,12 @@ class DataViewer(qt.QMainWindow):
             elif self.getDisplayMode() is _DisplayMode.FLATS:
                 self._viewer.setNormalizationFct(None)
                 slices = self._scan().flats
+            elif self.getDisplayMode() is _DisplayMode.REDUCED_DARKS:
+                self._viewer.setNormalizationFct(None)
+                slices = self._scan().load_reduced_darks(return_as_url=True)
+            elif self.getDisplayMode() is _DisplayMode.REDUCED_FLATS:
+                self._viewer.setNormalizationFct(None)
+                slices = self._scan().load_reduced_flats(return_as_url=True)
             else:
                 raise ValueError("DisplayMode should be RADIOS or SLICES")
 
@@ -250,8 +258,10 @@ class DataViewer(qt.QMainWindow):
 class _DisplayMode(_Enum):
     RADIOS = "projections-radios"
     SLICES = "slices"
-    DARKS = "darks"
-    FLATS = "flats"
+    DARKS = "raw darks"
+    FLATS = "raw flats"
+    REDUCED_DARKS = "reduced darks"
+    REDUCED_FLATS = "reduced flats"
 
 
 class _RadioMode(_Enum):
@@ -372,9 +382,12 @@ class DisplayControl(qt.QWidget):
             config = mode, self.getRadioOption()
         elif mode is _DisplayMode.SLICES:
             config = mode, self.getSliceOption()
-        elif mode is _DisplayMode.DARKS:
-            config = mode, None
-        elif mode is _DisplayMode.FLATS:
+        elif mode in (
+            _DisplayMode.DARKS,
+            _DisplayMode.FLATS,
+            _DisplayMode.REDUCED_DARKS,
+            _DisplayMode.REDUCED_FLATS,
+        ):
             config = mode, None
         else:
             raise ValueError("mode should be RADIOS or SLICES")
@@ -544,12 +557,6 @@ class _TomwerUrlLoader(UrlLoader):
     Thread use to load DataUrl
     """
 
-    def __init__(self, parent, url):
-        super(UrlLoader, self).__init__(parent=parent)
-        assert isinstance(url, DataUrl)
-        self.url = url
-        self.data = None
-
     def run(self):
         if self.url.file_path().endswith(".vol"):
             self.data = self._load_vol()

tomwer/gui/visualization/diffviewer/diffviewer.py

@@ -358,6 +358,7 @@ class DiffFrameViewer(qt.QMainWindow):
         self._framesSelector.setContentsMargins(0, 0, 0, 0)
         self._framesSelector.layout().setContentsMargins(0, 0, 0, 0)
         self._framesSelectorDW = qt.QDockWidget(parent=self)
+        self._framesSelectorDW.setWindowTitle("inputs")
         self._framesSelectorDW.setWidget(self._framesSelector)
         self._framesSelectorDW.setFeatures(qt.QDockWidget.DockWidgetMovable)
         self.addDockWidget(qt.Qt.TopDockWidgetArea, self._framesSelectorDW)
@@ -369,6 +370,7 @@ class DiffFrameViewer(qt.QMainWindow):
         self._shiftDW = qt.QDockWidget(parent=self)
         self._shiftDW.setWidget(self._shiftsWidget)
         self._shiftDW.setFeatures(qt.QDockWidget.DockWidgetMovable)
+        self._shiftDW.setWindowTitle("shifts")
         self.addDockWidget(qt.Qt.BottomDockWidgetArea, self._shiftDW)
 
         # define central widget
@@ -387,13 +389,6 @@ class DiffFrameViewer(qt.QMainWindow):
         toolbar.setFloatable(False)
         self.addToolBar(qt.Qt.TopToolBarArea, toolbar)
 
-        # add filtering
-        style = qt.QApplication.instance().style()
-        icon = style.standardIcon(qt.QStyle.SP_DialogResetButton)
-        self._clearAction = qt.QAction(icon, "Clear", toolbar)
-        toolbar.addAction(self._clearAction)
-        self._clearAction.triggered.connect(self.clear)
-
         # set up
         self._mainWidget.setAutoResetZoom(False)
         self._shiftsWidget.setFocus(qt.Qt.OtherFocusReason)
@@ -492,10 +487,6 @@ class DiffFrameViewer(qt.QMainWindow):
         )
         self._mainWidget.setImage2(shifted_image)
 
-    def clear(self):
-        self._framesSelector.clear()
-        self._mainWidget.getPlot().clear()
-
     def _frameShiftsChanged(self):
         self._resetLeftFrame()
         self._resetRightFrame()

tomwer/gui/visualization/nxtomometadata.py

@@ -0,0 +1,21 @@
+from silx.gui import qt
+from tomwer.gui.edit.nxtomoeditor import NXtomoEditor as _NXtomoEditor
+
+
+class NXtomoMetadataViewer(_NXtomoEditor):
+    """
+    class to display metadata of a NXtomo.
+    inherit from the `NXtomoEditor` and make sure not edition is possible
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        for widget in self.getEditableWidgets():
+            if isinstance(widget, (qt.QComboBox, qt.QCheckBox)):
+                widget.setEnabled(False)
+            else:
+                widget.setReadOnly(True)
+
+    def overwriteNXtomo(self):
+        """overwrite data on disk"""
+        raise NotImplementedError("viewer not editor")

tomwer/gui/visualization/scanoverview.py

@@ -95,7 +95,6 @@ class ScanOverviewWidget(qt.QWidget):
     def setScan(self, scan):
         if scan is None:
             self._scan = scan
-            self.clear()
         elif not isinstance(scan, TomwerScanBase):
             raise TypeError(f"{scan} is expected to be an instance of {TomwerScanBase}")
         else:

tomwer/gui/visualization/test/test_nx_tomo_metadata_viewer.py

@@ -0,0 +1,72 @@
+import os
+import pytest
+import numpy
+from tomoscan.esrf.scan.hdf5scan import ImageKey
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.gui.visualization.nxtomometadata import NXtomoMetadataViewer
+from nxtomomill.nexus.nxtomo import NXtomo
+from tomwer.tests.conftest import qtapp  # noqa F401
+from silx.gui import qt
+
+
+def test_nx_editor(
+    tmp_path,
+    qtapp,  # noqa F811
+):
+    # 1.0 create nx tomo with raw data
+    nx_tomo = NXtomo()
+    nx_tomo.instrument.detector.x_pixel_size = 2.6e-6
+    nx_tomo.instrument.detector.y_pixel_size = 2.5e-6
+    nx_tomo.instrument.detector.field_of_view = "Half"
+    nx_tomo.instrument.detector.distance = 59.0
+    nx_tomo.instrument.detector.x_flipped = True
+    nx_tomo.instrument.detector.y_flipped = False
+    nx_tomo.energy = 12.8
+    nx_tomo.sample.x_translation = numpy.arange(12)
+    nx_tomo.sample.z_translation = numpy.arange(2, 14)
+    nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
+    nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
+    nx_tomo.sample.rotation_angle = numpy.linspace(0, 180, num=12)
+
+    file_path = os.path.join(tmp_path, "nxtomo.nx")
+    entry = "entry0000"
+    nx_tomo.save(
+        file_path=file_path,
+        data_path=entry,
+    )
+
+    scan = HDF5TomoScan(file_path, entry)
+
+    # 2.0 create the widget and do the edition
+    widget = NXtomoMetadataViewer()
+    widget.setScan(scan=scan)
+    widget.show()
+
+    # 3.0 check data have been corrcetly loaded
+    def check_metric(expected_value, current_value):
+        if expected_value is None:
+            return current_value is None
+        return expected_value == current_value
+
+    assert check_metric(2.6e-6, widget._xPixelSizeMetricEntry.getValue())
+    assert widget._xPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+    assert check_metric(2.5e-6, widget._yPixelSizeMetricEntry.getValue())
+    assert widget._yPixelSizeMetricEntry._qcbUnit.currentText() == "m"
+
+    assert check_metric(59, widget._distanceMetricEntry.getValue())
+    assert widget._distanceMetricEntry._qcbUnit.currentText() == "m"
+
+    assert "Half" == widget._fieldOfViewCB.currentText()
+    assert widget._xFlippedCB.isChecked()
+    assert not widget._yFlippedCB.isChecked()
+
+    assert "12.8" == widget._energyQLE.text()
+
+    # make sure saving raises an error (viewer inherit from the editor)
+    with pytest.raises(NotImplementedError):
+        widget.overwriteNXtomo()
+
+    # end
+    widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+    widget.close()
+    widget = None

tomwer/gui/visualization/test/test_stacks.py

@@ -38,7 +38,7 @@ import logging
 import time
 import pytest
 from tomoscan.esrf.volume.edfvolume import EDFVolume
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 import weakref
 
 logging.disable(logging.INFO)

tomwer/gui/visualization/tomoobjoverview.py

@@ -0,0 +1,49 @@
+from .volumeoverview import VolumeOverviewWidget
+from .scanoverview import ScanOverviewWidget
+from silx.gui import qt
+from tomwer.core.tomwer_object import TomwerObject
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.scan.scanbase import TomwerScanBase
+from typing import Optional
+
+
+class TomoObjOverview(qt.QWidget):
+    """
+    Dummy widget to show ScanOverviewWidget if the object is a scan or VolumeOverviewWidget if the object is a Volume
+    """
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self.setLayout(qt.QVBoxLayout())
+        self._scanOverview = ScanOverviewWidget(self)
+        self.layout().addWidget(self._scanOverview)
+
+        self._volumeOverview = VolumeOverviewWidget(self)
+        self.layout().addWidget(self._volumeOverview)
+
+        self._scanOverview.setVisible(False)
+        self._volumeOverview.setVisible(False)
+
+    def setTomoObj(self, tomo_obj: Optional[TomwerObject]):
+        """
+        update sub widgets according to the type of tomo_obj
+        """
+        if tomo_obj is not None and not isinstance(tomo_obj, TomwerObject):
+            raise TypeError(
+                f"tomo_obj is expected to be an instance of {TomwerObject} and not {type(tomo_obj)}"
+            )
+        # handle visibility
+        self._volumeOverview.setVisible(isinstance(tomo_obj, TomwerVolumeBase))
+        self._scanOverview.setVisible(isinstance(tomo_obj, TomwerScanBase))
+
+        if isinstance(tomo_obj, TomwerVolumeBase):
+            self._scanOverview.setScan(None)
+            self._volumeOverview.setVolume(tomo_obj)
+        elif isinstance(tomo_obj, TomwerScanBase):
+            self._scanOverview.setScan(tomo_obj)
+            self._volumeOverview.setVolume(None)
+        elif tomo_obj is None:
+            self._volumeOverview.setVolume(None)
+            self._scanOverview.setScan(None)
+        else:
+            raise RuntimeError(f"TomwerObject of type {type(tomo_obj)} is not handled")