tomwer 1.2.8__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

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

@@ -54,12 +54,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
 
@@ -112,7 +106,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()
@@ -259,9 +253,6 @@ class DataViewer(qt.QMainWindow):
             else:
                 self._viewer.reset()
 
-    def _reportSettingsUpdate(self):
-        self.sigConfigChanged.emit()
-
     def clear(self):
         self._scan = None
         self._viewer.reset()
@@ -607,14 +598,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()))

tomwer/gui/visualization/diffviewer/diffviewer.py

@@ -42,7 +42,7 @@ from silx.gui import qt
 from silx.io.url import DataUrl
 from silx.utils.enum import Enum as _Enum
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.image import shift_img
@@ -158,7 +158,7 @@ class _FrameSelector(qt.QWidget):
             if self._scan.flats is not None:
                 urls = self._scan.flats.values()
         elif type_selected == self.FrameType.PROJ:
-            if isinstance(self._scan, HDF5TomoScan):
+            if isinstance(self._scan, NXtomoScan):
                 angles_and_urls = self._scan.get_proj_angle_url(with_alignment=False)
                 for angle, url in angles_and_urls.items():
                     urls.append(url)
@@ -267,10 +267,10 @@ class _FramesSelector(qt.QWidget):
         self._rightSelector.layout().setContentsMargins(0, 0, 0, 0)
 
         # signal / slot connection
-        self._leftSelector.sigCorrectionChanged.connect(self._leftFrameUpdReq)
-        self._rightSelector.sigCorrectionChanged.connect(self._rightFrameUpdReq)
-        self._leftSelector.sigSelectedUrlChanged.connect(self._leftFrameUpdReq)
-        self._rightSelector.sigSelectedUrlChanged.connect(self._rightFrameUpdReq)
+        self._leftSelector.sigCorrectionChanged.connect(self.sigLeftFrameUpdateReq)
+        self._rightSelector.sigCorrectionChanged.connect(self.sigRightFrameUpdateReq)
+        self._leftSelector.sigSelectedUrlChanged.connect(self.sigLeftFrameUpdateReq)
+        self._rightSelector.sigSelectedUrlChanged.connect(self.sigRightFrameUpdateReq)
         self._leftScanCB.sigScanChanged.connect(self._leftScanChanged)
         self._rightScanCB.sigScanChanged.connect(self._rightScanChanged)
         self._leftScanCB.sigRequestScanAdd.connect(self._addScanFrmDialogLeft)
@@ -314,12 +314,6 @@ class _FramesSelector(qt.QWidget):
     def getRightUrl(self):
         return self._rightSelector.getCurrentUrl()
 
-    def _rightFrameUpdReq(self):
-        self.sigRightFrameUpdateReq.emit()
-
-    def _leftFrameUpdReq(self):
-        self.sigLeftFrameUpdateReq.emit()
-
     def _addScanFrmDialogLeft(self):
         self._addScanFrmDialog(link_to="left")
 
@@ -542,7 +536,7 @@ class _ScanComboBox(qt.QWidget):
 
         # connect signal / slot
         self._scansCB.currentIndexChanged.connect(self._scanChanged)
-        self._addButton.pressed.connect(self._addScanCallback)
+        self._addButton.released.connect(self.sigRequestScanAdd)
 
     def clear(self):
         self._scans = set()
@@ -574,6 +568,3 @@ class _ScanComboBox(qt.QWidget):
             return None
         else:
             return scan
-
-    def _addScanCallback(self):
-        self.sigRequestScanAdd.emit()

tomwer/gui/visualization/diffviewer/shiftwidget.py

@@ -91,8 +91,8 @@ class TwoFramesShiftTab(qt.QTabWidget, _FrameShiftsBase):
         self._absoluteShiftWidget = Absolute2FramesShift(self)
         self.addTab(self._absoluteShiftWidget, self.ShiftMode.ABSOLUTE.value)
         # connect signal / slot
-        self._absoluteShiftWidget.sigShiftsChanged.connect(self._propagateSignal)
-        self._relativeShiftWidget.sigShiftsChanged.connect(self._propagateSignal)
+        self._absoluteShiftWidget.sigShiftsChanged.connect(self.sigShiftsChanged)
+        self._relativeShiftWidget.sigShiftsChanged.connect(self.sigShiftsChanged)
         # set up
         self.setCurrentWidget(self._relativeShiftWidget)
         self._relativeShiftWidget.setFocus(qt.Qt.OtherFocusReason)
@@ -102,9 +102,6 @@ class TwoFramesShiftTab(qt.QTabWidget, _FrameShiftsBase):
     def getRelativeShiftWidget(self):
         return self._relativeShiftWidget
 
-    def _propagateSignal(self, shift_infos: tuple):
-        self.sigShiftsChanged.emit(shift_infos)
-
     def getShiftMode(self):
         if self.currentWidget() is self._relativeShiftWidget:
             return self.ShiftMode.RELATIVE

tomwer/gui/visualization/scanoverview.py

@@ -32,7 +32,7 @@ import logging
 import weakref
 
 from silx.gui import qt
-from tomoscan.scanbase import FOV
+from nxtomo.nxobject.nxdetector import FOV
 
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase

tomwer/gui/visualization/sinogramviewer.py

@@ -134,12 +134,6 @@ class SinogramViewer(qt.QMainWindow):
         self._plot.getPlotWidget().addImage(data=sinogram)
         self._plot.getPlotWidget().replot()
 
-    def _editionLocked(self, locked):
-        self.sigAxisEditionLocked.emit(locked)
-
-    def _applyRequested(self):
-        self.sigApply.emit()
-
     def _sinogram_loaded(self):
         """callback when the sinogram is loaded"""
         self._plot.setWaiting(False)
@@ -272,15 +266,12 @@ class SinogramOpts(qt.QDialog):
 
         # connect signal / slot
         self._buttons.button(qt.QDialogButtonBox.Apply).clicked.connect(
-            self._updateSinogram
+            self.sigUpdateRequested
         )
 
     def setLineSelectionVisible(self, visible):
         self._lineSelWidget.setVisible(visible)
 
-    def _updateSinogram(self):
-        self.sigUpdateRequested.emit()
-
     def setScan(self, scan):
         old = self.blockSignals(True)
         # update line max and value

tomwer/gui/visualization/test/test_diffviewer.py

@@ -37,7 +37,7 @@ import unittest
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.visualization.diffviewer import DiffFrameViewer
 
 logging.disable(logging.INFO)
@@ -52,14 +52,14 @@ class TestDiffViewer(TestCaseQt):
         self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
 
         self.tmp_dir = tempfile.mkdtemp()
-        self.scan1 = MockHDF5(
+        self.scan1 = MockNXtomo(
             scan_path=os.path.join(self.tmp_dir, "myscan"),
             n_proj=20,
             n_ini_proj=20,
             dim=10,
         ).scan
 
-        self.scan2 = MockHDF5(
+        self.scan2 = MockNXtomo(
             scan_path=os.path.join(self.tmp_dir, "myscan"),
             n_proj=20,
             n_ini_proj=20,

tomwer/gui/visualization/test/test_nx_tomo_metadata_viewer.py

@@ -2,11 +2,11 @@ import os
 
 import numpy
 import pytest
-from nxtomomill.nexus.nxtomo import NXtomo
+from nxtomo.application.nxtomo import NXtomo
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.visualization.nxtomometadata import NXtomoMetadataViewer
 from tomwer.tests.conftest import qtapp  # noqa F401
 
@@ -37,7 +37,7 @@ def test_nx_editor(
         data_path=entry,
     )
 
-    scan = HDF5TomoScan(file_path, entry)
+    scan = NXtomoScan(file_path, entry)
 
     # 2.0 create the widget and do the edition
     widget = NXtomoMetadataViewer()

tomwer/gui/visualization/test/test_sinogramviewer.py

@@ -38,7 +38,7 @@ import unittest
 from silx.gui import qt
 from silx.gui.utils.testutils import SignalListener, TestCaseQt
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.visualization import sinogramviewer
 
 logging.disable(logging.INFO)
@@ -53,7 +53,7 @@ class TestSinogramViewer(TestCaseQt):
         self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
 
         self.tmp_dir = tempfile.mkdtemp()
-        self.scan = MockHDF5(
+        self.scan = MockNXtomo(
             scan_path=os.path.join(self.tmp_dir, "myscan"),
             n_proj=20,
             n_ini_proj=20,

tomwer/gui/visualization/test/test_stacks.py

@@ -39,7 +39,7 @@ from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from tomoscan.esrf.volume.edfvolume import EDFVolume
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.stacks import RadioStack, SliceStack
 from tomwer.tests.utils import skip_gui_test
 
@@ -67,7 +67,7 @@ class TestSliceStack(TestCaseQt):
         n_slice_per_scan = 1
         with tempfile.TemporaryDirectory() as root_dir:
             for i_scan in range(n_scan):
-                scan = MockHDF5(
+                scan = MockNXtomo(
                     scan_path=os.path.join(root_dir, f"scan{i_scan}"),
                     n_proj=10,
                     n_ini_proj=10,
@@ -103,7 +103,7 @@ class TestRadioStack(TestCaseQt):
         self.slider = weakref.ref(self._widget._viewer._qslider)
         self._tmp_dir = tempfile.mkdtemp()
         os.makedirs(self._tmp_dir, exist_ok=True)
-        self._scan = MockHDF5(
+        self._scan = MockNXtomo(
             os.path.join(self._tmp_dir, "my_scan"),
             n_proj=30,
             dim=10,

tomwer/gui/visualization/test/test_volumeviewer.py

@@ -39,7 +39,7 @@ from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from tomoscan.esrf.volume.hdf5volume import HDF5Volume
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.visualization.volumeviewer import VolumeViewer
 
 logging.disable(logging.INFO)
@@ -55,7 +55,7 @@ class TestDiffViewer(TestCaseQt):
 
         self.tmp_dir = tempfile.mkdtemp()
 
-        self.scan = MockHDF5(
+        self.scan = MockNXtomo(
             scan_path=os.path.join(self.tmp_dir, "myscan"),
             n_proj=20,
             n_ini_proj=20,