tomwer 1.3.0a2__tar.gz → 1.3.0a4__tar.gz

{tomwer-1.3.0a2 → tomwer-1.3.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.3.0a2
+Version: 1.3.0a4
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: data analysis unit

{tomwer-1.3.0a2 → tomwer-1.3.0a4}/tomwer/core/process/reconstruction/nabu/nabucommon.py

@@ -147,10 +147,29 @@ class ResultsLocalRun(ResultsWithStd):
             raise TypeError(
                 f"results_urls is expected to be an Iterable not {type(results_identifiers)}"
             )
-        for identifier in results_identifiers:
-            if not isinstance(identifier, VolumeIdentifier):
-                raise TypeError("identifiers are expected to be VolumeIdentifier")
-        self.__results_identifiers = results_identifiers
+
+        # check all identifiers
+        from tomwer.core.volume.volumefactory import VolumeFactory
+
+        def check_identifier(identifier):
+            if isinstance(identifier, str):
+                vol = VolumeFactory.create_tomo_object_from_identifier(
+                    identifier=identifier
+                )
+                return vol.get_identifier()
+            elif not isinstance(identifier, VolumeIdentifier):
+                raise TypeError(
+                    f"identifiers are expected to be VolumeIdentifier. Get {type(identifier)} instead."
+                )
+            else:
+                return identifier
+
+        self.__results_identifiers = tuple(
+            [
+                check_identifier(identifier=identifier)
+                for identifier in results_identifiers
+            ]
+        )
 
     @property
     def results_identifiers(self) -> tuple:

tomwer-1.3.0a4/tomwer/gui/visualization/test/test_volumeviewer.py

@@ -0,0 +1,82 @@
+import logging
+import os
+import pytest
+import numpy
+from time import sleep
+
+from silx.gui import qt
+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)
+
+
+@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()
+
+    scan.set_latest_vol_reconstructions(
+        [
+            volume,
+        ]
+    )
+
+    widget.setScan(scan)
+    assert widget._centralWidget.data() is not None
+    widget.clear()
+    assert widget._centralWidget.data() is None
+
+    # 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()
+
+    # 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
+
+    # 2.2 test with the data not being in cache anymore
+    volume.clear_cache()
+
+    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-1.3.0a2 → tomwer-1.3.0a4}/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
@@ -49,9 +18,13 @@ from tomoscan.volumebase import VolumeBase
 from tomoscan.io import HDF5File
 
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.ftseriesutils import get_vol_file_shape
 from tomwer.gui.visualization.reconstructionparameters import ReconstructionParameters
 
+try:
+    from silx.gui.widgets.WaitingOverlay import WaitingOverlay
+except ImportError:
+    from tomwer.third_part.WaitingOverlay import WaitingOverlay
+
 _logger = logging.getLogger(__name__)
 
 
@@ -247,6 +220,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 +230,11 @@ 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))
+
+        # display scan information when possible
         self._infoWidget = _ScanInfo(parent=self)
 
         # top level dock widget to display information regarding the scan
@@ -308,9 +289,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)}"
@@ -321,15 +305,61 @@ class VolumeViewer(qt.QMainWindow):
             self._h5_file = HDF5File(filename=volume.data_url.file_path(), mode="r")
             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")
+
+        if sender.volume.data is None:
+            _logger.error(f"Failed to load volume {sender.volume.get_identifier()}")
 
-        return data
+        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,21 +381,30 @@ 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)
+            data, state = self._get_data_volume(volume)
             # set volume dataset
-            if data is not None:
-                self._set_volume(data)
-            # set reconstruction parameters
-            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
-                self._reconsWidget.setVolumeMetadata(
-                    volume.metadata or volume.load_metadata()
-                )
-            except Exception as e:
-                _logger.info(
-                    f"Unable to set reconstruction parameters from {volume.data_url}. Not handled for pyhst reconstructions. Error is {e}"
+            if state == "loading":
+                self._waitingOverlay.show()
+                pass
+            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()}"
                 )
+                # set reconstruction parameters
+                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
+                    self._reconsWidget.setVolumeMetadata(
+                        volume.metadata or volume.load_metadata()
+                    )
+                except Exception as e:
+                    _logger.info(
+                        f"Unable to set reconstruction parameters from {volume.data_url}. Not handled for pyhst reconstructions. Error is {e}"
+                    )
 
     def _set_volume(self, volume: Union[numpy.ndarray, h5py.Dataset]):
         self._centralWidget.setData(volume)
@@ -380,68 +419,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

tomwer-1.3.0a4/tomwer/third_part/WaitingOverlay.py

@@ -0,0 +1,110 @@
+from typing import Optional
+from silx.gui.widgets.WaitingPushButton import WaitingPushButton
+from silx.gui import qt
+from silx.gui.qt import inspect as qt_inspect
+from silx.gui.plot import PlotWidget
+
+
+class WaitingOverlay(qt.QWidget):
+    """Widget overlaying another widget with a processing wheel icon.
+
+    :param parent: widget on top of which to display the "processing/waiting wheel"
+    """
+
+    def __init__(self, parent: qt.QWidget) -> None:
+        super().__init__(parent)
+        self.setContentsMargins(0, 0, 0, 0)
+
+        self._waitingButton = WaitingPushButton(self)
+        self._waitingButton.setDown(True)
+        self._waitingButton.setWaiting(True)
+        self._waitingButton.setStyleSheet(
+            "QPushButton { background-color: rgba(150, 150, 150, 40); border: 0px; border-radius: 10px; }"
+        )
+        self._registerParent(parent)
+
+    def text(self) -> str:
+        """Returns displayed text"""
+        return self._waitingButton.text()
+
+    def setText(self, text: str):
+        """Set displayed text"""
+        self._waitingButton.setText(text)
+        self._resize()
+
+    def _listenedWidget(self, parent: qt.QWidget) -> qt.QWidget:
+        """Returns widget to register event filter to according to parent"""
+        if isinstance(parent, PlotWidget):
+            return parent.getWidgetHandle()
+        return parent
+
+    def _backendChanged(self):
+        self._listenedWidget(self.parent()).installEventFilter(self)
+        self._resizeLater()
+
+    def _registerParent(self, parent: Optional[qt.QWidget]):
+        if parent is None:
+            return
+        self._listenedWidget(parent).installEventFilter(self)
+        if isinstance(parent, PlotWidget):
+            parent.sigBackendChanged.connect(self._backendChanged)
+        self._resize()
+
+    def _unregisterParent(self, parent: Optional[qt.QWidget]):
+        if parent is None:
+            return
+        if isinstance(parent, PlotWidget):
+            parent.sigBackendChanged.disconnect(self._backendChanged)
+        self._listenedWidget(parent).removeEventFilter(self)
+
+    def setParent(self, parent: qt.QWidget):
+        self._unregisterParent(self.parent())
+        super().setParent(parent)
+        self._registerParent(parent)
+
+    def showEvent(self, event: qt.QShowEvent):
+        super().showEvent(event)
+        self._waitingButton.setVisible(True)
+
+    def hideEvent(self, event: qt.QHideEvent):
+        super().hideEvent(event)
+        self._waitingButton.setVisible(False)
+
+    def _resize(self):
+        if not qt_inspect.isValid(self):
+            return  # For _resizeLater in case the widget has been deleted
+
+        parent = self.parent()
+        if parent is None:
+            return
+
+        size = self._waitingButton.sizeHint()
+        if isinstance(parent, PlotWidget):
+            offset = parent.getWidgetHandle().mapTo(parent, qt.QPoint(0, 0))
+            left, top, width, height = parent.getPlotBoundsInPixels()
+            rect = qt.QRect(
+                qt.QPoint(
+                    int(offset.x() + left + width / 2 - size.width() / 2),
+                    int(offset.y() + top + height / 2 - size.height() / 2),
+                ),
+                size,
+            )
+        else:
+            position = parent.size()
+            position = (position - size) / 2
+            rect = qt.QRect(qt.QPoint(position.width(), position.height()), size)
+        self.setGeometry(rect)
+        self.raise_()
+
+    def _resizeLater(self):
+        qt.QTimer.singleShot(0, self._resize)
+
+    def eventFilter(self, watched: qt.QWidget, event: qt.QEvent):
+        if event.type() == qt.QEvent.Resize:
+            self._resize()
+            self._resizeLater()  # Defer resize for the receiver to have handled it
+        return super().eventFilter(watched, event)
+
+    # expose Waiting push button API
+    def setIconSize(self, size):
+        self._waitingButton.setIconSize(size)

{tomwer-1.3.0a2 → tomwer-1.3.0a4}/tomwer/version.py

@@ -79,7 +79,7 @@ MAJOR = 1
 MINOR = 3
 MICRO = 0
 RELEV = "alpha"  # <16
-SERIAL = 2  # <16
+SERIAL = 4  # <16
 
 date = __date__
 

{tomwer-1.3.0a2 → tomwer-1.3.0a4}/tomwer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.3.0a2
+Version: 1.3.0a4
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: data analysis unit

{tomwer-1.3.0a2 → tomwer-1.3.0a4}/tomwer.egg-info/SOURCES.txt

@@ -825,4 +825,6 @@ tomwer/tests/conftest.py
 tomwer/tests/datasets.py
 tomwer/tests/test_scripts.py
 tomwer/tests/test_utils.py
-tomwer/tests/utils.py
+tomwer/tests/utils.py
+tomwer/third_part/WaitingOverlay.py
+tomwer/third_part/__init__.py

tomwer-1.3.0a2/tomwer/gui/visualization/test/test_volumeviewer.py

@@ -1,84 +0,0 @@
-# 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 numpy
-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 MockNXtomo
-from tomwer.gui.visualization.volumeviewer import VolumeViewer
-
-logging.disable(logging.INFO)
-
-
-class TestDiffViewer(TestCaseQt):
-    """unit test for the :class:_ImageStack widget"""
-
-    def setUp(self):
-        TestCaseQt.setUp(self)
-        self._widget = VolumeViewer(parent=None)
-        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-
-        self.tmp_dir = tempfile.mkdtemp()
-
-        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()
-
-        self.scan.set_latest_vol_reconstructions(
-            [
-                volume,
-            ]
-        )
-
-    def tearDown(self):
-        shutil.rmtree(self.tmp_dir)
-        self._widget.close()
-        self._widget = None
-        unittest.TestCase.tearDown(self)
-
-    def test(self):
-        self._widget.setScan(self.scan)