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

tomwer/tests/orangecontrib/tomwer/widgets/stitching/tests/test_zstitching.py

@@ -0,0 +1,313 @@
+import os
+import pickle
+import shutil
+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.stitching.ZStitchingConfigOW import ZStitchingConfigOW
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.core.volume.hdf5volume import HDF5Volume
+
+
+class TestScansZStitchingConfigOW(TestCaseQt):
+    """
+    Test stitching with scans
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._widget = ZStitchingConfigOW()
+        self._tmp_dir = tempfile.mkdtemp()
+        self._scans = []
+        for i_scan in range(3):
+            scan = MockNXtomo(
+                scan_path=os.path.join(self._tmp_dir, f"scan_{i_scan}.nx"),
+                n_ini_proj=20,
+                n_proj=20,
+                n_alignement_proj=2,
+                dim=10,
+            ).scan
+            self._scans.append(scan)
+        self._widget.setConfiguration(
+            {
+                "inputs": {
+                    "input_datasets": [
+                        scan.get_identifier().to_str() for scan in self._scans
+                    ],
+                },
+                "stitching": {
+                    "type": "z-preproc",
+                    "stitching_strategy": "closest",
+                    "alignment_axis_1": "center",
+                    "alignment_axis_2": "center",
+                    "pad_mode": "constant",
+                },
+                "preproc": {
+                    "data_path": "myentry",
+                    "location": "/path/to/mynexusfile.nx",
+                },
+            }
+        )
+        self.qapp.processEvents()
+
+    def test_get_configuration(self):
+        """Make sure the set configuration will be the get configuration"""
+        config = self._widget.getConfiguration()
+        assert config == {
+            "inputs": {
+                "input_datasets": list(
+                    [scan.get_identifier().to_str() for scan in self._scans]
+                ),
+                "slices": "",
+            },
+            "stitching": {
+                "stitching_strategy": "cosinus weights",
+                "type": "z-preproc",
+                "axis_0_pos_px": [0] * len(self._scans),
+                "axis_0_params": "overlap_size=;img_reg_method=nabu-fft;window_size=400",
+                "axis_1_pos_px": [0] * len(self._scans),
+                "axis_1_params": "img_reg_method=None;window_size=400",
+                "flipud": False,
+                "fliplr": False,
+                "avoid_data_duplication": False,
+                "rescale_frames": False,
+                "rescale_params": "rescale_min_percentile=0;rescale_max_percentile=100",
+                "alignment_axis_1": "center",
+                "alignment_axis_2": "center",
+                "pad_mode": "constant",
+            },
+            "preproc": {
+                "data_path": "myentry",
+                "location": "/path/to/mynexusfile.nx",
+            },
+            "output": {
+                "overwrite_results": True,
+            },
+            "normalization_by_sample": {
+                "active": False,
+                "margin": 0,
+                "method": "median",
+                "side": "left",
+                "width": 30,
+            },
+        }
+        # test setting some metadata for stitching
+        for i_scan, scan in enumerate(
+            self._widget.widget._widget._mainWidget.getTomoObjs()
+        ):
+            scan.stitching_metadata.setPxPos(-i_scan, axis=0)
+            scan.stitching_metadata.setPxPos(-i_scan * 10, axis=1)
+        self.qapp.processEvents()
+        config = self._widget.getConfiguration()
+        assert config == {
+            "inputs": {
+                "input_datasets": list(
+                    [scan.get_identifier().to_str() for scan in self._scans]
+                ),
+                "slices": "",
+            },
+            "stitching": {
+                "type": "z-preproc",
+                "stitching_strategy": "cosinus weights",
+                "axis_0_pos_px": [0, -1, -2],
+                "axis_0_params": "overlap_size=;img_reg_method=nabu-fft;window_size=400",
+                "axis_1_pos_px": [0, -10, -20],
+                "axis_1_params": "img_reg_method=None;window_size=400",
+                "flipud": False,
+                "fliplr": False,
+                "avoid_data_duplication": False,
+                "rescale_frames": False,
+                "rescale_params": "rescale_min_percentile=0;rescale_max_percentile=100",
+                "alignment_axis_1": "center",
+                "alignment_axis_2": "center",
+                "pad_mode": "constant",
+            },
+            "preproc": {
+                "data_path": "myentry",
+                "location": "/path/to/mynexusfile.nx",
+            },
+            "output": {
+                "overwrite_results": True,
+            },
+            "normalization_by_sample": {
+                "active": False,
+                "margin": 0,
+                "method": "median",
+                "side": "left",
+                "width": 30,
+            },
+        }
+        config["stitching"]["axis_1_pos_px"] = [0, -1, -2]
+        config["output"]["overwrite_results"] = False
+        self._widget.setConfiguration(config)
+        assert self._widget.getConfiguration() == config
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        shutil.rmtree(self._tmp_dir)
+
+    def test_serializing(self):
+        pickle.dumps(self._widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._widget.getConfiguration())
+
+
+class TestVolumesZStitchingConfigOW(TestCaseQt):
+    """
+    Test ZStitchingConfigOW with volumes
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._widget = ZStitchingConfigOW()
+        self._tmp_dir = tempfile.mkdtemp()
+        self._volumes = []
+        for i_volumes in range(4):
+            volume = HDF5Volume(
+                file_path=os.path.join(self._tmp_dir, f"volume_{i_volumes}.hdf5"),
+                data_path="entry0000",
+                data=numpy.ones(shape=(10, 20, 30)),
+                metadata={},
+            )
+            volume.save()
+            self._volumes.append(volume)
+
+        self.output_volume = HDF5Volume(
+            file_path=os.path.join(self._tmp_dir, "result.hdf5"),
+            data_path="stitched",
+        )
+        self._widget.setConfiguration(
+            {
+                "inputs": {
+                    "input_datasets": [
+                        volume.get_identifier().to_str() for volume in self._volumes
+                    ],
+                },
+                "stitching": {
+                    "type": "z-postproc",
+                    "stitching_strategy": "closest",
+                    "alignment_axis_1": "center",
+                    "alignment_axis_2": "center",
+                    "pad_mode": "constant",
+                },
+                "postproc": {
+                    "output_volume": self.output_volume.get_identifier().to_str(),
+                },
+            }
+        )
+        self.qapp.processEvents()
+
+    def test_get_configuration(self):
+        """Make sure the set configuration will be the get configuration"""
+        config = self._widget.getConfiguration()
+        assert config == {
+            "inputs": {
+                "input_datasets": list(
+                    [scan.get_identifier().to_str() for scan in self._volumes]
+                ),
+                "slices": "",
+            },
+            "stitching": {
+                "stitching_strategy": "cosinus weights",
+                "type": "z-postproc",
+                "axis_0_pos_px": [0] * len(self._volumes),
+                "axis_0_params": "overlap_size=;img_reg_method=nabu-fft;window_size=400",
+                "axis_1_pos_px": [0] * len(self._volumes),
+                "axis_1_params": "img_reg_method=None;window_size=400",
+                "flipud": False,
+                "fliplr": False,
+                "avoid_data_duplication": False,
+                "rescale_frames": False,
+                "rescale_params": "rescale_min_percentile=0;rescale_max_percentile=100",
+                "alignment_axis_1": "center",
+                "alignment_axis_2": "center",
+                "pad_mode": "constant",
+            },
+            "postproc": {
+                "output_volume": self.output_volume.get_identifier().to_str(),
+            },
+            "output": {
+                "overwrite_results": True,
+            },
+            "normalization_by_sample": {
+                "active": False,
+                "margin": 0,
+                "method": "median",
+                "side": "left",
+                "width": 30,
+            },
+        }
+        # test setting some metadata for stitching
+        for i_scan, scan in enumerate(
+            self._widget.widget._widget._mainWidget.getTomoObjs()
+        ):
+            scan.stitching_metadata.setPxPos(-i_scan, axis=0)
+            scan.stitching_metadata.setPxPos(-i_scan * 10, axis=1)
+        self.qapp.processEvents()
+        config = self._widget.getConfiguration()
+        assert config == {
+            "inputs": {
+                "input_datasets": list(
+                    [scan.get_identifier().to_str() for scan in self._volumes]
+                ),
+                "slices": "",
+            },
+            "stitching": {
+                "stitching_strategy": "cosinus weights",
+                "type": "z-postproc",
+                "axis_0_pos_px": [0, -1, -2, -3],
+                "axis_0_params": "overlap_size=;img_reg_method=nabu-fft;window_size=400",
+                "axis_1_pos_px": [0, -10, -20, -30],
+                "axis_1_params": "img_reg_method=None;window_size=400",
+                "flipud": False,
+                "fliplr": False,
+                "avoid_data_duplication": False,
+                "rescale_frames": False,
+                "rescale_params": "rescale_min_percentile=0;rescale_max_percentile=100",
+                "alignment_axis_1": "center",
+                "alignment_axis_2": "center",
+                "pad_mode": "constant",
+            },
+            "postproc": {
+                "output_volume": self.output_volume.get_identifier().to_str(),
+            },
+            "output": {
+                "overwrite_results": True,
+            },
+            "normalization_by_sample": {
+                "active": False,
+                "margin": 0,
+                "method": "median",
+                "side": "left",
+                "width": 30,
+            },
+        }
+        # update some field to enhance test
+        config["stitching"]["axis_1_pos_px"] = [0, -100, -200, -300]
+        config["stitching"]["rescale_frames"] = True
+        config["stitching"][
+            "rescale_params"
+        ] = "rescale_min_percentile=10;rescale_max_percentile=35"
+        config["output"]["overwrite_results"] = False
+        self._widget.setConfiguration(config)
+        assert self._widget.getConfiguration() == config
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        shutil.rmtree(self._tmp_dir)
+
+    def test_serializing(self):
+        pickle.dumps(self._widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._widget.getConfiguration())

tomwer/tests/orangecontrib/tomwer/widgets/tests/test_conditions.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import SignalListener, TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.FilterOW import NameFilterOW
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+
+logging.disable(logging.INFO)
+
+
+class NameFilterOWCI(NameFilterOW):
+    sigScanReady = qt.Signal(str)
+    """signal emitted when a scan is ready; Parameter is folder path of the
+    scan"""
+
+    def _signalScanReady(self, scan):
+        self.sigScanReady.emit(scan.path)
+
+
+class TestFilterWidget(TestCaseQt):
+    """class testing the DarkRefWidget"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self.widget = NameFilterOWCI(parent=None)
+
+        self.tmpdir = tempfile.mkdtemp()
+        # create hdf5 dataset
+        self._hdf5with_mytotodir = MockNXtomo(
+            scan_path=os.path.join(self.tmpdir, "mytotodir120"), n_proj=10
+        ).scan
+        self._hdf5without_mytotodir = MockNXtomo(
+            scan_path=os.path.join(self.tmpdir, "totodir120"), n_proj=10
+        ).scan
+        # create edf dataset
+        mockEDF1 = MockEDF(
+            scan_path=os.path.join(self.tmpdir, "mytotodir20"), n_radio=10
+        )
+        self.edfwith_mytotodir = EDFTomoScan(scan=mockEDF1.scan_path)
+
+        mockEDF2 = MockEDF(scan_path=os.path.join(self.tmpdir, "dir120"), n_radio=10)
+        self.edfwithout_mytotodir = EDFTomoScan(scan=mockEDF2.scan_path)
+
+        # add a signal listener
+        self.signalListener = SignalListener()
+        self.widget.sigScanReady.connect(self.signalListener)
+
+        # define the unix file pattern
+        self.widget.setPattern("*mytotodir*")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def testEDF(self):
+        """Make sure filtering works with EDF"""
+        self.assertEqual(self.signalListener.callCount(), 0)
+        self.widget.applyfilter(self.edfwith_mytotodir)
+        self.qapp.processEvents()
+        self.assertEqual(self.signalListener.callCount(), 1)
+        self.widget.applyfilter(self.edfwithout_mytotodir)
+        self.qapp.processEvents()
+        self.assertEqual(self.signalListener.callCount(), 1)
+
+    def testHDF5(self):
+        """Make sure filtering works with HDF5"""
+        self.assertEqual(self.signalListener.callCount(), 0)
+        self.widget.applyfilter(self._hdf5without_mytotodir)
+        self.qapp.processEvents()
+        self.assertEqual(self.signalListener.callCount(), 0)
+        self.widget.applyfilter(self._hdf5with_mytotodir)
+        self.qapp.processEvents()
+        self.assertEqual(self.signalListener.callCount(), 1)

tomwer/tests/orangecontrib/tomwer/widgets/tests/test_darkref.py

@@ -0,0 +1,225 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import shutil
+import tempfile
+import time
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW import (
+    DarkRefAndCopyOW,
+)
+from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
+from tomwer.core.process.reconstruction.darkref.params import ReduceMethod as DkrfMethod
+from tomwer.core.process.reconstruction.darkref.settings import (
+    DARKHST_PREFIX,
+    REFHST_PREFIX,
+)
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+from tomwer.synctools.darkref import QDKRFRP
+
+logging.disable(logging.INFO)
+
+
+class TestEDFDarkRefWidget(TestCaseQt):
+    """class testing the DarkRefWidget"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self._recons_params = QDKRFRP()
+        self.widget = DarkRefAndCopyOW(parent=None, reconsparams=self._recons_params)
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        gc.collect()
+
+    def testSyncRead(self):
+        """Make sure any modification on the self._reconsParams is
+        applied on the GUI"""
+        rp = self._recons_params
+        self.assertTrue(rp["REFSRMV"] is False)
+        self.assertFalse(
+            self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        )
+        rp["REFSRMV"] = True
+        self.assertTrue(
+            self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        )
+
+        pattern = self.widget.widget.mainWidget.tabExpert._refLE.text()
+        newText = "popo.*"
+        assert pattern != newText
+        rp["RFFILE"] = newText
+        self.assertTrue(
+            self.widget.widget.mainWidget.tabExpert._refLE.text() == newText
+        )
+
+    def testSyncWrite(self):
+        """Test that if we edit through the :class:`DarkRefWidget` then the
+        modification are fall back into the self._reconsParams"""
+        rp = self._recons_params
+
+        # test patterns
+        pattern = self.widget.widget.mainWidget.tabExpert._refLE.text()
+        newText = "popo.*"
+        assert pattern != newText
+        self.widget.widget.mainWidget.tabExpert._refLE.setText(newText)
+        self.widget.widget.mainWidget.tabExpert._refLE.editingFinished.emit()
+        qt.QApplication.instance().processEvents()
+        self.assertTrue(rp["RFFILE"] == newText)
+        self.widget.widget.mainWidget.tabExpert._darkLE.setText(newText)
+        self.widget.widget.mainWidget.tabExpert._darkLE.editingFinished.emit()
+        qt.QApplication.instance().processEvents()
+        self.assertTrue(rp["DKFILE"] == newText)
+
+        # test calc mode
+        self.widget.widget.mainWidget.tabGeneral._darkWCB.setMode(DkrfMethod.NONE)
+        self.widget.widget.mainWidget.tabGeneral._refWCB.setMode(DkrfMethod.MEDIAN)
+        self.assertTrue(rp["DARKCAL"] == DkrfMethod.NONE)
+        self.assertTrue(rp["REFSCAL"] == DkrfMethod.MEDIAN)
+
+        # test options
+        cuRm = self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        self.widget.widget.mainWidget.tabGeneral._rmOptionCB.setChecked(not cuRm)
+        self.assertTrue(rp["REFSRMV"] == (not cuRm))
+        self.assertTrue(rp["DARKRMV"] == (not cuRm))
+
+        cuSkip = self.widget.widget.mainWidget.tabGeneral._skipOptionCB.isChecked()
+        self.widget.widget.mainWidget.tabGeneral._skipOptionCB.setChecked(not cuSkip)
+        # warning : here value of skip and overwrite are of course inverse
+        self.assertTrue(rp["DARKOVE"] == cuSkip)
+        self.assertTrue(rp["REFSOVE"] == cuSkip)
+
+
+@pytest.mark.skip("Fail on CI")
+class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
+    """Test the DarkRefCopy orange widget behaviour"""
+
+    def setUp(self) -> None:
+        TestCaseQt.setUp(self)
+        self._folder = tempfile.mkdtemp()
+
+        # define scans to be treated
+        hdf5_mock_with_refs = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_with_refs"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=20,
+            create_ini_flat=True,
+            create_ini_dark=True,
+            create_final_flat=False,
+        )
+        self.hdf5_acquisition_with_refs = hdf5_mock_with_refs.scan
+
+        hdf5_mock_without_refs = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_without_refs"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=20,
+            create_ini_flat=False,
+            create_ini_dark=False,
+        )
+        self.hdf5_acquisition_without_refs = hdf5_mock_without_refs.scan
+
+        hdf5_mock_without_refs_incoherent_dim = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_without_refs_different_dim"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=21,
+            create_ini_flat=False,
+            create_ini_dark=False,
+        )
+        self.hdf5_acquisition_without_refs_incoherent_dim = (
+            hdf5_mock_without_refs_incoherent_dim.scan
+        )
+
+        edf_mock_without_ref = MockEDF(
+            scan_path=os.path.join(self._folder, "edf_without_refs"), dim=20, n_radio=20
+        )
+        self.edf_acquisition_without_ref = EDFTomoScan(
+            scan=edf_mock_without_ref.scan_path
+        )
+
+        # processes set up
+        self._recons_params = QDKRFRP()
+        self.widget = DarkRefAndCopyOW(parent=None, reconsparams=self._recons_params)
+        self.widget.setForceSync(True)
+        self.widget.show()
+
+    def tearDown(self) -> None:
+        time.sleep(0.5)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self._folder)
+        gc.collect()
+
+    def testCopyInactive(self):
+        self.widget.setCopyActive(False)
+
+        self.widget.process(self.hdf5_acquisition_with_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_with_refs.process_file))
+
+        # make sure no dark or flats exists for the hdf5 without refs
+        for scan in (
+            self.hdf5_acquisition_without_refs_incoherent_dim,
+            self.hdf5_acquisition_without_refs,
+        ):
+            self.widget.process(scan)
+            self.assertFalse(os.path.exists(scan.process_file))
+
+        # make sure no dark or flats exists for the edf one
+        self.widget.process(self.edf_acquisition_without_ref)
+
+    def testCopyActive(self):
+        self.widget.setCopyActive(True)
+        self.widget.setModeAuto(True)
+
+        self.widget.process(self.hdf5_acquisition_with_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_with_refs.process_file))
+        # 1. make sure dark has been processed for the one with ref
+        self.assertTrue(self.widget.hasDarkStored())
+        self.assertTrue(self.widget.hasFlatStored())
+
+        # 2. make sure copy has been processed for the the 'compatible hdf5'
+        self.widget.process(self.hdf5_acquisition_without_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_without_refs.process_file))
+
+        # 3. make sure copy has been processed for the the 'compatible edf'
+        self.widget.process(self.edf_acquisition_without_ref)
+        self.assertEqual(
+            len(
+                DarkRefsTask.getRefHSTFiles(
+                    self.edf_acquisition_without_ref.path, prefix=REFHST_PREFIX
+                )
+            ),
+            2,
+        )
+        self.assertEqual(
+            len(
+                DarkRefsTask.getDarkHSTFiles(
+                    self.edf_acquisition_without_ref.path, prefix=DARKHST_PREFIX
+                )
+            ),
+            1,
+        )
+
+        # 4. make sure process but no copy made if incompatible size
+        self.widget.process(self.hdf5_acquisition_without_refs_incoherent_dim)
+        self.assertFalse(
+            os.path.exists(
+                self.hdf5_acquisition_without_refs_incoherent_dim.process_file
+            )
+        )