tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/gui/utils/vignettes.py

@@ -1,42 +1,11 @@
-# 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.
-#
-# ###########################################################################*/
 """
 contains gui to select a slice in a volume
 """
 
-
-__authors__ = [
-    "H. Payno",
-]
-
-__license__ = "MIT"
-__date__ = "26/02/2021"
-
+from __future__ import annotations
 
 import logging
-from typing import Iterable, Union, Optional
+from typing import Iterable
 
 import numpy
 from silx.gui import qt
@@ -128,7 +97,7 @@ class VignettesQDialog(qt.QDialog):
         (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 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)
@@ -149,14 +118,14 @@ class VignettesQDialog(qt.QDialog):
         self._vignettesWidget.close()
         super().reject()
 
-    def getNColumn(self) -> Optional[int]:
+    def getNColumn(self) -> int | None:
         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]):
+    def setNbColumn(self, value: int | str):
         if value not in self.COLUMN_VALUES:
             raise ValueError(
                 f"Unhandled number of column requested ({value}). Valid values are {self.COLUMN_VALUES}"
@@ -203,10 +172,10 @@ class VignettesWidget(qt.QWidget):
     """
     Widget to display all the frames.
 
-    :param QWidget parent:
-    :param str value_name: name of the values for which we are looking for the
+    :param parent:
+    :param value_name: name of the values for which we are looking for the
                            best one
-    :param str score_name: name of the score computed
+    :param score_name: name of the score computed
     :param score_format: None or str that can be formatted to display the
                          score
     :param value_format: None or str that can be formatted to display the
@@ -317,7 +286,7 @@ class VignettesWidget(qt.QWidget):
         (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 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:
@@ -437,7 +406,7 @@ class Vignette(qt.QToolButton):
         value,
         value_name: str,
         score_name: str,
-        data: Union[DataUrl, numpy.array],
+        data: DataUrl | numpy.array,
         score: float,
         frame_color: qt.QColor,
         score_format=None,

tomwer/gui/utils/waiterthread.py

@@ -1,26 +1,4 @@
 # 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.
-#
-#############################################################################*/
 
 """
 This module is used to manage observations. Initially on files.
@@ -28,10 +6,6 @@ Observations are runned on a thread and run each n seconds.
 They are manage by thread and signals
 """
 
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "09/02/2017"
-
 
 import time
 

tomwer/gui/visualization/__init__.py

@@ -0,0 +1,2 @@
+"""Widgets for displaying data (sinogram, browsing scans, display reconstructed volumes...)
+"""

tomwer/gui/visualization/dataviewer.py

@@ -1,66 +1,13 @@
-# 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__ = "13/08/2021"
-
-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.io.url import DataUrl
 from silx.utils.enum import Enum as _Enum
 
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.ftseriesutils import get_vol_file_shape
 from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.volume.volumefactory import VolumeFactory
-from tomwer.gui import icons
 from tomwer.gui.settings import Y_AXIS_DOWNWARD
-from tomwer.gui.visualization.fullscreenplot import FullScreenPlot2D
-from tomwer.gui.visualization.reconstructionparameters import ReconstructionParameters
-from tomwer.gui.visualization.scanoverview import ScanOverviewWidget
-from tomwer.io.utils.utils import get_slice_data
-
-try:
-    from PIL import Image
-except ImportError:  # pragma: no cover
-    has_PIL = False  # pragma: no cover
-else:
-    has_PIL = True
-import os
-import time
-
-import numpy
-import numpy.lib.npyio
-
-_logger = logging.getLogger(__name__)
+from tomwer.gui.visualization.imagestack import ImageStack
 
 
 class DataViewer(qt.QMainWindow):
@@ -109,6 +56,7 @@ class DataViewer(qt.QMainWindow):
         but in our case we cannot afford it as it will take too much memory.
         So we will disconnect the callback (self._viewer.setCurrentUrlIndex) until the slider is active
         and reactivate it afterwards
+
         """
         self._viewer._slider.sigCurrentUrlIndexChanged.disconnect(
             self._viewer.setCurrentUrlIndex
@@ -186,7 +134,6 @@ class DataViewer(qt.QMainWindow):
 
     def _updateDisplay(self):
         """Update display of the viewer"""
-        # TODO: add a param visible for frames
         self._viewer.setSliceReconsParamsVisible(
             self.getDisplayMode() is _DisplayMode.SLICES
         )
@@ -195,74 +142,75 @@ class DataViewer(qt.QMainWindow):
         )
         if self._scan is None or self._scan() is None:
             self._viewer.reset()
-        else:
-            assert isinstance(self._scan(), TomwerScanBase)
-            slices_metadata = {}
-            if self.getDisplayMode() is _DisplayMode.RADIOS:
-                # update the normalization function from the viewer if needed
-                if self.getRadioOption() is _RadioMode.NORMALIZED:
-                    url_to_index = {
-                        v.path(): k for k, v in self._scan().projections.items()
-                    }
-                    self._viewer.setNormalizationFct(
-                        self._scan().data_flat_field_correction,
-                        url_indexes=url_to_index,
-                    )
-                else:
-                    self._viewer.setNormalizationFct(None)
+            return
 
-                slices = self._scan().projections
-            elif self.getDisplayMode() is _DisplayMode.SLICES:
-                self._viewer.setNormalizationFct(None)
-                if self.getSliceOption() is _SliceMode.LATEST:
-                    slices = self._scan().latest_reconstructions
-                else:
-                    slices = self._scan().get_reconstructions_urls()
-                # convert volumes identifiers to DataUrl
-                slices_urls = []
-                for identifier in slices:
-                    if isinstance(identifier, TomwerVolumeBase):
-                        volume = identifier
-                    else:
-                        volume = VolumeFactory.create_tomo_object_from_identifier(
-                            identifier=identifier
-                        )
-                    urls = list(volume.browse_data_urls())
-                    try:
-                        metadata = volume.metadata or volume.load_metadata()
-                    except Exception:
-                        metadata = None
-                    slices_urls.extend(urls)
-                    slices_metadata.update({url.path(): metadata for url in urls})
-
-                slices = slices_urls
-
-            elif self.getDisplayMode() is _DisplayMode.DARKS:
-                self._viewer.setNormalizationFct(None)
-                slices = self._scan().darks
-            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)
+        assert isinstance(self._scan(), TomwerScanBase)
+        slices_metadata = {}
+        if self.getDisplayMode() is _DisplayMode.RADIOS:
+            # update the normalization function from the viewer if needed
+            if self.getRadioOption() is _RadioMode.NORMALIZED:
+                url_to_index = {
+                    v.path(): k for k, v in self._scan().projections.items()
+                }
+                self._viewer.setNormalizationFct(
+                    self._scan().data_flat_field_correction,
+                    url_indexes=url_to_index,
+                )
             else:
-                raise ValueError("DisplayMode should be RADIOS or SLICES")
-
-            if isinstance(slices, dict):
-                slices = [
-                    value
-                    for key, value in sorted(slices.items(), key=lambda item: item[0])
-                ]
-            if slices is not None and len(slices) > 0:
-                # TODO: set metadata as well ??? For each url get the metadata as a dict ???
-                self._viewer.setMetadatas(slices_metadata)
-                self._viewer.setUrls(slices)
+                self._viewer.setNormalizationFct(None)
+
+            slices = self._scan().projections
+        elif self.getDisplayMode() is _DisplayMode.SLICES:
+            self._viewer.setNormalizationFct(None)
+            if self.getSliceOption() is _SliceMode.LATEST:
+                slices = self._scan().latest_reconstructions
             else:
-                self._viewer.reset()
+                slices = self._scan().get_reconstructed_slices()
+            # convert volumes identifiers to DataUrl
+            slices_urls = []
+            for identifier in slices:
+                if isinstance(identifier, TomwerVolumeBase):
+                    volume = identifier
+                else:
+                    volume = VolumeFactory.create_tomo_object_from_identifier(
+                        identifier=identifier
+                    )
+                urls = list(volume.browse_data_urls())
+                try:
+                    metadata = volume.metadata or volume.load_metadata()
+                except Exception:
+                    metadata = None
+                slices_urls.extend(urls)
+                slices_metadata.update({url.path(): metadata for url in urls})
+
+            slices = slices_urls
+
+        elif self.getDisplayMode() is _DisplayMode.DARKS:
+            self._viewer.setNormalizationFct(None)
+            slices = self._scan().darks
+        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")
+
+        if isinstance(slices, dict):
+            slices = [
+                value for key, value in sorted(slices.items(), key=lambda item: item[0])
+            ]
+        if slices is not None and len(slices) > 0:
+            # warning: 'setUrls' will clean metadata so we need to first set the urls
+            self._viewer.setUrls(slices)
+            self._viewer.setSliceMetadata(slices_metadata)
+        else:
+            self._viewer.reset()
+        self._viewer._filterUrlList()
 
     def clear(self):
         self._scan = None
@@ -420,304 +368,3 @@ class DisplayControl(qt.QWidget):
 
     def clear(self):
         self._scanQLE.clear()
-
-
-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.setAxesDisplayed(False)
-        self._loadSliceParams = False
-        self._resetZoom = True
-
-        # add dock widget for reconstruction parameters
-        self._reconsInfoDockWidget = qt.QDockWidget(parent=self)
-        self._reconsWidgetScrollArea = qt.QScrollArea(self)
-        self._reconsWidgetScrollArea.setWidgetResizable(True)
-        self._reconsWidget = ReconstructionParameters(self)
-        self._reconsWidgetScrollArea.setWidget(self._reconsWidget)
-        self._reconsInfoDockWidget.setWidget(self._reconsWidgetScrollArea)
-        self._reconsInfoDockWidget.setFeatures(qt.QDockWidget.DockWidgetMovable)
-        self.addDockWidget(qt.Qt.RightDockWidgetArea, self._reconsInfoDockWidget)
-
-        # add scan overview dock widget
-        if show_overview:
-            self._scanOverviewDockerWidget = qt.QDockWidget(parent=self)
-            self._scanOverviewDockerWidget.setMaximumHeight(300)
-            self._scanOverviewWidget = ScanOverviewWidget(self)
-            self._scanOverviewDockerWidget.setWidget(self._scanOverviewWidget)
-            self._scanOverviewDockerWidget.setFeatures(qt.QDockWidget.DockWidgetMovable)
-            self.addDockWidget(
-                qt.Qt.RightDockWidgetArea, self._scanOverviewDockerWidget
-            )
-        else:
-            self._scanOverviewWidget = None
-            self._scanOverviewDockerWidget = None
-
-        # for now hide the "control"
-        self._urlsTable._toggleButton.hide()
-
-        # add an action to plot the url-image 'full size'
-        fullScreenIcon = icons.getQIcon("full_screen")
-        self._fullScreenAction = qt.QAction(fullScreenIcon, "pop up full screen")
-        self.getPlotWidget().toolBar().addAction(self._fullScreenAction)
-        self._fullScreenAction.triggered.connect(self._popCurrentImageFullScreen)
-
-        # set up
-        self.setAutoResetZoom(False)
-
-    def _popCurrentImageFullScreen(self, *args, **kwargs):
-        new_plot = FullScreenPlot2D()
-        active_image = self.getPlotWidget().getActiveImage()
-        if active_image is None or active_image.getData(copy=False) is None:
-            return
-        url = self.getCurrentUrl()
-        window_title = f"Plot of {url.path()}" if url is not None else "Image Plot"
-
-        new_plot.setWindowTitle(window_title)
-        # reuse the same colormap for conveniance (user modification on it will be applied everywhere)
-        new_plot.setDefaultColormap(self.getPlotWidget().getDefaultColormap())
-
-        # add the current image
-        new_plot.addImage(active_image.getData(copy=True))
-
-        new_plot.showFullScreen()
-
-    def setScan(self, scan):
-        if self._scanOverviewWidget is not None:
-            self._scanOverviewWidget.setScan(scan=scan)
-
-    def getUrlListDockWidget(self):
-        return self._tableDockWidget
-
-    def resetZoom(self):
-        self._plot.resetZoom()
-
-    def setLimits(self, x_min, x_max, y_min, y_max):
-        self._plot.setLimits(xmin=x_min, ymin=y_min, xmax=x_max, ymax=y_max)
-
-    def getLimits(self):
-        limits = []
-        limits.extend(self._plot.getGraphXLimits())
-        limits.extend(self._plot.getGraphYLimits())
-        return tuple(limits)
-
-    def setSliceReconsParamsVisible(self, visible):
-        """show or not information regarding the slice reconstructed"""
-        self._reconsInfoDockWidget.setVisible(visible)
-        self._loadSliceParams = visible
-
-    def setScanOverviewVisible(self, visible):
-        """show or not overview of the scan"""
-        if self._scanOverviewDockerWidget is not None:
-            self._scanOverviewDockerWidget.setVisible(visible)
-
-    def setNormalizationFct(self, fct, url_indexes=None):
-        self._normFct = fct
-        self._url_indexes = url_indexes
-
-    def _urlLoaded(self) -> None:
-        """
-
-        :param url: result of DataUrl.path() function
-        :return:
-        """
-        sender = self.sender()
-        url = sender.url.path()
-        if self._urlIndexes is not None and url in self._urlIndexes:
-            data = sender.data
-            if data is None:
-                _logger.warning("no data found (is the url valid ?) " + url)
-                return
-
-            if data.ndim != 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
-            if self._normFct is None:
-                self._urlData[url] = data
-            else:
-                norm_data = self._normFct(data, index=self._urlIndexes[url])
-                self._urlData[url] = norm_data
-
-            if self.getCurrentUrl().path() == 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.resetZoom()
-
-            if sender in self._loadingThreads:
-                self._loadingThreads.remove(sender)
-            self.sigLoaded.emit(url)
-
-    def setResetZoomOnNextIteration(self, reset):
-        self._resetZoom = reset
-
-    def setCurrentUrl(self, url: DataUrl):
-        if url in ("", None):
-            url = None
-        elif isinstance(url, str):
-            url = DataUrl(path=url)
-        elif not isinstance(url, DataUrl):
-            raise TypeError
-        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)
-                )
-            except Exception:
-                _logger.info(f"Failed to find any metadata for {url.path()}.")
-        super().setCurrentUrl(url)
-
-    def setUrls(self, urls: list):
-        _ImageStack.setUrls(self, urls)
-        listWidget = self._urlsTable._urlsTable
-        items = []
-        for i in range(listWidget.count()):
-            # TODO: do this on the fly
-            item = listWidget.item(i)
-            try:
-                url = DataUrl(path=item.text())
-            except Exception:
-                _logger.info(
-                    f"fail to deduce data of last modification for {item.text()}"
-                )
-            else:
-                if os.path.exists(url.file_path()):
-                    lst_m = time.ctime(os.path.getmtime(url.file_path()))
-                    item.setToolTip(f"last modification : {lst_m}")
-            items.append(listWidget.item(i))
-
-    def setMetadatas(self, metadatas: dict):
-        """
-        :param dict metadata: for each url define a dict of the metadata
-        """
-        self._metadatas = metadatas
-
-
-class _TomwerUrlLoader(UrlLoader):
-    """
-    Thread use to load DataUrl
-    """
-
-    def run(self):
-        if self.url.file_path().endswith(".vol"):
-            self.data = self._load_vol()
-        elif self.url.scheme() == "tomwer":
-            if has_PIL:
-                self.data = numpy.array(Image.open(self.url.file_path()))
-                if self.url.data_slice() is not None:
-                    self.data = self.data[self.url.data_slice()]
-            else:
-                _logger.warning(
-                    "need to install Pillow to read file " + self.url.file_path()
-                )
-                self.data = None
-        else:
-            try:
-                self.data = get_slice_data(self.url)
-            except IOError:
-                self.data = None
-            except ValueError:
-                self.data = None
-                _logger.warning(
-                    f"Fail to open {self.url.path()}. Maybe the reconstruction failed."
-                )
-
-    def _load_vol(self):
-        """
-        load a .vol file
-        """
-        if self.url.file_path().lower().endswith(".vol.info"):
-            info_file = self.url.file_path()
-            raw_file = self.url.file_path().replace(".vol.info", ".vol")
-        else:
-            assert self.url.file_path().lower().endswith(".vol")
-            raw_file = self.url.file_path()
-            info_file = self.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 %s is too large for being read {raw_file}"
-                    )
-                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 self.url.data_slice() is None:
-            return data
-        else:
-            return data[self.url.data_slice()]