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

tomwer/tests/orangecontrib/tomwer/widgets/edit/tests/test_nxtomo_editor.py

@@ -0,0 +1,138 @@
+import os
+import pickle
+
+import numpy
+import pytest
+from nxtomomill.nexus.nxtomo import NXtomo
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui.utils.testutils import SignalListener
+from nxtomo.nxobject.nxdetector import ImageKey
+
+from orangecontrib.tomwer.widgets.edit.NXtomoEditorOW import NXtomoEditorOW
+from tomwer.core.process.edit.nxtomoeditor import NXtomoEditorKeys
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.tests.utils import skip_gui_test
+from tomwer.gui.utils.qt_utils import QSignalSpy
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def getDefaultConfig() -> dict:
+    """return the configuration of the NXtomo editor. First value is the value of the field, second is: is the associated lock button locked or not"""
+    return {
+        NXtomoEditorKeys.ENERGY: (5.9, False),
+        NXtomoEditorKeys.SAMPLE_DETECTOR_DISTANCE: (2.4, True),
+        NXtomoEditorKeys.FIELD_OF_VIEW: ("Full", False),
+        NXtomoEditorKeys.X_PIXEL_SIZE: (0.023, True),
+        NXtomoEditorKeys.Y_PIXEL_SIZE: (0.025, True),
+        NXtomoEditorKeys.X_FLIPPED: (True, True),
+        NXtomoEditorKeys.Y_FLIPPED: (False, False),
+        NXtomoEditorKeys.X_TRANSLATION: (0.0,),
+        NXtomoEditorKeys.Z_TRANSLATION: (0.0,),
+    }
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+def test_NXtomoEditorOW(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    window = NXtomoEditorOW()
+    # test serialization
+    window.setConfiguration(getDefaultConfig())
+    assert window.getConfiguration() == getDefaultConfig()
+    pickle.dumps(window.getConfiguration())
+
+    # test literal dumps
+    literal_dumps(window.getConfiguration())
+
+    # test widget automation
+    signal_listener = SignalListener()
+    window.sigScanReady.connect(signal_listener)
+    # set up the widget to define and lock distance, energy and x pixel size
+    distance_widget = window.widget.mainWidget._distanceMetricEntry
+    distance_widget.setValue(0.6)
+    distance_widget.setUnit("mm")
+    distance_locker = window.widget.mainWidget._distanceLB
+    distance_locker.setLock(True)
+    energy_widget = window.widget.mainWidget._energyEntry
+    energy_widget.setValue(88.058)
+    energy_locker = window.widget.mainWidget._energyLockerLB
+    energy_locker.setLock(True)
+    x_pixel_widget = window.widget.mainWidget._xPixelSizeMetricEntry
+    x_pixel_widget.setValue(45)
+    x_pixel_widget.setUnit("nm")
+    x_pixel_locker = window.widget.mainWidget._xPixelSizeLB
+    x_pixel_locker.setLock(True)
+
+    # 1.0 create nx tomos with raw data
+    nx_tomo = NXtomo()
+    nx_tomo.instrument.detector.x_pixel_size = (
+        0.023  # should be overwrite by the configuration / lock buttons
+    )
+    nx_tomo.instrument.detector.y_pixel_size = (
+        0.025  # should be overwrite by the configuration / lock buttons
+    )
+    nx_tomo.instrument.detector.field_of_view = "full"
+    nx_tomo.instrument.detector.distance = (
+        2.4  # should be overwrite by the configuration / lock buttons
+    )
+    nx_tomo.instrument.detector.x_flipped = (
+        False  # should be overwrite by the configuration / lock buttons
+    )
+    nx_tomo.instrument.detector.y_flipped = True
+    nx_tomo.energy = 5.9
+    nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
+    nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
+    nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+
+    file_path = os.path.join(tmp_path, "nxtomo.nx")
+    entry = "entry0000"
+    nx_tomo.save(
+        file_path=file_path,
+        data_path=entry,
+    )
+    # 2.0 set scan to the nxtomo-editor
+    scan = NXtomoScan(file_path, entry)
+    waiter = QSignalSpy(window.sigScanReady)
+    window.setScan(scan=scan)
+    # warning: avoid executing the ewoks task as this will be done
+    # automatically (has some field lock). This would create concurrency task
+    # and could bring some HDF5 concurrency error
+    waiter.wait(5000)
+    # 3.0 check results are as expected
+    # make sure the scan has been re-emitted
+    assert signal_listener.callCount() == 1
+    # make sure the edition of the parameters have been done and only those
+    overwrite_nx_tomo = NXtomo().load(
+        file_path=file_path,
+        data_path=entry,
+        detector_data_as="as_numpy_array",
+    )
+    numpy.testing.assert_almost_equal(
+        overwrite_nx_tomo.instrument.detector.x_pixel_size.si_value, 45e-9
+    )
+    assert (
+        overwrite_nx_tomo.instrument.detector.y_pixel_size.si_value
+        == nx_tomo.instrument.detector.y_pixel_size.si_value
+    )
+    assert (
+        overwrite_nx_tomo.instrument.detector.field_of_view
+        == nx_tomo.instrument.detector.field_of_view
+    )
+    numpy.testing.assert_almost_equal(
+        overwrite_nx_tomo.instrument.detector.distance.value, 6.0e-4
+    )
+    assert (
+        overwrite_nx_tomo.instrument.detector.x_flipped
+        == True  # is lock to True so should load the value and overwrite it
+    )
+
+    assert (
+        overwrite_nx_tomo.instrument.detector.y_flipped
+        == True  # is not locked and is initially set to False (should load it and ignore overwriting)
+    )
+    numpy.testing.assert_almost_equal(overwrite_nx_tomo.energy.value, 88.058)
+    numpy.testing.assert_array_almost_equal(
+        overwrite_nx_tomo.instrument.detector.data,
+        nx_tomo.instrument.detector.data,
+    )

tomwer/tests/orangecontrib/tomwer/widgets/other/tests/test_pythonscript.py

@@ -0,0 +1,31 @@
+import gc
+import logging
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.other.PythonScriptOW import OWPythonScript
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.volume.hdf5volume import HDF5Volume
+
+logging.disable(logging.INFO)
+
+
+class TestEDFDarkRefWidget(TestCaseQt):
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self.widget = OWPythonScript()
+        self._scan = NXtomoScan("my_file.hdf5", entry="entry0000")
+        self._volume = HDF5Volume(file_path="my_volume.hdf5", data_path="volume")
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test_handle_data(self):
+        self.widget.handle_input(self._scan, (1,), "data")
+
+    def test_handle_volume(self):
+        self.widget.handle_input(self._volume, (1,), "volume")

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_axis.py

@@ -0,0 +1,215 @@
+import gc
+import pickle
+import shutil
+import tempfile
+import time
+import os
+
+import pytest
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.AxisOW import AxisOW
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.settings import mock_lsbram
+from tomwer.core.utils.scanutils import MockNXtomo, MockEDF
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestOWAxis(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        self._window = AxisOW()
+        self.recons_params = self._window.recons_params
+        self.tempdir = tempfile.mkdtemp()
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=20,
+            energy=12.3,
+        ).scan
+
+        self._window.getAxisParams().mode = AxisMode.centered
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        gc.collect()
+
+    def testAxisLock(self):
+        """Test behavior when locking the axis position. Could not be included
+        in the tomwer/gui because the lock action is only available for the OW
+        """
+        assert self._window.getAxisParams().mode in (
+            AxisMode.centered,
+            AxisMode.global_,
+        )
+        radio_axis = self._window._widget._axisWidget
+        main_widget = self._window._widget
+        self.assertFalse(main_widget._controlWidget._lockBut.isLocked())
+        self.assertTrue(radio_axis._settingsWidget._mainWidget.isEnabled())
+        self.mouseClick(main_widget._controlWidget._lockBut, qt.Qt.LeftButton)
+        self.qapp.processEvents()
+        self.assertTrue(main_widget._controlWidget._lockBut.isLocked())
+        # when the lock button is activated we should automatically switch to
+        # the manual mode
+        self.assertTrue(self._window.getAxisParams().mode is AxisMode.manual)
+        self.assertFalse(radio_axis._settingsWidget._mainWidget.isEnabled())
+
+    def test_serializing(self):
+        pickle.dumps(self._window.recons_params.to_dict())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._window.recons_params.to_dict())
+
+
+class TestWindowAxisComputation(TestCaseQt):
+    @staticmethod
+    def _long_computation(scan):
+        time.sleep(5)
+        return -1
+
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self.tempdir = tempfile.mkdtemp()
+        self._mainWindow = AxisOW()
+        self.recons_params = self._mainWindow.recons_params
+        self._window = self._mainWindow._widget
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=20,
+            energy=12.3,
+        ).scan
+        self._mainWindow.show()
+        self.qWaitForWindowExposed(self._mainWindow)
+        self._mainWindow.setMode("manual")
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._mainWindow.close()
+        self._mainWindow = None
+        self._window = None
+        gc.collect()
+
+    def testComputationSucceed(self):
+        """Test gui if the axis position is correctly computed"""
+        self.recons_params.mode = AxisMode.manual
+        radio_axis = self._window._axisWidget
+        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
+        radio_axis.setXShift(2.345)
+        self._mainWindow.process(self.scan)
+        self.qapp.processEvents()
+        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
+        self.assertEqual(self.recons_params.relative_cor_value, 2.345)
+        position_info_widget = self._window._controlWidget._positionInfo
+        self.assertEqual(position_info_widget._relativePositionQLE.text(), "2.345")
+
+
+global _computation_res
+_computation_res = 0
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestAxisStack(TestCaseQt):
+    """Test axis computation of a stack of scan"""
+
+    @staticmethod
+    def _test_computation(scan):
+        global _computation_res
+        _computation_res += 1
+        return _computation_res
+
+    def setUp(self):
+        # not working due to OW
+        TestCaseQt.setUp(self)
+        self._scan1 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._scan2 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._scan3 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._mainWindow = AxisOW()
+        self.recons_params = self._mainWindow._axis_params
+        self._mainWindow._skip_exec(True)
+
+        global _computation_res
+        _computation_res = 0
+
+        self._mainWindow.patch_calc_method(
+            AxisMode.centered, TestAxisStack._test_computation
+        )
+        self.recons_params.mode = AxisMode.centered
+
+        self._mainWindow.show()
+        self.qWaitForWindowExposed(self._mainWindow)
+
+    def tearDown(self):
+        mock_low_memory(False)
+        mock_lsbram(False)
+        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._mainWindow.close()
+        self._mainWindow = None
+        self._recons_params = None
+        self.qapp.processEvents()
+        for scan in (self._scan1, self._scan2, self._scan3):
+            shutil.rmtree(scan.path)
+        gc.collect()
+
+    def testLowMemory(self):
+        """Make sure the axis computation will be skip if we are in low memory"""
+        mock_low_memory(True)
+        mock_lsbram(True)
+        for scan in (self._scan1, self._scan2, self._scan3):
+            self.qapp.processEvents()
+            self._mainWindow.new_data_in(scan)
+
+        self.assertEqual(self._scan1.axis_params, None)
+        self.assertEqual(self._scan2.axis_params, None)
+        self.assertEqual(self._scan3.axis_params, None)
+
+    def testUnlockStack(self):
+        """Check that all axis position will be computed properly if we set a
+        stack of scan"""
+        self._mainWindow.recons_params.set_relative_value(1.0)
+        for scan in (self._scan1, self._scan2, self._scan3):
+            self._mainWindow.process(scan)
+
+        for i in range(5):
+            self.qapp.processEvents()
+            time.sleep(0.2)
+            self.qapp.processEvents()
+
+        self.assertNotEqual(self._scan1.axis_params, None)
+        self.assertNotEqual(self._scan2.axis_params, None)
+        self.assertNotEqual(self._scan3.axis_params, None)
+
+    def testLockStack(self):
+        """Check that axis position will be simply copy if we are in a lock
+        stack"""
+        self.recons_params.mode = AxisMode.manual
+        position_value = 0.36
+        self.recons_params.set_relative_value(position_value)
+
+        for scan in (self._scan1, self._scan2, self._scan3):
+            self._mainWindow.process(scan)
+
+        for i in range(5):
+            self.qapp.processEvents()
+            time.sleep(0.2)
+            self.qapp.processEvents()
+
+        self.assertEqual(self._scan1.axis_params.relative_cor_value, position_value)
+        self.assertEqual(self._scan2.axis_params.relative_cor_value, position_value)
+        self.assertEqual(self._scan3.axis_params.relative_cor_value, position_value)

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_cast_volumeow.py

@@ -0,0 +1,58 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import os
+import pickle
+import tempfile
+import time
+
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.CastNabuVolumeOW import (
+    CastNabuVolumeOW,
+)
+from tomwer.core.volume.rawvolume import RawVolume
+
+
+class TestCastVolumeOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._window = CastNabuVolumeOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+    def test_serializing(self):
+        pickle.dumps(self._window.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._window.getConfiguration())
+
+    def test_cast_volume(self):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            input_dir = os.path.join(tmp_dir, "input")
+            os.makedirs(input_dir)
+
+            volume = RawVolume(
+                file_path=os.path.join(input_dir, "vol_file.vol"),
+                data=numpy.linspace(0, 10, 100 * 100 * 3, dtype=numpy.float32).reshape(
+                    3, 100, 100
+                ),
+            )
+            volume.save()
+
+            self._window.process_volume(volume)
+            while self._window._processingStack.is_computing():
+                time.sleep(0.1)
+                self.qapp.processEvents()

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_dark_refs_widget.py

@@ -0,0 +1,136 @@
+import gc
+import logging
+import os
+import pickle
+import tempfile
+
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW import (
+    DarkRefAndCopyOW,
+)
+from tomwer.core.utils.scanutils import MockNXtomo
+
+logging.disable(logging.INFO)
+
+
+class TestDarkRefWidget(TestCaseQt):
+    """class testing the DarkRefWidget"""
+
+    def setUp(self):
+        self._tmp_path = tempfile.mkdtemp()
+        scan_folder_with_raw = os.path.join(self._tmp_path, "test_dir_1")
+        scan_folder_without_raw = os.path.join(self._tmp_path, "test_dir_2")
+        for my_dir in (scan_folder_with_raw, scan_folder_without_raw):
+            os.makedirs(my_dir)
+
+        self._scan_with_raw = MockNXtomo(
+            scan_path=scan_folder_with_raw,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            create_final_flat=False,
+            n_proj=10,
+            n_ini_proj=10,
+            dim=12,
+        ).scan
+        self._scan_without_raw = MockNXtomo(
+            scan_path=scan_folder_without_raw,
+            create_ini_dark=False,
+            create_ini_flat=False,
+            create_final_flat=False,
+            n_proj=10,
+            n_ini_proj=10,
+            dim=12,
+        ).scan
+
+        self.widget = DarkRefAndCopyOW()
+        return super().setUp()
+
+    def tearDown(self):
+        # shutil.rmtree(self._tmp_path)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        gc.collect()
+
+    def test_serializing(self):
+        self.widget._updateSettingsVals()
+        pickle.dumps(self.widget._ewoks_default_inputs)
+
+    def test_literal_dumps(self):
+        self.widget._updateSettingsVals()
+        literal_dumps(self.widget._ewoks_default_inputs)
+
+    def test_copy(self):
+        self.widget.setCopyActive(True)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
+
+        self.widget.process(self._scan_with_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_with_raw.load_reduced_darks() not in (None, {})
+        assert self._scan_with_raw.load_reduced_flats() not in (None, {})
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
+
+        self.widget.setCopyActive(False)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_without_raw.load_reduced_darks() in (None, {})
+        assert self._scan_without_raw.load_reduced_flats() in (None, {})
+
+        self.widget.setCopyActive(True)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_without_raw.load_reduced_darks() not in (None, {})
+        assert self._scan_without_raw.load_reduced_flats() not in (None, {})
+
+    def test_set_darks_and_flats(self):
+        """
+        Test settings darks and flats.
+        """
+        self.widget.setCopyActive(True)
+
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
+        self.widget.setReducedFlats(
+            {
+                "0.0r": numpy.linspace(12, 12 + 12 * 12, 12 * 12).reshape(12, 12),
+                "1.0r": numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
+            }
+        )
+        self.widget.setReducedDarks(
+            {
+                "0.0r": numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
+            }
+        )
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+
+        loaded_reduced_darks = self._scan_without_raw.load_reduced_darks()
+        assert tuple(loaded_reduced_darks.keys()) == (0,)
+        numpy.testing.assert_allclose(
+            loaded_reduced_darks[0],
+            numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
+        )
+
+        loaded_reduced_flats = self._scan_without_raw.load_reduced_flats()
+        assert tuple(loaded_reduced_flats.keys()) == (0, 9)
+        numpy.testing.assert_allclose(
+            loaded_reduced_flats[9],
+            numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
+        )

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_delta_beta_selector.py

@@ -0,0 +1,15 @@
+import numpy
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW import (
+    _DeltaBetaSelectorDialog,
+)
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_DeltaBetaSelector(
+    qtapp,  # noqa F811
+):
+    """simple test of the _DeltaBetaSelectorDialog"""
+    dialog = _DeltaBetaSelectorDialog(values=(12, 45))
+    dialog.show()
+    assert numpy.isscalar(dialog.getSelectedValue())