tomwer 1.3.6__py3-none-any.whl → 1.3.7__py3-none-any.whl

orangecontrib/tomwer/widgets/reconstruction/test/test_nabu_helical_prepare_weights_double.py

@@ -0,0 +1,20 @@
+import pickle
+
+from orangecanvas.scheme.readwrite import literal_dumps
+
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW import (
+    NabuHelicalPrepareWeightsDoubleOW,
+)
+
+
+def test_NabuHelicalPrepareWeightsDoubleOW(
+    qtapp,  # noqa F811
+):
+    """simple test of the _DeltaBetaSelectorDialog"""
+    widget = NabuHelicalPrepareWeightsDoubleOW()
+    widget._loadSettings()
+    # test settings serialization
+    pickle.dumps(widget._ewoks_default_inputs)
+    literal_dumps(widget._ewoks_default_inputs)

orangecontrib/tomwer/widgets/reconstruction/test/test_nabu_volume.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2017-2021 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 gc
+import os
+import pickle
+import shutil
+import tempfile
+from time import sleep
+
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW import NabuVolumeOW
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+class TestNabuVolumeOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        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
+        self.widget = NabuVolumeOW()
+        self.widget._processingStack.setDryRun(True)
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self.tmp_dir)
+        self.qapp.processEvents()
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())
+
+    def test_scan_as_None(self):
+        "test if scan is None"
+        self.widget.process(None)
+
+    def test_scan_un_preprocessed(self):
+        "test when scan is unconfigured (No nabu_recons_params defined)"
+        assert self.scan.nabu_recons_params is None
+        self.widget.process(self.scan)
+
+    def test_scan_ready_to_be_processed(self):
+        "test if scan has valid reconstruction parameters to be runned"
+        self.scan.nabu_recons_params = get_default_nabu_config(
+            nabu_fullfield_default_config
+        )
+        self.widget.process(self.scan)
+        timeout = 3
+        loop_sleep_time = 0.05
+        while not self.widget._processingStack.can_process_next():
+            self.qapp.processEvents()
+            timeout -= loop_sleep_time
+            if timeout <= 0.0:
+                raise TimeoutError("volume not process within expected time")
+            else:
+                sleep(loop_sleep_time)

orangecontrib/tomwer/widgets/reconstruction/test/test_nabu_widget.py

@@ -0,0 +1,107 @@
+import gc
+import logging
+import os
+import pickle
+import shutil
+import tempfile
+import time
+from glob import glob
+
+import h5py
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import SignalListener, TestCaseQt
+from nxtomo.nxobject.nxdetector import FOV
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuOW import NabuOW
+from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.settings import mock_lsbram
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.synctools.darkref import QDKRFRP
+from tomwer.tests.datasets import TomwerCIDatasets
+
+logging.disable(logging.INFO)
+
+
+class TestNabuWidget(TestCaseQt):
+    """class testing the NabuOW"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self._recons_params = QDKRFRP()
+        self.widget = NabuOW(parent=None)
+        self.scan_dir = tempfile.mkdtemp()
+        # create dataset
+        self.master_file = os.path.join(self.scan_dir, "frm_edftomomill_twoentries.nx")
+        shutil.copyfile(
+            TomwerCIDatasets.get_dataset(
+                "h5_datasets/frm_edftomomill_twoentries.nx",
+            ),
+            self.master_file,
+        )
+        self.scan = NXtomoScan(scan=self.master_file, entry="entry0000")
+        # create listener for the nabu widget
+        self.signal_listener = SignalListener()
+
+        # connect signal / slot
+        self.widget.sigScanReady.connect(self.signal_listener)
+
+        # set up
+        mock_low_memory(True)
+        mock_lsbram(True)
+        self.widget.setDryRun(dry_run=True)
+
+    def tearDown(self):
+        mock_low_memory(False)
+        mock_lsbram(False)
+        self.widget.sigScanReady.disconnect(self.signal_listener)
+        self._recons_params = None
+        self.scan = None
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())
+
+    def testLowMemory(self):
+        """Make sure no reconstruction is started if we are low in memory in
+        lbsram"""
+        self.assertEqual(len(glob(os.path.join(self.scan_dir, "*.cfg"))), 0)
+        self.widget.process(self.scan)
+        self.wait_processing()
+        self.assertEqual(len(glob(os.path.join(self.scan_dir, "*.cfg"))), 0)
+
+    def wait_processing(self):
+        timeout = 10
+        while timeout >= 0 and self.signal_listener.callCount() == 0:
+            timeout -= 0.1
+            time.sleep(0.1)
+        if timeout <= 0.0:
+            raise TimeoutError("nabu widget never end processing")
+
+    def patch_fov(self, value: str):
+        with h5py.File(self.scan.master_file, mode="a") as h5s:
+            for entry in ("entry0000", "entry0001"):
+                entry_node = h5s[entry]
+                if "instrument/detector/field_of_view" in entry_node:
+                    del entry_node["instrument/detector/field_of_view"]
+                entry_node["instrument/detector/field_of_view"] = value
+
+    def testSetConfiguration(self):
+        """Make sure the configuration evolve from scan information"""
+        self.assertEqual(self.widget.getMode(), _NabuMode.FULL_FIELD)
+        self.patch_fov(value=FOV.HALF.value)
+        self.widget.process(self.scan)
+        self.wait_processing()
+        self.assertEqual(self.widget.getMode(), _NabuMode.HALF_ACQ)
+        self.patch_fov(value=FOV.FULL.value)
+        self.scan.clear_caches()
+        self.widget.process(self.scan)
+        self.wait_processing()
+        self.assertEqual(self.widget.getMode(), _NabuMode.FULL_FIELD)

orangecontrib/tomwer/widgets/reconstruction/test/test_sa_delta_beta.py

@@ -0,0 +1,194 @@
+import gc
+import logging
+import os
+import pickle
+import shutil
+import tempfile
+import uuid
+
+import h5py
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from processview.core.manager import DatasetState, ProcessManager
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from silx.io.url import DataUrl
+
+from orangecontrib.tomwer.widgets.reconstruction.SADeltaBetaOW import (
+    SADeltaBetaOW as _SADeltaBetaOW,
+)
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.core.process.reconstruction.scores import ComputedScore
+from tomwer.core.utils.scanutils import MockNXtomo
+
+logger = logging.getLogger(__name__)
+
+
+class SADeltaBetaOW(_SADeltaBetaOW):
+    def __init__(self, parent=None):
+        self._scans_finished = []
+        super().__init__(parent)
+
+    def processing_finished(self, scan):
+        # TODO: add message processing finished
+        self._scans_finished.append(scan)
+
+    @property
+    def scans_finished(self):
+        return self._scans_finished
+
+    def close(self):
+        self._scans_finished = {}
+        super().close()
+
+
+class TestProcessing(TestCaseQt):
+    DIM = 100
+
+    def setUp(self):
+        super().setUp()
+        self._source_dir = tempfile.mkdtemp()
+
+        def create_scan(folder_name):
+            _dir = os.path.join(self._source_dir, folder_name)
+            return MockNXtomo(
+                scan_path=_dir,
+                n_ini_proj=20,
+                n_proj=20,
+                n_alignement_proj=2,
+                create_final_flat=False,
+                create_ini_dark=True,
+                create_ini_flat=True,
+                n_refs=1,
+                dim=self.DIM,
+            ).scan
+
+        # create scans
+        self.scan_1 = create_scan("scan_1")
+        self.scan_2 = create_scan("scan_2")
+        self.scan_3 = create_scan("scan_3")
+        self._process_manager = ProcessManager()
+
+        self.widget = SADeltaBetaOW()
+        self.widget.show()
+
+        def patch_score(cor):
+            data = numpy.random.random(TestProcessing.DIM * TestProcessing.DIM)
+            data = data.reshape(TestProcessing.DIM, TestProcessing.DIM)
+            slice_file_path = os.path.join(
+                self._source_dir, str(uuid.uuid1()) + ".hdf5"
+            )
+            data_url = DataUrl(
+                file_path=slice_file_path, data_path="data", scheme="silx"
+            )
+            with h5py.File(slice_file_path, mode="a") as h5f:
+                h5f["data"] = data
+            return data_url, ComputedScore(
+                tv=numpy.random.random(),
+                std=numpy.random.random(),
+            )
+
+        self.widget._widget._processing_stack.patch_processing(patch_score)
+
+    def tearDown(self):
+        mock_low_memory(False)
+        settings.mock_lsbram(False)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        shutil.rmtree(self._source_dir)
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())
+
+    def testAutoFocusUnlock(self):
+        self.widget.lockAutofocus(False)
+
+        def manual_processing():
+            self.widget.compute()
+            self.qapp.processEvents()
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        self.widget.process(self.scan_1)
+        manual_processing()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+
+        self.widget.process(self.scan_2)
+        manual_processing()
+        self.assertEqual(len(self.widget.scans_finished), 0)
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SKIPPED,
+        )
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_2.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+        self.widget.process(self.scan_3)
+        manual_processing()
+        self.widget.validateCurrentScan()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_3.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SUCCEED,
+        )
+        # insure a cor has been registered
+        self.assertNotEqual(
+            self.scan_3.sa_delta_beta_params.selected_delta_beta_value, None
+        )
+
+    def testTestLbsram(self):
+        mock_low_memory(True)
+        settings.mock_lsbram(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            with self.subTest(scan=str(scan)):
+                self.assertEqual(
+                    self._process_manager.get_dataset_state(
+                        dataset_id=scan.get_identifier(),
+                        process=self.widget,
+                    ),
+                    DatasetState.SKIPPED,
+                )
+
+    def testAutoFocusLock(self):
+        self.widget.lockAutofocus(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            with self.subTest(scan=str(scan)):
+                self.assertEqual(
+                    self._process_manager.get_dataset_state(
+                        dataset_id=scan.get_identifier(),
+                        process=self.widget,
+                    ),
+                    DatasetState.SUCCEED,
+                )

orangecontrib/tomwer/widgets/reconstruction/test/test_saaxis.py

@@ -0,0 +1,220 @@
+# 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__ = "12/04/2021"
+
+import gc
+import logging
+import os
+import pickle
+import shutil
+import tempfile
+import time
+import uuid
+
+import h5py
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from processview.core.manager import DatasetState, ProcessManager
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from silx.io.url import DataUrl
+
+from orangecontrib.tomwer.widgets.reconstruction.SAAxisOW import SAAxisOW as _SAAxisOW
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.core.process.reconstruction.scores import ComputedScore
+from tomwer.core.utils.scanutils import MockNXtomo
+
+logger = logging.getLogger(__name__)
+
+
+class SAAxisOW(_SAAxisOW):
+    def __init__(self, parent=None):
+        self._scans_finished = []
+        super().__init__(parent)
+
+    def processing_finished(self, scan):
+        # TODO: add message processing finished
+        self._scans_finished.append(scan)
+
+    @property
+    def scans_finished(self):
+        return self._scans_finished
+
+    def close(self):
+        self._scans_finished = {}
+        super().close()
+
+
+class TestProcessing(TestCaseQt):
+    DIM = 100
+
+    def setUp(self):
+        super().setUp()
+        self._source_dir = tempfile.mkdtemp()
+
+        def create_scan(folder_name):
+            _dir = os.path.join(self._source_dir, folder_name)
+            return MockNXtomo(
+                scan_path=_dir,
+                n_ini_proj=20,
+                n_proj=20,
+                n_alignement_proj=2,
+                create_final_flat=False,
+                create_ini_dark=True,
+                create_ini_flat=True,
+                n_refs=1,
+                dim=self.DIM,
+            ).scan
+
+        # create scans
+        self.scan_1 = create_scan("scan_1")
+        self.scan_2 = create_scan("scan_2")
+        self.scan_3 = create_scan("scan_3")
+        self._process_manager = ProcessManager()
+
+        self.widget = SAAxisOW()
+        self.widget.show()
+
+        def patch_score(*args, **kwargs):
+            data = numpy.random.random(TestProcessing.DIM * TestProcessing.DIM)
+            data = data.reshape(TestProcessing.DIM, TestProcessing.DIM)
+            slice_file_path = os.path.join(
+                self._source_dir, str(uuid.uuid1()) + ".hdf5"
+            )
+            data_url = DataUrl(
+                file_path=slice_file_path, data_path="data", scheme="silx"
+            )
+            with h5py.File(slice_file_path, mode="a") as h5f:
+                h5f["data"] = data
+            return data_url, ComputedScore(
+                tv=numpy.random.random(),
+                std=numpy.random.random(),
+            )
+
+        self.widget._widget._processing_stack.patch_processing(patch_score)
+
+    def tearDown(self):
+        mock_low_memory(False)
+        settings.mock_lsbram(False)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        shutil.rmtree(self._source_dir)
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())
+
+    def testAutoFocusUnlock(self):
+        self.widget.lockAutofocus(False)
+
+        def manual_processing():
+            self.widget.load_sinogram()
+            self.widget.compute()
+            self.qapp.processEvents()
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        self.widget.process(self.scan_1)
+        manual_processing()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+
+        self.widget.process(self.scan_2)
+        manual_processing()
+        self.assertEqual(len(self.widget.scans_finished), 0)
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SKIPPED,
+        )
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_2.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+        self.widget.process(self.scan_3)
+        manual_processing()
+        self.widget.validateCurrentScan()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_3.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SUCCEED,
+        )
+        # insure a cor has been registered
+        self.assertNotEqual(self.scan_3.axis_params.relative_cor_value, None)
+
+    def testTestLbsram(self):
+        mock_low_memory(True)
+        settings.mock_lsbram(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            with self.subTest(scan=str(scan)):
+                self.assertEqual(
+                    self._process_manager.get_dataset_state(
+                        dataset_id=scan.get_identifier(),
+                        process=self.widget,
+                    ),
+                    DatasetState.SKIPPED,
+                )
+
+    def testAutoFocusLock(self):
+        self.widget.lockAutofocus(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(10000)
+            self.qapp.processEvents()
+            time.sleep(0.1)
+            self.qapp.processEvents()
+            self.assertEqual(
+                self._process_manager.get_dataset_state(
+                    dataset_id=scan.get_identifier(),
+                    process=self.widget,
+                ),
+                DatasetState.SUCCEED,
+            )