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

tomwer/gui/utils/inputwidget.py

@@ -246,49 +246,60 @@ class ListSelAction(SelectionAction):
 
 
 class NXTomomillOutputDirSelector(qt.QWidget):
-
     sigChanged = qt.Signal()
     """Signal emit when the output directory of the nx file change"""
 
+    DEFAULT_PROCESSED_DIR = (
+        "{scan_parent_dir_basename}/../PROCESSED_DATA/{scan_dir_name}"
+    )
+    """Default pattern to find the 'processed' directory"""
+
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QGridLayout())
         self.__buttonGroup = qt.QButtonGroup(self)
         self.__buttonGroup.setExclusive(True)
 
-        # automatic
-        self._automaticRB = qt.QRadioButton("automatic", self)
-        self._automaticRB.setToolTip(
-            "Define the output directory of the "
-            "nexus (.nx) file. Will be created at the"
-            " same level as the bliss input file "
-            "(.h5)"
-        )
-        self.layout().addWidget(self._automaticRB, 0, 0, 1, 1)
-        self.__buttonGroup.addButton(self._automaticRB)
+        tooltip = f"""Define the output directory of the nexus (.nx) file. Options are:
+        \n - next to bliss file: create the NXtomos at the same level as the bliss input file
+        \n - 'PROCESSED_DATA' folder: create NXtomos on the default 'PROCESSED_DATA' folder (bliss default folder, nearby the 'raw' folder). Uses {self.DEFAULT_PROCESSED_DIR} pattern
+        \n - user defined folder: users can provide their own folders using keywords for string formatting such as 'scan_dir_name', 'scan_basename' or 'scan_parent_dir_basename'
+        """
+
+        # output dir is the folder containing the .nx file
+        self._closeToNxRB = qt.QRadioButton("next to bliss file", self)
+        self._closeToNxRB.setToolTip(tooltip)
+        self.layout().addWidget(self._closeToNxRB, 0, 0, 1, 1)
+        self.__buttonGroup.addButton(self._closeToNxRB)
+        # output dir is the default 'reduced'folder
+        self._processedFolderRB = qt.QRadioButton("'PROCESSED_DATA' folder", self)
+        self._processedFolderRB.setToolTip(tooltip)
+        self.layout().addWidget(self._processedFolderRB, 1, 0, 1, 1)
+        self.__buttonGroup.addButton(self._processedFolderRB)
         # manual
-        self._manualRB = qt.QRadioButton("personalized output directory", self)
-        self._manualRB.setToolTip("Define yourself the output directory")
-        self.layout().addWidget(self._manualRB, 1, 0, 1, 1)
+        self._manualRB = qt.QRadioButton("custom output directory", self)
+        self._manualRB.setToolTip(tooltip)
+        self.layout().addWidget(self._manualRB, 2, 0, 1, 1)
         self._outputFolderQLE = qt.QLineEdit("", self)
-        self.layout().addWidget(self._outputFolderQLE, 1, 1, 1, 1)
+        self.layout().addWidget(self._outputFolderQLE, 2, 1, 1, 1)
         self._selectButton = qt.QPushButton("", self)
         style = qt.QApplication.style()
         icon_opendir = style.standardIcon(qt.QStyle.SP_DirOpenIcon)
         self._selectButton.setIcon(icon_opendir)
         self._selectButton.setToolTip("select output directory")
-        self.layout().addWidget(self._selectButton, 1, 2, 1, 1)
+        self.layout().addWidget(self._selectButton, 2, 2, 1, 1)
         self.__buttonGroup.addButton(self._manualRB)
 
         # connect signal / slot
         self._selectButton.released.connect(self._selectOutpuFolder)
         self.__buttonGroup.buttonReleased.connect(self._updateVisiblity)
-        self._automaticRB.toggled.connect(self._outputDirChanged)
+        self._closeToNxRB.toggled.connect(self._outputDirChanged)
+        self._processedFolderRB.toggled.connect(self._outputDirChanged)
         self._manualRB.toggled.connect(self._outputDirChanged)
         self._outputFolderQLE.editingFinished.connect(self._outputDirChanged)
 
         # set up
-        self._automaticRB.setChecked(True)
+        self._closeToNxRB.setChecked(True)
         self._updateVisiblity()
 
     def _updateVisiblity(self, *args, **kwargs):
@@ -298,7 +309,7 @@ class NXTomomillOutputDirSelector(qt.QWidget):
     def _outputDirChanged(self):
         self.sigChanged.emit()
 
-    def _selectOutpuFolder(self):
+    def _selectOutpuFolder(self):  # pragma: no cover
         defaultDirectory = self._outputFolderQLE.text()
         if os.path.isdir(defaultDirectory):
             defaultDirectory = get_default_directory()
@@ -316,14 +327,23 @@ class NXTomomillOutputDirSelector(qt.QWidget):
     def getOutputFolder(self) -> Union[None, str]:
         if self._manualRB.isChecked():
             return self._outputFolderQLE.text()
+        elif self._processedFolderRB.isChecked():
+            return self.DEFAULT_PROCESSED_DIR
         else:
             return None
 
     def setOutputFolder(self, output_folder: Optional[str]):
         old = self.blockSignals(True)
         self._manualRB.setChecked(output_folder is not None)
-        if output_folder is not None:
-            self._outputFolderQLE.setText(output_folder)
+        if output_folder is None:
+            self._closeToNxRB.setChecked()
+        else:
+            is_default_processed_folder = output_folder == self.DEFAULT_PROCESSED_DIR
+            if is_default_processed_folder:
+                self._processedFolderRB.setChecked(True)
+            else:
+                self._outputFolderQLE.setText(output_folder)
+                self._manualRB.setChecked(True)
         self._updateVisiblity()
         self.blockSignals(old)
 
@@ -360,7 +380,7 @@ class _ConfigFileSelector(qt.QWidget):
     def _clearFilePath(self):
         self._lineEdit.clear()
 
-    def _selectCFGFile(self):
+    def _selectCFGFile(self):  # pragma: no cover
         dialog = qt.QFileDialog(self)
         dialog.setFileMode(qt.QFileDialog.ExistingFile)
 

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: