tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/utils/step.py

@@ -0,0 +1,144 @@
+import functools
+from silx.gui import qt
+from typing import Optional, Union
+from tomwer.gui.utils.qt_utils import block_signals
+
+
+class StepSizeSelectorWidget(qt.QGroupBox):
+    """
+    Widget to define some steps size (as float). Used by the Axis and the AxisOrdered widgets
+
+    :param str title: title to provide to the group box
+    :param str label: text for the label set at the left of the QLineEdit
+    :param fine_value: (optional) value to provide for 'fine' step
+    :param medium_value: (optional) value to provide for 'medium' step
+    :param rough_value: (optional) value to provide for 'rough' step
+    :param dtype: type of the step. Can be int or float
+    """
+
+    valueChanged = qt.Signal()
+
+    def __init__(
+        self,
+        parent=None,
+        title="",
+        label: str = "step size",
+        fine_value: [float, int, None] = 0.1,
+        medium_value: [float, int, None] = 0.5,
+        rough_value: [float, int, None] = 1.0,
+        unit: Optional[str] = "px",
+        dtype: Union[int, float] = float,
+    ):
+        assert fine_value is None or isinstance(
+            fine_value, dtype
+        ), f"fine_value is expected to be None or a {dtype}. Get {type(fine_value)}"
+        assert medium_value is None or isinstance(
+            medium_value, dtype
+        ), f"medium_value is expected to be None or a {dtype}. Get {type(medium_value)}"
+        assert rough_value is None or isinstance(
+            rough_value, dtype
+        ), f"rough_value is expected to be None or a {dtype}. Get {type(rough_value)}"
+        super().__init__(title, parent)
+        self._dtype = dtype
+        if unit is None:
+            unit = ""
+        else:
+            unit = f" {unit}"
+        self.setLayout(qt.QGridLayout())
+        self.layout().setSpacing(2)
+
+        # label
+        self.layout().addWidget(qt.QLabel(label), 0, 0, 3, 1)
+
+        # QLE manual step size
+        default_value = medium_value or fine_value or rough_value
+        self._manualLE = qt.QLineEdit(str(default_value), parent=self)
+        if dtype is float:
+            validator = qt.QDoubleValidator(parent=self._manualLE, decimals=2)
+            validator.setBottom(0.0)
+        elif dtype is int:
+            validator = qt.QIntValidator(parent=self._manualLE)
+            validator.setBottom(0)
+        else:
+            raise ValueError("dtype is expected to be int or float")
+        self._manualLE.setValidator(validator)
+        self.layout().addWidget(self._manualLE, 0, 1, 3, 1)
+
+        # buttons
+        buttons_font = self.font()
+        buttons_font.setPixelSize(10)
+        self._expectedValues = {}
+        # for each button associate the expected value
+
+        # fine
+        if fine_value is not None:
+            self._fineButton = qt.QPushButton(f"fine ({fine_value}{unit})", parent=self)
+            self._fineButton.setCheckable(True)
+            self._fineButton.setFont(buttons_font)
+            self.layout().addWidget(self._fineButton, 0, 2, 1, 1)
+            self._fineButton.released.connect(
+                functools.partial(self.setStepSize, fine_value)
+            )
+            self._expectedValues[self._fineButton] = fine_value
+        else:
+            self._fineButton = None
+
+        # medium
+        if medium_value is not None:
+            self._mediumButton = qt.QPushButton(
+                f"medium ({medium_value}{unit})", parent=self
+            )
+            self._mediumButton.setCheckable(True)
+            self._mediumButton.setFont(buttons_font)
+            self.layout().addWidget(self._mediumButton, 1, 2, 1, 1)
+            self._mediumButton.released.connect(
+                functools.partial(self.setStepSize, medium_value)
+            )
+            self._expectedValues[self._mediumButton] = medium_value
+        else:
+            self._mediumButton = None
+
+        # rough
+        if rough_value is not None:
+            self._roughButton = qt.QPushButton(
+                f"rough ({rough_value}{unit})", parent=self
+            )
+            self._roughButton.setCheckable(True)
+            self._roughButton.setFont(buttons_font)
+            self.layout().addWidget(self._roughButton, 2, 2, 1, 1)
+            self._roughButton.released.connect(
+                functools.partial(self.setStepSize, rough_value)
+            )
+            self._expectedValues[self._roughButton] = rough_value
+        else:
+            self._roughButton = None
+
+        # connect signal / slot
+        self._manualLE.textChanged.connect(self._updateButtonChecked)
+        self._manualLE.textChanged.connect(self.valueChanged)
+        # set up
+        self._updateButtonChecked(self._manualLE.text())
+
+    def _updateButtonChecked(self, text):
+        if text == "":
+            return
+        current_value = self._dtype(text)
+        for button, activation_value in self._expectedValues.items():
+            with block_signals(button):
+                button.setChecked(activation_value == current_value)
+
+    def getStepSize(self) -> Union[float, int]:
+        """
+
+        :return: displacement shift defined
+        :rtype: float
+        """
+        return self._dtype(self._manualLE.text())
+
+    def setStepSize(self, value: Union[float, int]):
+        """
+
+        :param float value: shift step
+        """
+        assert isinstance(value, self._dtype)
+        self._manualLE.setText(str(value))

tomwer/gui/utils/unitsystem.py

@@ -35,7 +35,7 @@ __date__ = "21/09/2018"
 import logging
 
 from silx.gui import qt
-from tomoscan.unitsystem import metricsystem
+from pyunitsystem import metricsystem
 
 from tomwer.core.utils.char import MU_CHAR
 
@@ -64,10 +64,7 @@ class PixelEntry(qt.QWidget):
         self.layout().addWidget(self._qlePixelSize)
 
         # connect signal / slot
-        self._qlePixelSize.editingFinished.connect(self._callbackEditingFinished)
-
-    def _callbackEditingFinished(self):
-        self.valueChanged.emit()
+        self._qlePixelSize.editingFinished.connect(self.valueChanged)
 
     def getValue(self):
         if self._qlePixelSize.text() in ("unknown", ""):

tomwer/gui/utils/vignettes.py

@@ -36,7 +36,7 @@ __date__ = "26/02/2021"
 
 
 import logging
-from typing import Iterable, Union
+from typing import Iterable, Union, Optional
 
 import numpy
 from silx.gui import qt
@@ -44,8 +44,9 @@ from silx.gui.plot import PlotWindow
 from silx.gui.plot.utils.axis import SyncAxes
 from silx.io.url import DataUrl
 from tomoscan.esrf.scan.utils import get_data
+from math import floor
 
-from tomwer.core.process.reconstruction.scores.scores import ComputedScore
+from tomwer.core.process.reconstruction.scores.scores import ComputedScore, ScoreMethod
 
 _logger = logging.getLogger(__name__)
 
@@ -55,6 +56,12 @@ class VignettesQDialog(qt.QDialog):
 
     SIZE_HINT = qt.QSize(820, 820)
 
+    AUTO_NB_COLUMN = "auto"
+
+    COLUMN_VALUES = (AUTO_NB_COLUMN, 1, 2, 3, 4, 5, 6, 8, 10)
+
+    RESIZE_MAX_TIME = 500
+
     def __init__(
         self,
         value_name,
@@ -65,10 +72,24 @@ class VignettesQDialog(qt.QDialog):
         colormap=None,
     ):
         qt.QDialog.__init__(self, parent)
+        self.setWindowFlags(qt.Qt.Widget)
         self._scan = None
         self._selectedValue = None
         self.setLayout(qt.QVBoxLayout())
+
+        self._nbColumnCB = qt.QComboBox(self)
+        for nb_column in self.COLUMN_VALUES:
+            self._nbColumnCB.addItem(str(nb_column))
+
+        self._columnWidget = qt.QWidget(self)
+        # needed intermediary widget because the 'setWidgetResizable' fails with QFormLayout on PyQt 5.14.1 and will want to keep compatiblity for now
+        self._columnWidget.setLayout(qt.QFormLayout())
+        self._columnWidget.layout().addRow("number of column", self._nbColumnCB)
+        self.layout().addWidget(self._columnWidget)
+
         self._mainWidget = qt.QScrollArea(self)
+        self._mainWidget.setHorizontalScrollBarPolicy(qt.Qt.ScrollBarAlwaysOff)
+        self._mainWidget.setVerticalScrollBarPolicy(qt.Qt.ScrollBarAsNeeded)
         self._vignettesWidget = VignettesWidget(
             self,
             with_spacer=True,
@@ -86,18 +107,30 @@ class VignettesQDialog(qt.QDialog):
         types = qt.QDialogButtonBox.Ok | qt.QDialogButtonBox.Cancel
         self._buttons = qt.QDialogButtonBox(parent=self)
         self._buttons.setStandardButtons(types)
+        self._buttons.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum)
         self.layout().addWidget(self._buttons)
 
         # connect signal slot
         self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self.accept)
-
         self._buttons.button(qt.QDialogButtonBox.Cancel).clicked.connect(self.reject)
+        self._nbColumnCB.currentIndexChanged.connect(self._updateNbColumn)
+
+        self._resizeCallback = None
+        self._firstResizeEvent = True
 
     def sizeHint(self):
         """Return a reasonable default size for usage in :class:`PlotWindow`"""
         return self.SIZE_HINT
 
-    def setScores(self, scores, score_method):
+    def setScores(self, scores: dict, score_method: ScoreMethod):
+        """
+        Expect a dictionary with possible values to select as key and
+        (2D numpy.array, score) as value.
+        Where the 2D numpy.array is the frame to display and the score if the
+        "indicator" score to display with the frame.
+        :param dict scores: with score as key and a tuple (url|numpy array, ComputedScore) as value
+        :param ScoreMethod score_method: score kind to be display
+        """
         self._vignettesWidget.setScores(scores=scores, score_method=score_method)
 
     def selectedValue(self):
@@ -116,6 +149,55 @@ class VignettesQDialog(qt.QDialog):
         self._vignettesWidget.close()
         super().reject()
 
+    def getNColumn(self) -> Optional[int]:
+        n_column = self._nbColumnCB.currentText()
+        if n_column == self.AUTO_NB_COLUMN:
+            return None
+        else:
+            return int(n_column)
+
+    def setNbColumn(self, value: Union[int, str]):
+        if value not in self.COLUMN_VALUES:
+            raise ValueError(
+                f"Unhandled number of column requested ({value}). Valid values are {self.COLUMN_VALUES}"
+            )
+        idx = self._nbColumnCB.findText(str(value))
+        self._nbColumnCB.setCurrentIndex(idx)
+
+    @staticmethod
+    def computeOptimalNColumn(window_width, vignette_width):
+        n = floor(window_width / vignette_width)
+        # To check with Jerome; He seems to have work on the topic.
+        # might have some method for a smart way to do it
+        return max(1, n)
+
+    def _updateNbColumn(self, force_update=False):
+        n_colum = self.getNColumn()
+        if n_colum is None:
+            n_colum = self.computeOptimalNColumn(
+                window_width=self.width(),
+                vignette_width=400,
+            )
+        self._vignettesWidget.setNElementsPerRow(n_colum, force_update=force_update)
+
+    def resizeEvent(self, event):
+        if self._firstResizeEvent:
+            # cheap way to filter the first resize and avoid updating it
+            self._firstResizeEvent = False
+        else:
+            # print("resize event received...", event)
+            if self._resizeCallback is not None:
+                self._resizeCallback.timeout.disconnect(self._updateNbColumn)
+                self._resizeCallback.stop()
+                self._resizeCallback.deleteLater()
+                self._resizeCallback = None
+            self._resizeCallback = qt.QTimer(self)
+            self._resizeCallback.setSingleShot(True)
+            self._resizeCallback.timeout.connect(self._updateNbColumn)
+            self._resizeCallback.start(self.RESIZE_MAX_TIME)
+
+        super().resizeEvent(event)
+
 
 class VignettesWidget(qt.QWidget):
     """
@@ -132,6 +214,7 @@ class VignettesWidget(qt.QWidget):
     """
 
     DEFAULT_PLOT_PER_ROW = 2
+    MAX_NB_COLUMN = 999999
 
     def __init__(
         self,
@@ -155,6 +238,9 @@ class VignettesWidget(qt.QWidget):
         self._scoreFormat = score_format
         self._colormap = colormap
         self._vignettes = []
+        self.__score_method = None
+
+        self.setLayout(qt.QGridLayout())
 
     def close(self):
         for vignette in self._vignettes:
@@ -164,24 +250,81 @@ class VignettesWidget(qt.QWidget):
     def selectedValue(self):
         sel_vignette = self._vignettesGroup.checkedButton()
         if sel_vignette is not None:
-            return sel_vignette.getValue()
+            return sel_vignette.getScoreValue()
         else:
             return None
 
-    def setNElementsPerRow(self, n: int):
-        self._nPlotPerRow = n
+    def setNElementsPerRow(self, n: int, force_update):
+        assert isinstance(n, int), "number of column must be an int"
+        if self._nPlotPerRow != n:
+            self._nPlotPerRow = n
+            self.__update()
+        elif force_update:
+            self.__update()
+
+    def __update(self):
+        scores, score_method = self.getScores()
+        self.setScores(scores, score_method)
+        # raise NotImplementedError
+
+    def getNElementsPerRow(self):
+        return self._nPlotPerRow
+
+    def getScores(self) -> tuple:
+        """
+        Return currently displayed scores as (scores, scores_method)
+        """
+        scores = {}
+        scores_method = self.__score_method
+        for vignette in self._vignettes:
+            assert isinstance(vignette, Vignette)
+            if scores_method in (ScoreMethod.STD, ScoreMethod.STD_INVERSE):
+                compute_score_args = {
+                    "std": vignette.getScoreValue(),
+                    "tv": None,
+                }
+            elif scores_method in (ScoreMethod.TV, ScoreMethod.TV_INVERSE):
+                compute_score_args = {
+                    "std": None,
+                    "tv": vignette.getScoreValue(),
+                }
+            elif scores_method in (ScoreMethod.TOMO_CONSISTENCY):
+                compute_score_args = {
+                    "std": None,
+                    "tv": None,
+                    "tomo_consitency": vignette.getScoreValue(),
+                }
+            else:
+                raise ValueError(f"score method unhandled: {scores_method.value}")
+
+            scores[vignette.getValue()] = (
+                vignette.getData(),
+                ComputedScore(**compute_score_args),
+            )
+        return scores, scores_method
+
+    def clearVignettes(self):
+        for vignette in self._vignettes:
+            self.layout().removeWidget(vignette)
+            vignette.setParent(None)
+            self._vignettesGroup.removeButton(vignette)
+            # vignette.deleteLater()
+        self._vignettes = []
 
-    def setScores(self, scores: dict, score_method):
+    def setScores(self, scores: dict, score_method: ScoreMethod):
         """
         Expect a dictionary with possible values to select as key and
         (2D numpy.array, score) as value.
         Where the 2D numpy.array is the frame to display and the score if the
         "indicator" score to display with the frame.
-        :param dict scores: with score as key and url or numpy array as value
+        :param dict scores: with score as key and a tuple (url|numpy array, ComputedScore) as value
+        :param ScoreMethod score_method: score kind to be display
         """
         if len(scores) < 1:
             return
-        self.setLayout(qt.QGridLayout())
+
+        self.clearVignettes()
+
         i_row = 0
         scores_values = []
         for i_score, (value, (data, score_cls)) in enumerate(scores.items()):
@@ -190,6 +333,7 @@ class VignettesWidget(qt.QWidget):
                     f"score is expected to be a dict with values as (v1: numpy.ndarray, v2: ComputedScore). v2 type Found: {type(score_cls)}"
                 )
             scores_values.append(score_cls.get(score_method))
+        self.__score_method = ScoreMethod.from_value(score_method)
         highest_score_indices = numpy.nanargmax(scores_values)
         self._vignettesGroup = qt.QButtonGroup(self)
         self._vignettesGroup.setExclusive(True)
@@ -202,10 +346,9 @@ class VignettesWidget(qt.QWidget):
 
         for i_score, (value, (data, score_cls)) in enumerate(scores.items()):
             score = score_cls.get(score_method)
-            i_column = i_score % self.DEFAULT_PLOT_PER_ROW
+            i_column = i_score % self.getNElementsPerRow()
             # TODO: instead of having a binary color we could use
-            # colormap
-            # TODO: synchronize zooms
+            # colormap from green (good score) to red (bad score score)
             if i_score == highest_score_indices or i_score in highest_score_indices:
                 frame_color = qt.Qt.green
             else:
@@ -227,7 +370,7 @@ class VignettesWidget(qt.QWidget):
             yAxis.append(widget.getPlotWidget().getYAxis())
 
             self.layout().addWidget(widget, i_row, i_column)
-            if i_column == self.DEFAULT_PLOT_PER_ROW - 1:
+            if i_column == self.getNElementsPerRow() - 1:
                 i_row += 1
             if i_score == 0:
                 # we cannot request all widget to keep the aspect ratio
@@ -238,7 +381,8 @@ class VignettesWidget(qt.QWidget):
         if self._withSpacer:
             spacer = qt.QWidget(self)
             spacer.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
-            self.layout().addWidget(spacer, i_row + 1, self.DEFAULT_PLOT_PER_ROW - 1)
+            # to simplify we add a spacer at the end. We do not expect to have more than 999999 column
+            self.layout().addWidget(spacer, i_row + 1, self.MAX_NB_COLUMN)
 
         # constrain axis synchronization
         self.__constraintXAxis = SyncAxes(
@@ -339,6 +483,18 @@ class Vignette(qt.QToolButton):
     def getValue(self):
         return self._value
 
+    def getData(self) -> numpy.ndarray:
+        return self._plot.getImage().getData()
+
+    def getScoreValue(self):
+        return self._valueLabel.score
+
+    def getScoreName(self):
+        return self._scoreName
+
+    def getValueName(self):
+        return self._valueName
+
     def paintEvent(self, event):
         super().paintEvent(event)
         painter = qt.QPainter(self)
@@ -375,6 +531,7 @@ class ValueLabel(qt.QWidget):
         self, parent, value, score, value_name, score_name, value_format, score_format
     ):
         qt.QWidget.__init__(self, parent)
+        self._score = score
         self.setLayout(qt.QHBoxLayout())
         if value_format is not None:
             str_value = value_format.format(value)
@@ -390,3 +547,7 @@ class ValueLabel(qt.QWidget):
         txt = f"({score_name}: {str_score})"
         self._scoreLabel = qt.QLabel(txt, self)
         self.layout().addWidget(self._scoreLabel)
+
+    @property
+    def score(self):
+        return self._score

tomwer/gui/visualization/dataviewer.py

@@ -31,6 +31,7 @@ import logging
 import weakref
 
 from silx.gui import qt
+from silx.gui.dialog.ColormapDialog import DisplayMode
 from silx.gui.plot.ImageStack import ImageStack as _ImageStack
 from silx.gui.plot.ImageStack import UrlLoader
 from silx.gui.utils.signal import SignalProxy
@@ -54,12 +55,6 @@ except ImportError:  # pragma: no cover
     has_PIL = False  # pragma: no cover
 else:
     has_PIL = True
-try:
-    import cv2  # pragma: no cover
-except ImportError:  # pragma: no cover
-    has_cv2 = False  # pragma: no cover
-else:
-    has_cv2 = True
 import os
 import time
 
@@ -85,6 +80,7 @@ class DataViewer(qt.QMainWindow):
         self._viewer = ImageStack(
             parent=self, show_overview=show_overview, backend=backend
         )
+        self._viewer.getPlotWidget().getMaskAction().setVisible(False)
         self._viewer.getPlotWidget().setYAxisInverted(Y_AXIS_DOWNWARD)
         # set an UrlLoader managing .npy and .vol
         self._viewer.getPlotWidget().setKeepDataAspectRatio(True)
@@ -112,7 +108,7 @@ class DataViewer(qt.QMainWindow):
 
         # connect signal / slot
         self._controls.sigDisplayModeChanged.connect(self._updateDisplay)
-        self._controls.sigDisplayModeChanged.connect(self._reportSettingsUpdate)
+        self._controls.sigDisplayModeChanged.connect(self.sigConfigChanged)
 
     def getPlotWidget(self):
         return self._viewer.getPlotWidget()
@@ -129,9 +125,6 @@ class DataViewer(qt.QMainWindow):
     def setScanOverviewVisible(self, visible: bool) -> None:
         self._viewer.setScanOverviewVisible(visible=visible)
 
-    def cleanBeforeQuit(self):
-        self._viewer._plot.updateThread.stop()
-
     def getUrlListDockWidget(self):
         return self._viewer.getUrlListDockWidget()
 
@@ -259,9 +252,6 @@ class DataViewer(qt.QMainWindow):
             else:
                 self._viewer.reset()
 
-    def _reportSettingsUpdate(self):
-        self.sigConfigChanged.emit()
-
     def clear(self):
         self._scan = None
         self._viewer.reset()
@@ -421,14 +411,27 @@ class DisplayControl(qt.QWidget):
 
 
 class ImageStack(_ImageStack):
+    """
+    Image stack dedicated to data display.
+
+    It deal for example with data normalization...
+    """
+
     def __init__(self, parent, show_overview=True, backend=None):
         self._normFct = None
         self._url_indexes = None
         super().__init__(parent)
         self.getPlotWidget().setBackend(backend)
+
+        # tune colormap dialog to have histogram by default
+        colormapAction = self.getPlotWidget().getColormapAction()
+        colormapDialog = colormapAction.getColormapDialog()
+        colormapDialog.getHistogramWidget().setDisplayMode(DisplayMode.HISTOGRAM)
+        colormapAction.setColormapDialog(colormapDialog)
+
         self.setUrlLoaderClass(_TomwerUrlLoader)
         # hide axis to be display
-        self._plot.getPlotWidget().setAxesDisplayed(False)
+        self._plot.setAxesDisplayed(False)
         self._loadSliceParams = False
         self._resetZoom = True
 
@@ -493,17 +496,15 @@ class ImageStack(_ImageStack):
         return self._tableDockWidget
 
     def resetZoom(self):
-        self._plot.getPlotWidget().resetZoom()
+        self._plot.resetZoom()
 
     def setLimits(self, x_min, x_max, y_min, y_max):
-        plot = self._plot.getPlotWidget()
-        plot.setLimits(xmin=x_min, ymin=y_min, xmax=x_max, ymax=y_max)
+        self._plot.setLimits(xmin=x_min, ymin=y_min, xmax=x_max, ymax=y_max)
 
     def getLimits(self):
-        plot = self._plot.getPlotWidget()
         limits = []
-        limits.extend(plot.getGraphXLimits())
-        limits.extend(plot.getGraphYLimits())
+        limits.extend(self._plot.getGraphXLimits())
+        limits.extend(self._plot.getGraphYLimits())
         return tuple(limits)
 
     def setSliceReconsParamsVisible(self, visible):
@@ -535,8 +536,19 @@ class ImageStack(_ImageStack):
                 return
 
             if data.ndim != 2:
-                if data.ndim == 3 and data.shape[0] == 1:
-                    data = data.reshape((data.shape[1], data.shape[2]))
+                if data.ndim == 3:
+                    if data.shape[0] == 1:
+                        # if reconstruction along z
+                        data = data.reshape((data.shape[1], data.shape[2]))
+                    elif data.shape[1] == 1:
+                        # if reconstruction along y
+                        data = data.reshape((data.shape[0], data.shape[2]))
+                    elif data.shape[2] == 1:
+                        # if reconstruction along z
+                        data = data.reshape((data.shape[0], data.shape[1]))
+                    else:
+                        _logger.warning(f"Image Stack only manage 2D data. Url: {url}")
+                        return
                 else:
                     _logger.warning(f"Image Stack only manage 2D data. Url: {url}")
                     return
@@ -547,10 +559,14 @@ class ImageStack(_ImageStack):
                 self._urlData[url] = norm_data
 
             if self.getCurrentUrl().path() == url:
-                self._plot.setData(self._urlData[url])
+                self._plot.addImage(self._urlData[url])
+                if hasattr(self, "getWaiterOverlay"):
+                    self.getWaiterOverlay().hide()
+                else:
+                    self._waitingOverlay.hide()
                 if self._resetZoom:
                     self._resetZoom = False
-                    self._plot.getPlotWidget().resetZoom()
+                    self._plot.resetZoom()
 
             if sender in self._loadingThreads:
                 self._loadingThreads.remove(sender)
@@ -560,11 +576,16 @@ class ImageStack(_ImageStack):
         self._resetZoom = reset
 
     def setCurrentUrl(self, url: DataUrl):
-        if isinstance(url, str):
+        if url in ("", None):
+            url = None
+        elif isinstance(url, str):
             url = DataUrl(path=url)
         elif not isinstance(url, DataUrl):
             raise TypeError
-        if self._loadSliceParams:
+        if url is None:
+            pass
+            # FIXME: add a function to clear the metadata widget
+        elif self._loadSliceParams:
             try:
                 self._reconsWidget.setVolumeMetadata(
                     self._metadatas.get(url.path(), None)
@@ -575,7 +596,7 @@ class ImageStack(_ImageStack):
 
     def setUrls(self, urls: list):
         _ImageStack.setUrls(self, urls)
-        listWidget = self._urlsTable._urlsTable._listWidget
+        listWidget = self._urlsTable._urlsTable
         items = []
         for i in range(listWidget.count()):
             # TODO: do this on the fly
@@ -607,14 +628,6 @@ class _TomwerUrlLoader(UrlLoader):
     def run(self):
         if self.url.file_path().endswith(".vol"):
             self.data = self._load_vol()
-        elif self.url.scheme() == "cv2":
-            if has_cv2:
-                self.data = cv2.imread(self.url.file_path(), -1)
-            else:
-                self.data = None
-                _logger.warning(
-                    f"need to install cv2 to read cast file {self.url.file_path()} because fabio fails to read float16"
-                )
         elif self.url.scheme() == "tomwer":
             if has_PIL:
                 self.data = numpy.array(Image.open(self.url.file_path()))