tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/gui/visualization/test/test_stacks.py

@@ -1,134 +1,203 @@
-# 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__ = "16/06/2021"
-
 import logging
 import os
-import shutil
-import tempfile
-import time
-import weakref
 
 import numpy
 import pytest
 from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
-from tomoscan.esrf.volume.edfvolume import EDFVolume
-
+from tomwer.core.volume.edfvolume import EDFVolume
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.core.process.reconstruction.output import (
+    PROCESS_FOLDER_RECONSTRUCTED_SLICES,
+)
 from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.stacks import RadioStack, SliceStack
 from tomwer.tests.utils import skip_gui_test
+from tomwer.tests.conftest import qtapp  # noqa F401
 
 logging.disable(logging.INFO)
 
 
+@pytest.mark.parametrize("use_identifiers", (True, False))
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
-class TestSliceStack(TestCaseQt):
-    """unit test for the :class:_ImageStack widget"""
-
-    def setUp(self):
-        super().setUp()
-        self._widget = SliceStack()
-        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-
-    def tearDown(self):
-        self._widget.close()
-        self._widget = None
-        self.qapp.processEvents()
-        super().tearDown()
-
-    def test_hdf5(self):
-        self.assertEqual(len(self._widget._scans), 0)
-        n_scan = 5
-        n_slice_per_scan = 1
-        with tempfile.TemporaryDirectory() as root_dir:
-            for i_scan in range(n_scan):
-                scan = MockNXtomo(
-                    scan_path=os.path.join(root_dir, f"scan{i_scan}"),
-                    n_proj=10,
-                    n_ini_proj=10,
-                    scan_range=180,
-                    dim=10,
-                ).scan
-                volume = EDFVolume(
-                    folder=os.path.join(scan.path, "edf_volume"),
-                    data=numpy.random.random(10 * 10 * n_slice_per_scan).reshape(
-                        n_slice_per_scan, 10, 10
-                    ),
-                )
-                volume.save()
-                scan.set_latest_reconstructions((volume,))
-                assert len(scan.latest_reconstructions) == 1
-                self._widget.addLeafScan(scan)
-        self.assertEqual(len(self._widget._scans), n_scan)
-        self.assertEqual(len(self._widget.extractImages()), n_scan * n_slice_per_scan)
-
-
+def test_slice_stack(
+    qtapp,  # noqa F811
+    tmp_path,
+    use_identifiers,
+):
+    """
+    :param use_identifiers: If true will add the different tomo object using identifiers instead of class instances.
+    """
+    widget = SliceStack()
+    widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+
+    url_list = widget._viewer._urlsTable._urlsTable
+    assert url_list.count() == 0
+    n_scan = 5
+
+    root_dir = tmp_path / "test_slice_stack"
+    root_dir.mkdir()
+
+    def create_vol_data(n_slice=1):
+        return numpy.random.random(10 * 10 * n_slice).reshape(n_slice, 10, 10)
+
+    volume_metadata = {
+        "nabu_config": {
+            "reconstruction": {
+                "method": "FBP",
+            },
+            "phase": {
+                "method": "paganin",
+                "delta_beta": 110.0,
+            },
+        },
+        "processing_options": {
+            "reconstruction": {
+                "voxel_size_cm": (0.2, 0.2, 0.2),
+                "rotation_axis_position": 104,
+                "enable_halftomo": True,
+                "fbp_filter_type": "Hilbert",
+                "sample_detector_dist": 0.4,
+            },
+            "take_log": {
+                "log_min_clip": 1.0,
+                "log_max_clip": 10.0,
+            },
+        },
+    }
+
+    # step 1: test adding some scans
+    for i_scan in range(n_scan):
+        scan = MockNXtomo(
+            scan_path=os.path.join(root_dir, f"scan{i_scan}"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=10,
+        ).scan
+        volume = EDFVolume(
+            folder=os.path.join(
+                scan.path,
+                PROCESS_FOLDER_RECONSTRUCTED_SLICES,
+                f"edf_volume_scan_{i_scan}",
+            ),
+            volume_basename=f"edf_volume_scan_{i_scan}",
+            data=create_vol_data(),
+            metadata=volume_metadata,
+        )
+        volume.save()
+        scan.set_latest_reconstructions((volume,))
+        assert len(scan.latest_reconstructions) == 1
+        if use_identifiers:
+            widget.addTomoObj(scan.get_identifier().to_str())
+        else:
+            widget.addTomoObj(scan)
+
+    last_scan_added = scan
+
+    assert url_list.count() == n_scan
+    assert len(widget._volume_id_to_urls) == n_scan
+
+    # step 2: test adding some volumes
+    n_volume = 4
+    last_edf_volume_added = None
+    last_hdf5_volume_added = None
+
+    for i_vol in range(n_volume):
+        volume_metadata["nabu_config"]["phase"]["delta_beta"] += i_vol
+        volume_type = [EDFVolume, HDF5Volume][i_vol % 2]
+        if volume_type == EDFVolume:
+            volume = EDFVolume(
+                folder=root_dir
+                / PROCESS_FOLDER_RECONSTRUCTED_SLICES
+                / f"slice_{i_vol}",
+                volume_basename=f"slice_{i_vol}",
+                data=create_vol_data(),
+                metadata=volume_metadata,
+            )
+            last_edf_volume_added = volume
+        elif volume_type == HDF5Volume:
+            volume = HDF5Volume(
+                file_path=os.path.join(
+                    root_dir
+                    / PROCESS_FOLDER_RECONSTRUCTED_SLICES
+                    / f"my_vol_{i_vol}.hdf5"
+                ),
+                data_path="entry0000",
+                data=create_vol_data(),
+                metadata=volume_metadata,
+            )
+            last_hdf5_volume_added = volume
+        else:
+            raise TypeError
+        volume.save()
+        if use_identifiers:
+            widget.addTomoObj(volume.get_identifier().to_str())
+        else:
+            widget.addTomoObj(volume)
+
+    assert len(widget._volume_id_to_urls) == (n_scan + n_volume)
+    assert len(widget._viewer.getUrls()) == (n_scan + n_volume)
+
+    widget.clear()
+    assert len(widget._volume_id_to_urls) == 0
+
+    # check adding objects from a list of string
+    assert n_volume >= 2, "following test won't be able to be correctly executed"
+    widget._addTomoObjectsFromStrList(
+        [
+            last_hdf5_volume_added.file_path,
+            last_edf_volume_added.url.file_path(),
+            last_scan_added.path,
+        ]
+    )
+    # dummy check metadata are displayed
+    widget._viewer._reconsWidget._deltaBetaQLE.text().startswith("1")
+    assert len(widget._volume_id_to_urls) == 3
+    # try adding a non existing path
+    widget._addTomoObjectsFromStrList(
+        [
+            "/none/existing/path",
+            "/none/existing/path.hdf5",
+        ]
+    )
+
+    widget.close()
+
+
+@pytest.mark.parametrize("use_identifiers", (True, False))
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
-class TestRadioStack(TestCaseQt):
+def test_radio_stack(
+    qtapp,  # noqa F811
+    tmp_path,
+    use_identifiers: bool,
+):
     """
-    Test for the RadioStack
-    The main part of test on mode is done on silx side, test of silx.gui.plot.ImageStack
+    :param use_identifiers: If true will add the different tomo object using identifiers instead of class instances.
     """
-
-    def setUp(self):
-        super().setUp()
-        self._widget = RadioStack()
-        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self.spinBox = weakref.ref(self._widget._viewer._qspinbox)
-        self.slider = weakref.ref(self._widget._viewer._qslider)
-        self._tmp_dir = tempfile.mkdtemp()
-        os.makedirs(self._tmp_dir, exist_ok=True)
-        self._scan = MockNXtomo(
-            os.path.join(self._tmp_dir, "my_scan"),
-            n_proj=30,
+    widget = RadioStack()
+    widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+
+    widget_urls = widget._viewer._urlsTable._urlsTable
+    n_scan = 3
+
+    root_dir = tmp_path / "test_radio_stack"
+    root_dir.mkdir()
+    proj_per_scan = 10
+
+    # step 1: test adding some scans
+    for i_scan in range(n_scan):
+        scan = MockNXtomo(
+            scan_path=os.path.join(root_dir, f"scan{i_scan}"),
+            n_proj=proj_per_scan,
+            n_ini_proj=proj_per_scan,
+            scan_range=180,
             dim=10,
         ).scan
-
-    def tearDown(self):
-        shutil.rmtree(self._tmp_dir)
-        self._widget.close()
-        self._widget = None
-        self.qapp.processEvents()
-        super().tearDown()
-
-    def _waitImages(self):
-        for _ in range(5):
-            self.qapp.processEvents()
-            time.sleep(0.1)
-
-    def testASAPMode(self):
-        self._widget.setLoadingMode("load ASAP")
-        self._widget.setForceSync(True)
-        self._widget.addLeafScan(self._scan.master_file)
-        self._waitImages()
-
-        self.spinBox().setValue(20)
-        self._waitImages()
-
-        self.slider().setValue(10)
-        self.qapp.processEvents()
+        if use_identifiers:
+            widget.addTomoObj(scan.get_identifier().to_str())
+        else:
+            widget.addTomoObj(scan)
+    assert widget_urls.count() == n_scan * proj_per_scan
+
+    widget.show()
+    widget.close()

tomwer/gui/visualization/test/test_volumeviewer.py

@@ -5,8 +5,9 @@ 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.core.volume.hdf5volume import HDF5Volume
+from tomwer.core.volume.tiffvolume import TIFFVolume
+from tomoscan.esrf.volume.tiffvolume import has_tifffile
 
 from tomwer.tests.conftest import qtapp  # noqa F401
 from tomwer.core.utils.scanutils import MockNXtomo

tomwer/gui/visualization/tomoobjoverview.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from __future__ import annotations
 
 from silx.gui import qt
 
@@ -27,7 +27,7 @@ class TomoObjOverview(qt.QWidget):
         self._scanOverview.setVisible(False)
         self._volumeOverview.setVisible(False)
 
-    def setTomoObj(self, tomo_obj: Optional[TomwerObject]):
+    def setTomoObj(self, tomo_obj: TomwerObject | None):
         """
         update sub widgets according to the type of tomo_obj
         """

tomwer/gui/visualization/volumeoverview.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import logging
-from typing import Optional
 
 from silx.gui import qt
 from tomoscan.identifier import VolumeIdentifier
@@ -33,7 +34,7 @@ class VolumeOverviewWidget(qt.QWidget):
         self._y_pixel_size = qt.QTreeWidgetItem(self._tree)
         self._y_pixel_size.setText(0, "y pixel size")
 
-    def setVolume(self, volume: Optional[TomwerVolumeBase]):
+    def setVolume(self, volume: TomwerVolumeBase | None):
         if volume is None:
             self._x_position.setText(1, "")
             self._y_position.setText(1, "")

tomwer/gui/visualization/volumeviewer.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import logging
 import weakref
 import h5py
-from typing import Union
 
 import numpy
 import numpy.lib.npyio
@@ -11,13 +12,14 @@ from silx.gui.colors import Colormap
 from silx.gui.data.DataViewerFrame import DataViewerFrame
 from silx.gui.data.DataViews import IMAGE_MODE, DataViewHooks
 from silx.gui.dialog.ColormapDialog import ColormapDialog
-from tomoscan.esrf.volume.hdf5volume import HDF5Volume
-from tomoscan.factory import Factory
-from tomoscan.identifier import VolumeIdentifier
-from tomoscan.volumebase import VolumeBase
 
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.visualization.reconstructionparameters import ReconstructionParameters
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomoscan.identifier import VolumeIdentifier
+
 from silx.gui.widgets.WaitingOverlay import WaitingOverlay
 
 _logger = logging.getLogger(__name__)
@@ -37,17 +39,27 @@ class _ScanInfo(qt.QWidget):
         self._volumeQLE.setReadOnly(True)
         self.layout().addRow("volume", self._volumeQLE)
 
-    def setScan(self, scan):
+    def setScan(self, scan: None | TomwerScanBase):
         if scan is None:
-            self._scanQLE.setText("")
-            self._volumeQLE.setText("")
+            self._scanQLE.clear()
         else:
-            assert isinstance(scan, TomwerScanBase)
+            assert isinstance(
+                scan, TomwerScanBase
+            ), f"scan should be an instance of {TomwerScanBase}. Got {type(scan)}"
             self._scanQLE.setText(str(scan))
-            if len(scan.latest_vol_reconstructions) == 0:
-                self._volumeQLE.setText("")
-            else:
-                self._volumeQLE.setText(str(scan.latest_vol_reconstructions[0]))
+            self.setVolumes(volumes=scan.latest_vol_reconstructions)
+
+    def setVolumes(self, volumes: tuple[str | VolumeIdentifier | TomwerVolumeBase]):
+        """
+        Display volume metadata. At the moment only display the identifier of the first reconstructed volume
+        """
+        self._volumeQLE.clear()
+        if len(volumes) > 0:
+            volume = volumes[0]
+            if not isinstance(volume, TomwerVolumeBase):
+                volume = VolumeFactory.create_tomo_object_from_identifier(volume)
+            self._volumeQLE.setText(str(volume))
+            self._volumeQLE.setToolTip(volume.data_url.file_path())
 
     def clear(self):
         self.setScan(None)
@@ -71,11 +83,8 @@ class _TomoApplicationContext(DataViewHooks):
         self.__settings = settings
         self.__recentFiles = []
 
-    def getSettings(self):
-        """Returns actual application settings.
-
-        :rtype: qt.QSettings
-        """
+    def getSettings(self) -> qt.QSettings:
+        """Returns actual application settings."""
         return self.__settings
 
     def restoreLibrarySettings(self):
@@ -154,17 +163,15 @@ class _TomoApplicationContext(DataViewHooks):
                 settings.remove(key)
         settings.endGroup()
 
-    def getRecentFiles(self):
+    def getRecentFiles(self) -> list[str]:
         """Returns the list of recently opened files.
 
         The list is limited to the last 10 entries. The newest file path is
         in first.
-
-        :rtype: List[str]
         """
         return self.__recentFiles
 
-    def pushRecentFile(self, filePath):
+    def pushRecentFile(self, filePath: str):
         """Push a new recent file to the list.
 
         If the file is duplicated in the list, all duplications are removed
@@ -181,26 +188,22 @@ class _TomoApplicationContext(DataViewHooks):
             self.__recentFiles.pop()
 
     def clearRencentFiles(self):
-        """Clear the history of the rencent files."""
+        """Clear the history of the recent files."""
         self.__recentFiles[:] = []
 
-    def getColormap(self, view):
+    def getColormap(self, view) -> Colormap:
         """Returns a default colormap.
 
         Override from DataViewHooks
-
-        :rtype: Colormap
         """
         if self.__defaultColormap is None:
             self.__defaultColormap = Colormap(name="viridis")
         return self.__defaultColormap
 
-    def getColormapDialog(self, view):
+    def getColormapDialog(self, view) -> ColormapDialog:
         """Returns a shared color dialog as default for all the views.
 
         Override from DataViewHooks
-
-        :rtype: ColorDialog
         """
         if self.__defaultColormapDialog is None:
             parent = self.__parent()
@@ -280,19 +283,20 @@ class VolumeViewer(qt.QMainWindow):
             self._infoWidget.setScan(scan)
 
     def setVolume(self, volume):
-        self.clear()
+        self.clear(clear_infos=False)
         if volume is None:
             return
         self._set_volumes(volumes=(volume,))
+        self._infoWidget.setVolumes((volume,))
 
-    def _get_data_volume(self, volume: VolumeBase):
+    def _get_data_volume(self, volume: TomwerVolumeBase):
         """
         load the data of the requested volume.
-        :return: (data: Optional[str], state: str) state can be "loaded", "loading" or "failed"
+        :return: (data: str | None, state: str) state can be "loaded", "loading" or "failed"
         """
-        if not isinstance(volume, VolumeBase):
+        if not isinstance(volume, TomwerVolumeBase):
             raise TypeError(
-                f"volume is expected to be an instance of {VolumeBase}. Not {type(volume)}"
+                f"volume is expected to be an instance of {TomwerVolumeBase}. Not {type(volume)}"
             )
 
         self._close_h5_file()
@@ -306,7 +310,6 @@ class VolumeViewer(qt.QMainWindow):
                     libver="latest",
                     swmr=True,
                 )
-
             if volume.data_url.data_path() in self._h5_file:
                 data = self._h5_file[volume.data_url.data_path()]
                 state = "loaded"
@@ -343,7 +346,7 @@ class VolumeViewer(qt.QMainWindow):
         self._stopExistingLoaderThread()
         if sender.volume.data is None:
             _logger.error(f"Failed to load volume {sender.volume.get_identifier()}")
-        else:
+        elif sender.volume is not None:
             self.setVolume(sender.volume)
 
     def _loadAndDisplay(self, volume):
@@ -377,8 +380,8 @@ class VolumeViewer(qt.QMainWindow):
                 )
             volume = volumes[0]
             if isinstance(volume, (str, VolumeIdentifier)):
-                volume = Factory.create_tomo_object_from_identifier(volume)
-            elif isinstance(volume, VolumeBase):
+                volume = VolumeFactory.create_tomo_object_from_identifier(volume)
+            elif isinstance(volume, TomwerVolumeBase):
                 pass
             else:
                 raise TypeError(
@@ -412,15 +415,16 @@ class VolumeViewer(qt.QMainWindow):
                 )
                 return
 
-    def _set_volume(self, volume: Union[numpy.ndarray, h5py.Dataset]):
+    def _set_volume(self, volume: numpy.ndarray | h5py.Dataset):
         self._centralWidget.setData(volume)
         self._centralWidget.setDisplayMode(self.__last_mode or IMAGE_MODE)
 
-    def clear(self):
+    def clear(self, clear_infos=True):
         if self._centralWidget.displayMode():
             self.__last_mode = self._centralWidget.displayMode()
         self._close_h5_file()
-        self._infoWidget.clear()
+        if clear_infos:
+            self._infoWidget.clear()
         self._centralWidget.setData(None)
         # if clear stop loading any volume
         self._stopExistingLoaderThread()
@@ -434,9 +438,9 @@ class VolumeLoader(qt.QThread):
     simple thread that load a volume in memory
     """
 
-    def __init__(self, volume: VolumeBase) -> None:
+    def __init__(self, volume: TomwerVolumeBase) -> None:
         super().__init__()
-        if not isinstance(volume, VolumeBase):
+        if not isinstance(volume, TomwerVolumeBase):
             raise TypeError()
         self.__volume = volume
 

tomwer/io/__init__.py

@@ -0,0 +1,2 @@
+"""This package provides functionalities for inputs and outputs (read, write)
+"""

tomwer/io/utils/h5pyutils.py

@@ -1,34 +1,8 @@
 # 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 utils for inputs and outputs
 """
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "22/04/2021"
+from __future__ import annotations
 
 
 import contextlib

tomwer/io/utils/test/test_raw_and_processed_data.py

@@ -0,0 +1,10 @@
+from tomwer.io.utils.raw_and_processed_data import file_is_on_processed_data
+
+
+def test_file_is_on_processed_data():
+    """test file_is_on_processed_data function"""
+    assert file_is_on_processed_data("/path/to/file") == False
+    assert file_is_on_processed_data("/path/to/PROCESSED_DATA/file") == True
+    assert file_is_on_processed_data("/path/to/RAW_DATA/file") == False
+    assert file_is_on_processed_data("/path/to/RAW_DATA/PROCESSED_DATA/file") == True
+    assert file_is_on_processed_data("/path/to/PROCESSED_DATA/RAW_DATA/file") == False