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

tomwer/core/process/reconstruction/utils/cor.py

@@ -1,16 +1,12 @@
 def relative_pos_to_absolute(relative_pos: float, det_width: int):
     """
-    Convert relative center of rotation to absolute.
+    convert relative center of rotation to absolute
     """
-    # Compute the midpoint differently for even and odd widths
-    midpoint = det_width / 2.0
-    return relative_pos + midpoint
+    return relative_pos + (det_width - 1) / 2.0
 
 
 def absolute_pos_to_relative(absolute_pos: float, det_width: int):
     """
-    Convert absolute center of rotation to relative.
+    convert absolute center of rotation to relative
     """
-    # Compute the midpoint differently for even and odd widths
-    midpoint = det_width / 2.0
-    return absolute_pos - midpoint
+    return absolute_pos - (det_width - 1) / 2.0

tomwer/core/process/tests/test_axis.py

@@ -0,0 +1,231 @@
+# coding: utf-8
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import unittest
+
+import h5py
+from tomoscan.io import get_swmr_mode
+import numpy
+from silx.io.utils import h5py_read_dataset
+
+from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.process.reconstruction.axis.params import AxisRP
+from tomwer.core.process.task import Task
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+
+from ..reconstruction.axis.axis import AxisTask
+
+
+class TestAxisIO(unittest.TestCase):
+    """Test inputs and outputs types of the handler functions"""
+
+    @staticmethod
+    def _random_calc(scan):
+        return numpy.random.random()
+
+    def setUp(self):
+        self.scan_folder = tempfile.mkdtemp()
+
+        self.scan = MockEDF.mockScan(
+            scanID=self.scan_folder, nRadio=10, nRecons=1, nPagRecons=4, dim=10
+        )
+        self.recons_params = AxisRP()
+
+        # set the axis url to be used
+        projections = self.scan.projections
+        urls = list(projections.values())
+        self.scan.axis_params = AxisRP()
+        self.scan.axis_params.axis_url_1 = urls[0]
+        self.scan.axis_params.axis_url_2 = urls[1]
+
+    def tearDown(self):
+        shutil.rmtree(self.scan_folder)
+
+    def testInputOutput(self):
+        """Test that io using TomoBase instance work"""
+        for input_type in (dict, TomwerScanBase):
+            for serialize_output_data in (True, False):
+                with self.subTest(
+                    serialize_output_data=serialize_output_data,
+                    input_type=input_type,
+                ):
+                    input_obj = self.scan
+                    if input_obj is dict:
+                        input_obj = input_obj.to_dict()
+                    axis_process = AxisTask(
+                        inputs={
+                            "axis_params": self.recons_params,
+                            "data": input_obj,
+                            "serialize_output_data": serialize_output_data,
+                        }
+                    )
+
+                    # patch the axis process
+                    axis_process._CALCULATIONS_METHODS[AxisMode.centered] = (
+                        TestAxisIO._random_calc
+                    )
+
+                    axis_process.run()
+                    out = axis_process.outputs.data
+                    if serialize_output_data:
+                        self.assertTrue(isinstance(out, dict))
+                    else:
+                        self.assertTrue(isinstance(out, TomwerScanBase))
+
+
+class TestAxis(unittest.TestCase):
+    """Test the axis process"""
+
+    def setUp(self):
+        self.recons_params = AxisRP()
+        self.recons_params.mode = "centered"
+
+    def test_process_saved_edf(self):
+        """Test that if process is called, the tomwer.h5 file is created
+        and is correctly saving information regarding the center of position
+        """
+        self.tempdir = tempfile.mkdtemp()
+        mock = MockEDF(scan_path=self.tempdir, n_radio=10, n_ini_radio=10)
+        scan = EDFTomoScan(mock.scan_path)
+        self.recons_params.mode = "centered"
+        axis_process = AxisTask(
+            inputs={
+                "data": scan,
+                "axis_params": self.recons_params,
+                "serialize_output_data": False,
+            }
+        )
+
+        axis_process.run()
+        self.assertTrue(os.path.exists(scan.process_file))
+
+        with h5py.File(scan.process_file, "r", swmr=get_swmr_mode()) as h5f:
+            self.assertTrue("entry" in h5f)
+            self.assertTrue("tomwer_process_0" in h5f["entry"])
+            group_axis = h5f["entry"]["tomwer_process_0"]
+            self.assertTrue("configuration" in group_axis)
+            self.assertTrue("program" in group_axis)
+            self.assertTrue("results" in group_axis)
+            self.assertTrue("center_of_rotation" in group_axis["results"])
+            axis_value = h5py_read_dataset(group_axis["results"]["center_of_rotation"])
+
+        processes = Task.get_processes_frm_type(
+            process_file=scan.process_file, process_type=AxisTask, entry="entry"
+        )
+        self.assertEqual(len(processes), 1)
+        self.assertEqual(processes[0].results["center_of_rotation"], axis_value)
+
+    def test_process_saved_hdf5(self):
+        """Test that if process is called, the tomwer.h5 file is created
+        and is correctly saving information regarding the center of position
+        """
+        self.tempdir = tempfile.mkdtemp()
+        dim = 10
+        mock = MockNXtomo(
+            scan_path=self.tempdir, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
+        )
+        mock.add_alignment_radio(index=10, angle=90)
+        mock.add_alignment_radio(index=10, angle=0)
+        scan = mock.scan
+        self.recons_params.mode = "centered"
+
+        # check data url take
+        axis_process = AxisTask(
+            inputs={
+                "data": scan,
+                "axis_params": self.recons_params,
+                "serialize_output_data": False,
+            }
+        )
+        axis_process.run()
+        # make sure center of position has been computed
+        self.assertTrue(os.path.exists(scan.process_file))
+
+        with h5py.File(scan.process_file, "r", swmr=get_swmr_mode()) as h5f:
+            self.assertTrue("entry" in h5f)
+            self.assertTrue("tomwer_process_0" in h5f["entry"])
+            group_axis = h5f["entry"]["tomwer_process_0"]
+            self.assertTrue("configuration" in group_axis)
+            self.assertTrue("program" in group_axis)
+            self.assertTrue("results" in group_axis)
+            self.assertTrue("center_of_rotation" in group_axis["results"])
+            axis_value = h5py_read_dataset(group_axis["results"]["center_of_rotation"])
+        self.assertTrue(-dim / 2 <= axis_value <= dim / 2)
+        processes = Task.get_processes_frm_type(
+            process_file=scan.process_file, process_type=AxisTask
+        )
+        self.assertEqual(len(processes), 1)
+        self.assertEqual(processes[0].results["center_of_rotation"], axis_value)
+
+
+class TestAxisRP(unittest.TestCase):
+    """Test the class used for AxisProcess configuration"""
+
+    def setUp(self):
+        self.axis_rp = AxisRP()
+        self.tmp_folder = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp_folder)
+
+
+class TestSinogramAlgorithm(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp_folder = tempfile.mkdtemp()
+        dim = 512
+        self.scan = MockNXtomo(
+            scan_path=self.tmp_folder,
+            n_proj=10,
+            n_ini_proj=10,
+            create_ini_dark=True,
+            create_final_flat=True,
+            scan_range=360,
+            dim=dim,
+        ).scan
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp_folder)
+
+    def test_growing_window_sinogram(self):
+        recons_params = AxisRP()
+        axis_process = AxisTask(
+            inputs={"axis_params": recons_params, "data": self.scan}
+        )
+        recons_params.mode = AxisMode.growing_window_sinogram
+        recons_params.use_sinogram = True
+        recons_params.sinogram_subsampling = 1
+        axis_process.run()
+
+    def test_sliding_window(self):
+        recons_params = AxisRP()
+        axis_process = AxisTask(
+            inputs={
+                "axis_params": recons_params,
+                "data": self.scan,
+                "serialize_output_data": False,
+            }
+        )
+        recons_params.mode = AxisMode.sliding_window_sinogram
+        recons_params.side = "left"
+        recons_params.sinogram_subsampling = 1
+        recons_params.use_sinogram = True
+        axis_process.run()
+
+    def test_sino_coarse_to_fine(self):
+        recons_params = AxisRP()
+        axis_process = AxisTask(
+            inputs={
+                "axis_params": recons_params,
+                "data": self.scan,
+                "serialize_output_data": False,
+            }
+        )
+        recons_params.mode = AxisMode.sino_coarse_to_fine
+        recons_params.sinogram_subsampling = 1
+        recons_params.sinogram_line = 2
+        axis_process.run()

tomwer/core/process/tests/test_nabu.py

@@ -402,7 +402,9 @@ class TestNabuAndAxis(unittest.TestCase):
         nabu_rotation_axis_value = self.get_saved_rotation_axis(nabu_conf_files[0])
         self.assertEqual(
             nabu_rotation_axis_value,
-            str(self.scan._axis_params.relative_cor_value + (self.scan.dim_1 / 2.0)),
+            str(
+                self.scan._axis_params.relative_cor_value + (self.scan.dim_1 - 1) / 2.0
+            ),
         )
 
 

tomwer/core/scan/nxtomoscan.py

@@ -18,7 +18,6 @@ from tomoscan.esrf.identifier.hdf5Identifier import (
 )
 from tomoscan.esrf.identifier.url_utils import UrlSettings, split_path, split_query
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan as _tsNXtomoScan
-from tomoscan.utils.io import filter_esrf_mounting_points
 from nxtomo.nxobject.nxdetector import ImageKey
 from nxtomo.paths.nxtomo import get_paths as _get_nexus_paths
 
@@ -488,7 +487,6 @@ class NXtomoScan(_tsNXtomoScan, TomwerScanBase):
                 bliss_raw_data_files[0] if len(bliss_raw_data_files) > 0 else None
             )
             if bliss_raw_data_file is not None:
-                bliss_raw_data_file = filter_esrf_mounting_points(bliss_raw_data_file)
                 strips = bliss_raw_data_file.lstrip("/").split("/")
                 if len(strips) > 2 and bliss_raw_data_file.startswith(
                     ("/data/visitor", "/data/visitor")

tomwer/core/scan/scanbase.py

@@ -279,6 +279,7 @@ class TomwerScanBase(TomwerObject):
     def get_opposite_projections(self, mode) -> tuple:
         """
         Return the two best opposite projections for the required mode.
+
         """
         radios_with_angle = self.projections_with_angle()
         angles = numpy.array(
@@ -321,10 +322,9 @@ class TomwerScanBase(TomwerObject):
         nearest_c1 = find_nearest(angles=angles, angle=couples[0])
         nearest_c2 = find_nearest(angles=angles, angle=couples[1])
         if nearest_c1 is not None and nearest_c2 is not None:
-            return (
-                AxisResource(radios_with_angle[nearest_c1], angle=nearest_c1),
-                AxisResource(radios_with_angle[nearest_c2], angle=nearest_c2),
-            )
+            radio_0 = AxisResource(radios_with_angle[nearest_c1])
+            radio_1 = AxisResource(radios_with_angle[nearest_c2])
+            return radio_0, radio_1
         else:
             return None, None
 

tomwer/core/scan/tests/test_process_registration.py

@@ -40,6 +40,24 @@ class TestProcessRegistration(unittest.TestCase):
     def tearDown(self):
         shutil.rmtree(self.tmp_dir)
 
+    def testGetCorValues(self):
+        from tomwer.core.process.reconstruction.axis import AxisTask
+
+        for i in range(20):
+            results = {"center_of_rotation": i}
+            Task._register_process(
+                self.scan.process_file,
+                process=AxisTask,
+                entry=self.scan.entry,
+                configuration=None,
+                results=results,
+                process_index=i,
+            )
+        cor_value = AxisTask.get_cor_frm_process_file(
+            self.scan.process_file, entry=self.scan.entry
+        )
+        self.assertEqual(cor_value, 19)
+
     def testGetProcessNodes(self):
         """insure it return the last dark process based on the processing index"""
 

tomwer/gui/reconstruction/axis/AxisMainWindow.py

@@ -10,10 +10,6 @@ from silx.gui import qt
 from tomwer.gui.utils.qt_utils import block_signals
 
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.process.reconstruction.utils.cor import (
-    absolute_pos_to_relative,
-    relative_pos_to_absolute,
-)
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 from ...utils.scandescription import ScanNameLabelAndShape
@@ -128,15 +124,17 @@ class AxisMainWindow(qt.QMainWindow):
         )
 
     def setAutoUpdateEstimatedCor(self, value):
-        self._axisWidget._settingsWidget._mainWidget.setUpdateXRotationAxisPixelPositionOnNewScan(
-            value
-        )
+        self._axisWidget.setUpdateAutomaticallyEstimatedCor(value)
+
+    def getAutoUpdateEstimatedCor(self):
+        return self._axisWidget.updateAutomaticallyEstimatedCor()
 
     def manual_uses_full_image(self, value):
         self._axisWidget.manual_uses_full_image(value)
 
     def _modeChanged(self):
         self.getAxisParams().mode = self.getMode()
+        self.getAxisParams().use_sinogram = self.useSinogram()
 
     def _CORValueLocked(self, lock):
         if lock:
@@ -154,8 +152,8 @@ class AxisMainWindow(qt.QMainWindow):
             and relative_value is not None
         ):
             try:
-                absolute_value = relative_pos_to_absolute(
-                    relative_pos=relative_value, det_width=self._axis_params.frame_width
+                absolute_value = (
+                    relative_value + (self._axis_params.frame_width - 1) / 2.0
                 )
             except TypeError:
                 absolute_value = None
@@ -165,8 +163,8 @@ class AxisMainWindow(qt.QMainWindow):
             and absolute_value is not None
         ):
             try:
-                relative_value = absolute_pos_to_relative(
-                    absolute_pos=absolute_value, det_width=self._axis_params.frame_width
+                relative_value = (
+                    absolute_value - (self._axis_params.frame_width - 1) / 2.0
                 )
             except TypeError:
                 relative_value = None
@@ -264,12 +262,3 @@ class AxisMainWindow(qt.QMainWindow):
 
     def setEstimatedCor(self, value: float):
         self._axisWidget.setEstimatedCor(value=value)
-
-    def getAutoUpdateEstimatedCor(self):
-        return self._axisWidget.updateXRotationAxisPixelPositionOnNewScan()
-
-    def isYAxisInverted(self) -> bool:
-        return self._axisWidget.isYAxisInverted()
-
-    def setYAxisInverted(self, checked: bool):
-        return self._axisWidget.setYAxisInverted(checked=checked)