tomwer 1.3.0.dev2__py3-none-any.whl → 1.3.0rc10__py3-none-any.whl

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
@@ -79,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)
@@ -123,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()
 
@@ -412,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
 
@@ -484,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):
@@ -526,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
@@ -538,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)
@@ -551,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)
@@ -566,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

tomwer/gui/visualization/sinogramviewer.py

@@ -35,14 +35,8 @@ import logging
 import weakref
 
 from silx.gui import qt
-
-try:
-    from silx.gui.plot.ImageStack import (  # noqa F401
-        PlotWithWaitingLabel as _PlotWithWaitingLabel,
-    )
-except ImportError:
-    from silx.gui.plot.ImageStack import _PlotWithWaitingLabel  # noqa F401
-
+from silx.gui.plot import Plot2D
+from silx.gui.widgets.WaitingOverlay import WaitingOverlay
 from tomwer.gui.settings import Y_AXIS_DOWNWARD
 
 _logger = logging.getLogger(__name__)
@@ -72,13 +66,16 @@ class SinogramViewer(qt.QMainWindow):
         # used to memorize sinogram properties when load it.
         # Contains (str(scan), line, oversampling)
 
-        self._plot = _PlotWithWaitingLabel(parent=self)
-        self._plot.getPlotWidget().setYAxisInverted(Y_AXIS_DOWNWARD)
-        plot = self._plot.getPlotWidget()
-        plot.getDefaultColormap().setVRange(None, None)
-        plot.setAxesDisplayed(False)
-        plot.setKeepDataAspectRatio(True)
-        self._plot.setWaiting(False)
+        self._plot = Plot2D(parent=self)
+        self._plotWaiter = WaitingOverlay(self._plot)
+        self._plotWaiter.hide()
+        self._plotWaiter.setIconSize(qt.QSize(30, 30))
+
+        self._plot.getMaskAction().setVisible(False)
+        self._plot.setYAxisInverted(Y_AXIS_DOWNWARD)
+        self._plot.getDefaultColormap().setVRange(None, None)
+        self._plot.setAxesDisplayed(False)
+        self._plot.setKeepDataAspectRatio(True)
         self._dockOpt = qt.QDockWidget(self)
         self._options = SinogramOpts(parent=self, orientation=opts_orientation)
         self._dockOpt.setWidget(self._options)
@@ -95,7 +92,7 @@ class SinogramViewer(qt.QMainWindow):
         self._loadingThread.finished.connect(self._sinogram_loaded)
 
         # expose API
-        self.getActiveImage = plot.getActiveImage
+        self.getActiveImage = self._plot.getActiveImage
 
         # set up
         if scan is not None:
@@ -131,12 +128,12 @@ class SinogramViewer(qt.QMainWindow):
         self._options.setSubsampling(value)
 
     def _updatePlot(self, sinogram):
-        self._plot.getPlotWidget().addImage(data=sinogram)
-        self._plot.getPlotWidget().replot()
+        self._plot.addImage(data=sinogram)
+        self._plot.replot()
 
     def _sinogram_loaded(self):
         """callback when the sinogram is loaded"""
-        self._plot.setWaiting(False)
+        self._plotWaiter.hide()
         if self._scan is None or self._scan() is None:
             return
         assert self._sinoInfoCache is not None
@@ -161,7 +158,7 @@ class SinogramViewer(qt.QMainWindow):
             )
             return
         # update scan
-        self._plot.setWaiting(True)
+        self._plotWaiter.show()
         self.sigSinoLoadStarted.emit()
         self._sinoInfoCache = (
             str(self._scan()),
@@ -176,18 +173,14 @@ class SinogramViewer(qt.QMainWindow):
         self._loadingThread.start()
 
     def clear(self):
-        self._plot.getPlotWidget().clear()
+        self._plot.clear()
 
     def close(self):
-        self._stopAnimationThread()
+        self._plotWaiter.hide()
         self._plot.close()
         self._plot = None
         super().close()
 
-    def _stopAnimationThread(self):
-        if self._plot is not None:
-            self._plot.stopUpdateThread()
-
 
 class _LoadSinoThread(qt.QThread):
     def init(self, data, line, subsampling):

tomwer/gui/visualization/test/test_volumeviewer.py

@@ -1,84 +1,82 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################*/
-
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "21/06/2021"
-
-
 import logging
 import os
-import shutil
-import tempfile
-import unittest
-
+import pytest
 import numpy
+from time import sleep
+
 from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
 from tomoscan.esrf.volume.hdf5volume import HDF5Volume
+from tomoscan.esrf.volume.tiffvolume import TIFFVolume, has_tifffile
 
+from tomwer.tests.conftest import qtapp  # noqa F401
 from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.visualization.volumeviewer import VolumeViewer
 
 logging.disable(logging.INFO)
 
 
-class TestDiffViewer(TestCaseQt):
-    """unit test for the :class:_ImageStack widget"""
+@pytest.mark.skipif(not has_tifffile, reason="tifffile not available")
+def test_volume_viewer(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    """
+    test the volume viewer setting a scan having an HDF5 volume linked to it
+    """
+
+    widget = VolumeViewer(parent=None)
+    widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+
+    tmp_dir = tmp_path / "test_volume_viewer"
+    tmp_dir.mkdir()
+
+    # step 1 - test setting a scan containing a HDF5Volume
+    scan = MockNXtomo(
+        scan_path=os.path.join(str(tmp_dir), "myscan"),
+        n_proj=20,
+        n_ini_proj=20,
+        dim=10,
+    ).scan
+    volume = HDF5Volume(
+        file_path=os.path.join(scan.path, "volume.hdf5"),
+        data_path="entry",
+        data=numpy.random.random(60 * 10 * 10).reshape(60, 10, 10),
+    )
+    volume.save()
 
-    def setUp(self):
-        TestCaseQt.setUp(self)
-        self._widget = VolumeViewer(parent=None)
-        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+    scan.set_latest_vol_reconstructions(
+        [
+            volume,
+        ]
+    )
 
-        self.tmp_dir = tempfile.mkdtemp()
+    widget.setScan(scan)
+    assert widget._centralWidget.data() is not None
+    widget.clear()
+    assert widget._centralWidget.data() is None
 
-        self.scan = MockNXtomo(
-            scan_path=os.path.join(self.tmp_dir, "myscan"),
-            n_proj=20,
-            n_ini_proj=20,
-            dim=10,
-        ).scan
-        volume = HDF5Volume(
-            file_path=os.path.join(self.scan.path, "volume.hdf5"),
-            data_path="entry",
-            data=numpy.random.random(60 * 10 * 10).reshape(60, 10, 10),
-        )
-        volume.save()
+    # step 2: test setting a a tiff volume dirrectly
+    volume = TIFFVolume(
+        folder=os.path.join(tmp_dir, "my_tiff_vol"),
+        data=numpy.random.random(60 * 100 * 100).reshape(60, 100, 100),
+    )
+    volume.save()
 
-        self.scan.set_latest_vol_reconstructions(
-            [
-                volume,
-            ]
-        )
+    # 2.1 test with the data being in cache
+    widget.setVolume(volume=volume)
+    assert widget._centralWidget.data() is not None
+    widget.clear()
+    assert widget._centralWidget.data() is None
 
-    def tearDown(self):
-        shutil.rmtree(self.tmp_dir)
-        self._widget.close()
-        self._widget = None
-        unittest.TestCase.tearDown(self)
+    # 2.2 test with the data not being in cache anymore
+    volume.clear_cache()
 
-    def test(self):
-        self._widget.setScan(self.scan)
+    widget.setVolume(volume=volume)
+    # wait_for_processing_finished
+    while qt.QApplication.instance().hasPendingEvents():
+        qt.QApplication.instance().processEvents()
+    sleep(1.2)  # wait for the thread to be processed
+    while qt.QApplication.instance().hasPendingEvents():
+        qt.QApplication.instance().processEvents()
+    # end waiting
+    assert widget._centralWidget.data() is not None

tomwer/gui/visualization/volumeviewer.py

@@ -1,35 +1,4 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "05/08/2020"
-
-
 import logging
-import os
 import weakref
 import h5py
 from typing import Union
@@ -46,11 +15,11 @@ from tomoscan.esrf.volume.hdf5volume import HDF5Volume
 from tomoscan.factory import Factory
 from tomoscan.identifier import VolumeIdentifier
 from tomoscan.volumebase import VolumeBase
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.ftseriesutils import get_vol_file_shape
 from tomwer.gui.visualization.reconstructionparameters import ReconstructionParameters
+from silx.gui.widgets.WaitingOverlay import WaitingOverlay
 
 _logger = logging.getLogger(__name__)
 
@@ -247,6 +216,9 @@ class _TomoApplicationContext(DataViewHooks):
 class VolumeViewer(qt.QMainWindow):
     def __init__(self, parent):
         qt.QMainWindow.__init__(self, parent)
+
+        self._volume_loaded_in_background = (None, None)
+        # store the volume loaded in the background and the thread used for it as (volume_identifier, thread)
         self._centralWidget = DataViewerFrame(parent=self)
         self.__context = _TomoApplicationContext(self)
         self._centralWidget.setGlobalHooks(self.__context)
@@ -254,6 +226,12 @@ class VolumeViewer(qt.QMainWindow):
             qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding
         )
         self.setCentralWidget(self._centralWidget)
+        # waiter overlay to notify user loading is on-going
+        self._waitingOverlay = WaitingOverlay(self._centralWidget)
+        self._waitingOverlay.setIconSize(qt.QSize(30, 30))
+        self._waitingOverlay.hide()
+
+        # display scan information when possible
         self._infoWidget = _ScanInfo(parent=self)
 
         # top level dock widget to display information regarding the scan
@@ -308,9 +286,12 @@ class VolumeViewer(qt.QMainWindow):
         if volume is None:
             return
         self._set_volumes(volumes=(volume,))
-        # TODO in the future: do the equivalent of setScan from the volume metadata
 
     def _get_data_volume(self, volume: VolumeBase):
+        """
+        load the data of the requested volume.
+        :return: (data: Optional[str], state: str) state can be "loaded", "loading" or "failed"
+        """
         if not isinstance(volume, VolumeBase):
             raise TypeError(
                 f"volume is expected to be an instance of {VolumeBase}. Not {type(volume)}"
@@ -318,18 +299,66 @@ class VolumeViewer(qt.QMainWindow):
 
         self._close_h5_file()
         if isinstance(volume, HDF5Volume):
-            self._h5_file = HDF5File(filename=volume.data_url.file_path(), mode="r")
+            self._h5_file = HDF5File(
+                filename=volume.data_url.file_path(), mode="r", swmr=get_swmr_mode()
+            )
             if volume.data_url.data_path() in self._h5_file:
                 data = self._h5_file[volume.data_url.data_path()]
+                state = "loaded"
             else:
                 data = None
+                state = "failed"
+        elif volume.data is not None:
+            data = volume.data
+            state = "loaded"
         else:
-            _logger.warning(
-                "Attempt to set a non HDF5 volume to the viewer. This requires to load all the data in memory. This can take a while"
-            )
-            data = volume.data if volume.data is not None else volume.load_data()
+            volume_id, _ = self._volume_loaded_in_background
+            if volume_id == volume.get_identifier().to_str():
+                # special case if the user send several time the volume which is currently loading
+                # in this case we just want to ignore the request to avoid reloading the volume
+                # can happen in the case of a large volume that take some time to be loaded.
+                pass
+            else:
+                _logger.warning(
+                    "Attempt to set a non HDF5 volume to the viewer. This requires to load all the data in memory. This can take a while"
+                )
+                self._stopExistingLoaderThread()
+                self._loadAndDisplay(volume)
+            state = "loading"
+            data = None
+
+        return data, state
+
+    def _loaderThreadFinished(self):
+        """Callback activated when a VolumeLoader thread is finished"""
+        sender = self.sender()
+        if not isinstance(sender, VolumeLoader):
+            raise TypeError("sender is expected to be a VolumeLoader")
 
-        return data
+        if sender.volume.data is None:
+            _logger.error(f"Failed to load volume {sender.volume.get_identifier()}")
+
+        self._stopExistingLoaderThread()
+        self.setVolume(sender.volume)
+
+    def _loadAndDisplay(self, volume):
+        """Load a thread and add a callback when loading is done"""
+        loader_thread = VolumeLoader(volume=volume)
+        self._volume_loaded_in_background = (
+            volume.get_identifier().to_str(),
+            loader_thread,
+        )
+        loader_thread.finished.connect(self._loaderThreadFinished)
+        loader_thread.start()
+
+    def _stopExistingLoaderThread(self):
+        """Will stop any existing loader thread. Make sure we load one volume at most at the time"""
+        _, loader_thread = self._volume_loaded_in_background
+        if loader_thread is not None:
+            loader_thread.finished.disconnect(self._loaderThreadFinished)
+            if loader_thread.isRunning():
+                loader_thread.quit()
+            self._volume_loaded_in_background = (None, None)
 
     def _set_volumes(self, volumes: tuple):
         self.clear()
@@ -351,11 +380,7 @@ class VolumeViewer(qt.QMainWindow):
                     f"Volume should be an instance of a Volume, a VolumeIdentifier or a string refering to a VolumeIdentifier. {type(volume)} provided"
                 )
 
-            data = self._get_data_volume(volume)
-            # set volume dataset
-            if data is not None:
-                self._set_volume(data)
-            # set reconstruction parameters
+            # warning: load metadata before data because can get some conflict with the HDF5 reader flag if done after
             try:
                 # warning: limitation expected for .vol as it gets two configuration file. The default one is vol.info and does not contains
                 # any of the metadata 'distance', 'pixel size'... but it is here for backward compatiblity
@@ -367,6 +392,21 @@ class VolumeViewer(qt.QMainWindow):
                     f"Unable to set reconstruction parameters from {volume.data_url}. Not handled for pyhst reconstructions. Error is {e}"
                 )
 
+            data, state = self._get_data_volume(volume)
+            # set volume dataset
+            if state == "loading":
+                self._waitingOverlay.show()
+            elif state == "loaded":
+                self._waitingOverlay.hide()
+                if data is not None:
+                    self._set_volume(data)
+
+            elif state == "failed":
+                _logger.warning(
+                    f"Failed to load data from {volume.get_identifier().to_str()}"
+                )
+                return
+
     def _set_volume(self, volume: Union[numpy.ndarray, h5py.Dataset]):
         self._centralWidget.setData(volume)
         if self.__first_load:
@@ -380,68 +420,28 @@ class VolumeViewer(qt.QMainWindow):
         self._close_h5_file()
         # self._centralWidget.setData(None)
         self._infoWidget.clear()
+        self._centralWidget.setData(None)
+        # if clear stop loading any volume
+        self._stopExistingLoaderThread()
 
     def sizeHint(self):
         return qt.QSize(600, 600)
 
-    # TODO: should be merged with dataviewer._load_vol function ?
-    def _load_vol(self, url):
-        """
-        load a .vol file
-        """
-        if url.file_path().lower().endswith(".vol.info"):
-            info_file = url.file_path()
-            raw_file = url.file_path().replace(".vol.info", ".vol")
-        else:
-            assert url.file_path().lower().endswith(".vol")
-            raw_file = url.file_path()
-            info_file = url.file_path().replace(".vol", ".vol.info")
 
-        if not os.path.exists(raw_file):
-            data = None
-            mess = f"Can't find raw data file {raw_file} associated with {info_file}"
-            _logger.warning(mess)
-        elif not os.path.exists(info_file):
-            mess = f"Can't find info file {info_file} associated with {raw_file}"
-            _logger.warning(mess)
-            data = None
-        else:
-            shape = get_vol_file_shape(info_file)
-            if None in shape:
-                _logger.warning(f"Fail to retrieve data shape for {info_file}.")
-                data = None
-            else:
-                try:
-                    numpy.zeros(shape)
-                except MemoryError:
-                    data = None
-                    _logger.warning(f"Raw file {raw_file} is too large for being read")
-                else:
-                    data = numpy.fromfile(
-                        raw_file, dtype=numpy.float32, count=-1, sep=""
-                    )
-                    try:
-                        data = data.reshape(shape)
-                    except ValueError:
-                        _logger.warning(
-                            f"unable to fix shape for raw file {raw_file}. "
-                            "Look for information in {info_file}"
-                        )
-                        try:
-                            sqr = int(numpy.sqrt(len(data)))
-                            shape = (1, sqr, sqr)
-                            data = data.reshape(shape)
-                        except ValueError:
-                            _logger.info(
-                                f"deduction of shape size for {raw_file} " "failed"
-                            )
-                            data = None
-                        else:
-                            _logger.warning(
-                                f"try deducing shape size for {raw_file} "
-                                "might be an incorrect interpretation"
-                            )
-        if url.data_slice() is None:
-            return data
-        else:
-            return data[url.data_slice()]
+class VolumeLoader(qt.QThread):
+    """
+    simple thread that load a volume in memory
+    """
+
+    def __init__(self, volume: VolumeBase) -> None:
+        super().__init__()
+        if not isinstance(volume, VolumeBase):
+            raise TypeError()
+        self.__volume = volume
+
+    def run(self):
+        self.__volume.load_data(store=True)
+
+    @property
+    def volume(self):
+        return self.__volume