nabu 2024.1.10__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/estimation/tests/test_cor.py

@@ -4,17 +4,16 @@ import pytest
 import scipy.ndimage
 import h5py
 from nabu.testutils import utilstest, __do_long_tests__
-from nabu.testutils import get_data as nabu_get_data
+from nabu.testutils import get_data
 
 from nabu.estimation.cor import (
     CenterOfRotation,
     CenterOfRotationAdaptiveSearch,
     CenterOfRotationGrowingWindow,
     CenterOfRotationSlidingWindow,
-    CenterOfRotationFourierAngles,
     CenterOfRotationOctaveAccurate,
 )
-from nabu.estimation.cor_sino import SinoCor
+from nabu.estimation.cor_sino import SinoCor, CenterOfRotationFourierAngles, CenterOfRotationVo, __have_algotom__
 
 
 @pytest.fixture(scope="class")
@@ -51,7 +50,6 @@ def bootstrap_cor_fourier(request):
     cls.sinos = a["sinos"]
     cls.angles = a["angles"]
     cls.true_cor = a["true_cor"]
-    cls.estimated_cor_from_motor = a["estimated_cor_from_motor"]
 
 
 def get_cor_data_h5(*dataset_path):
@@ -64,11 +62,9 @@ def get_cor_data_h5(*dataset_path):
     dataset_downloaded_path = utilstest.getfile(dataset_relpath)
     with h5py.File(dataset_downloaded_path, "r") as hf:
         data = hf["/entry/instrument/detector/data"][()]
-
-        cor_global_pix = hf["/calibration/alignment/global/x_rotation_axis_pixel_position"][()]
-
-        cor_highlow_pix = hf["/calibration/alignment/highlow/x_rotation_axis_pixel_position"][()]
-        tilt_deg = hf["/calibration/alignment/highlow/z_camera_tilt"][()]
+        cor_global_pix = hf["/calibration/alignment/global/x_rotation_axis_pixel_position"][()][0]
+        cor_highlow_pix = hf["/calibration/alignment/highlow/x_rotation_axis_pixel_position"][()][0]
+        tilt_deg = hf["/calibration/alignment/highlow/z_camera_tilt"][()][0]
 
     return data, (cor_global_pix, cor_highlow_pix, tilt_deg)
 
@@ -109,14 +105,16 @@ class TestCor:
         radio2 = np.fliplr(self.data[1, :, :])
 
         CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2)
+        cor_position = CoR_calc.find_shift(radio1, radio2, return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
         assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
 
         # testing again with the validity return value
-        cor_position, result_validity = CoR_calc.find_shift(radio1, radio2, return_validity=True)
+        cor_position, result_validity = CoR_calc.find_shift(
+            radio1, radio2, return_validity=True, return_relative_to_middle=True
+        )
         assert np.isscalar(cor_position)
 
         message = (
@@ -133,7 +131,7 @@ class TestCor:
         radio2 = np.random.poisson(np.fliplr(radio2) * 400)
 
         CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3))
+        cor_position = CoR_calc.find_shift(radio1, radio2, median_filt_shape=(3, 3), return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
@@ -157,8 +155,7 @@ class TestCor:
 
         CoR_calc = CenterOfRotation()
 
-        # cor_position = CoR_calc.find_shift(radio1, radio2)
-        cor_position = CoR_calc.find_shift(radio1, radio2, low_pass=(6.0, 0.3))
+        cor_position = CoR_calc.find_shift(radio1, radio2, low_pass=(6.0, 0.3), return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
@@ -168,7 +165,7 @@ class TestCor:
     def test_half_tomo_cor_exp(self):
         """test the half_tomo algorithm on experimental data"""
 
-        radios = nabu_get_data("ha_autocor_radios.npz")
+        radios = get_data("ha_autocor_radios.npz")
         radio1 = radios["radio1"]
         radio2 = radios["radio2"]
         cor_pos = radios["cor_pos"]
@@ -177,20 +174,22 @@ class TestCor:
 
         CoR_calc = CenterOfRotationAdaptiveSearch()
 
-        cor_position = CoR_calc.find_shift(radio1, radio2, low_pass=1, high_pass=20, filtered_cost=True)
+        cor_position = CoR_calc.find_shift(
+            radio1, radio2, low_pass=1, high_pass=20, filtered_cost=True, return_relative_to_middle=True
+        )
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = (
             "Computed CoR %f " % cor_position
-            + " and real CoR %f should coincide when using the halftomo algorithm with hald tomo data" % cor_pos
+            + " and real CoR %f should coincide when using the halftomo algorithm with half tomo data" % cor_pos
         )
-        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol), message
+        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol + 0.5), message
 
     @pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
     def test_half_tomo_cor_exp_limited(self):
         """test the hal_tomo algorithm on experimental data and global search with limits"""
 
-        radios = nabu_get_data("ha_autocor_radios.npz")
+        radios = get_data("ha_autocor_radios.npz")
         radio1 = radios["radio1"]
         radio2 = radios["radio2"]
         cor_pos = radios["cor_pos"]
@@ -200,15 +199,22 @@ class TestCor:
         CoR_calc = CenterOfRotationAdaptiveSearch()
 
         cor_position, result_validity = CoR_calc.find_shift(
-            radio1, radio2, low_pass=1, high_pass=20, margins=(100, 10), filtered_cost=False, return_validity=True
+            radio1,
+            radio2,
+            low_pass=1,
+            high_pass=20,
+            margins=(100, 10),
+            filtered_cost=False,
+            return_validity=True,
+            return_relative_to_middle=True,
         )
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = (
             "Computed CoR %f " % cor_position
-            + " and real CoR %f should coincide when using the halftomo algorithm with hald tomo data" % cor_pos
+            + " and real CoR %f should coincide when using the halftomo algorithm with half tomo data" % cor_pos
         )
-        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol), message
+        assert np.isclose(cor_pos, cor_position, atol=self.abs_tol + 0.5), message
 
         message = "returned result_validity is  %s " % result_validity + " while it should be sound"
 
@@ -219,7 +225,7 @@ class TestCor:
         radio2 = np.fliplr(self.data[1, :, :])
 
         CoR_calc = CenterOfRotation()
-        cor_position = CoR_calc.find_shift(radio1, radio2, padding_mode="edge")
+        cor_position = CoR_calc.find_shift(radio1, radio2, padding_mode="edge", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_gl_pix
@@ -232,7 +238,7 @@ class TestCor:
         radio2 = self.data[1, :, :]
 
         with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
+            CoR_calc.find_shift(radio1, radio2, return_relative_to_middle=True)
 
         message = "Error should have been raised about img #1 shape, other error raised instead:\n%s" % str(ex.value)
         assert "Images need to be 2-dimensional. Shape of image #1" in str(ex.value), message
@@ -244,7 +250,7 @@ class TestCor:
         radio2 = self.data
 
         with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
+            CoR_calc.find_shift(radio1, radio2, return_relative_to_middle=True)
 
         message = "Error should have been raised about img #2 shape, other error raised instead:\n%s" % str(ex.value)
         assert "Images need to be 2-dimensional. Shape of image #2" in str(ex.value), message
@@ -256,7 +262,7 @@ class TestCor:
         radio2 = self.data[1, :, 0:10]
 
         with pytest.raises(ValueError) as ex:
-            CoR_calc.find_shift(radio1, radio2)
+            CoR_calc.find_shift(radio1, radio2, return_relative_to_middle=True)
 
         message = (
             "Error should have been raised about different image shapes, "
@@ -274,7 +280,11 @@ class TestCorWindowSlide:
 
         CoR_calc = CenterOfRotationSlidingWindow()
         cor_position = CoR_calc.find_shift(
-            radio1, radio2, side="left", window_width=round(radio1.shape[-1] / 4.0 * 3.0)
+            radio1,
+            radio2,
+            side="left",
+            window_width=round(radio1.shape[-1] / 4.0 * 3.0),
+            return_relative_to_middle=True,
         )
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
@@ -282,7 +292,12 @@ class TestCorWindowSlide:
         assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
 
         cor_position, result_validity = CoR_calc.find_shift(
-            radio1, radio2, side="left", window_width=round(radio1.shape[-1] / 4.0 * 3.0), return_validity=True
+            radio1,
+            radio2,
+            side="left",
+            window_width=round(radio1.shape[-1] / 4.0 * 3.0),
+            return_validity=True,
+            return_relative_to_middle=True,
         )
 
         message = "returned result_validity is  %s " % result_validity + " while it should be sound"
@@ -294,7 +309,7 @@ class TestCorWindowSlide:
         radio2 = np.fliplr(self.data[1, :, :])
 
         CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="center")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="center", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_gl_pix
@@ -305,7 +320,7 @@ class TestCorWindowSlide:
         radio2 = np.fliplr(self.data_ha_proj[1, :, :])
 
         CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="right")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="right", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
@@ -316,7 +331,7 @@ class TestCorWindowSlide:
         radio2 = self.data_ha_proj[1, :, :]
 
         CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="left")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="left", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % -self.cor_ha_pr_pix
@@ -327,7 +342,7 @@ class TestCorWindowSlide:
         sino2 = np.fliplr(self.data_ha_sino[1, :, :])
 
         CoR_calc = CenterOfRotationSlidingWindow()
-        cor_position = CoR_calc.find_shift(sino1, sino2, side="right")
+        cor_position = CoR_calc.find_shift(sino1, sino2, side="right", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
@@ -342,7 +357,7 @@ class TestCorWindowGrow:
         radio2 = np.fliplr(self.data[1, :, :])
 
         CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="center")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="center", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_gl_pix
         assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
@@ -352,7 +367,7 @@ class TestCorWindowGrow:
         radio2 = np.fliplr(self.data_ha_proj[1, :, :])
 
         CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="right")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="right", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
@@ -363,13 +378,15 @@ class TestCorWindowGrow:
         radio2 = self.data_ha_proj[1, :, :]
 
         CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="left")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="left", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % -self.cor_ha_pr_pix
         assert np.isclose(-self.cor_ha_pr_pix, cor_position, atol=self.abs_tol), message
 
-        cor_position, result_validity = CoR_calc.find_shift(radio1, radio2, side="left", return_validity=True)
+        cor_position, result_validity = CoR_calc.find_shift(
+            radio1, radio2, side="left", return_validity=True, return_relative_to_middle=True
+        )
 
         message = "returned result_validity is  %s " % result_validity + " while it should be sound"
 
@@ -380,7 +397,7 @@ class TestCorWindowGrow:
         radio2 = np.fliplr(self.data_ha_proj[1, :, :])
 
         CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(radio1, radio2, side="all")
+        cor_position = CoR_calc.find_shift(radio1, radio2, side="all", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_pr_pix
@@ -391,7 +408,7 @@ class TestCorWindowGrow:
         sino2 = np.fliplr(self.data_ha_sino[1, :, :])
 
         CoR_calc = CenterOfRotationGrowingWindow()
-        cor_position = CoR_calc.find_shift(sino1, sino2, side="right")
+        cor_position = CoR_calc.find_shift(sino1, sino2, side="right", return_relative_to_middle=True)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
@@ -421,7 +438,9 @@ class TestCorOctaveAccurate:
     def test_cor_accurate_positive_shift(self):
         detector_width = self.image_pair_stylo[0].shape[1]
         CoR_calc = CenterOfRotationOctaveAccurate()
-        cor_position = CoR_calc.find_shift(self.image_pair_stylo[0], np.fliplr(self.image_pair_stylo[1]), "center")
+        cor_position = CoR_calc.find_shift(
+            self.image_pair_stylo[0], np.fliplr(self.image_pair_stylo[1]), "center", return_relative_to_middle=True
+        )
         cor_position = cor_position + detector_width / 2
         assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
         message = f"Computed CoR {cor_position} and expected CoR {self.cor_pos_abs_stylo} do not coincide."
@@ -431,7 +450,10 @@ class TestCorOctaveAccurate:
         detector_width = self.image_pair_blc12781[0].shape[1]
         CoR_calc = CenterOfRotationOctaveAccurate()
         cor_position = CoR_calc.find_shift(
-            self.image_pair_blc12781[0], np.fliplr(self.image_pair_blc12781[1]), "center"
+            self.image_pair_blc12781[0],
+            np.fliplr(self.image_pair_blc12781[1]),
+            "center",
+            return_relative_to_middle=True,
         )
         cor_position = cor_position + detector_width / 2
         assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
@@ -441,32 +463,76 @@ class TestCorOctaveAccurate:
 
 @pytest.mark.usefixtures("bootstrap_cor_fourier", "bootstrap_cor_win")
 class TestCorFourierAngle:
+    @pytest.mark.skip("Broken function")
     def test_sino_right_axis_with_near_pos(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
+        sino = np.vstack([self.data_ha_sino[0], self.data_ha_sino[1]])
         start_angle = np.pi / 4
-        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
+        angles = np.linspace(start_angle, start_angle + 2 * np.pi, sino.shape[0])
 
-        cor_options = {"side": 740, "refine": True}
-
-        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
-        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        CoR_calc = CenterOfRotationFourierAngles()
+        cor_position = CoR_calc.find_shift(
+            sino, angles, side="right", crop_around_cor=True, return_relative_to_middle=True
+        )  # side=sino.shape[1]/2+740)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
         message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
         assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message
 
-    def test_sino_right_axis_with_ignore(self):
-        sino1 = self.data_ha_sino[0, :, :]
-        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
-        start_angle = np.pi / 4
-        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
-
-        cor_options = {"side": "ignore", "refine": True}
+    def test_sino_right_axis_with_near_pos_jl(self):
 
-        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
-        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        CoR_calc = CenterOfRotationFourierAngles()
+        cor_position = CoR_calc.find_shift(
+            self.sinos, self.angles, side="right", crop_around_cor=True, return_relative_to_middle=True
+        )  # side=sino.shape[1]/2+740)
         assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
 
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
-        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message
+        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.true_cor
+        assert np.isclose(self.true_cor, cor_position, atol=self.abs_tol * 3), message
+
+
+@pytest.fixture(scope="class")
+def bootstrap_vo_cor(request):
+    cls = request.cls
+    cls.tol = 1e-2
+    cls.test_sinograms = {name: get_data("sino_%s.npz" % name) for name in ["pencil", "coffee", "mousebrains"]}
+    sino_bamboo = get_data("sino_bamboo_hercules_for_test.npz")
+    cls.test_sinograms["bamboo_hercules"] = {
+        "data": sino_bamboo["sinos"],
+        # FIXME the test file needs to be re-generated, "true_cor" has an incorrect offset
+        "cor": sino_bamboo["true_cor"] + (2560) / 2,
+    }
+
+
+@pytest.mark.skipif(not (__have_algotom__), reason="need algotom for this test")
+@pytest.mark.usefixtures("bootstrap_vo_cor")
+class TestVoCOR:
+
+    def _test_cor(self, dataset_name, tolerance=1e-2, **cor_options):
+        cor_finder = CenterOfRotationVo()
+        cor = cor_finder.find_shift(
+            self.test_sinograms[dataset_name]["data"], return_relative_to_middle=False, **cor_options
+        )
+        cor_ref = self.test_sinograms[dataset_name]["cor"]
+        assert (
+            np.abs(cor - cor_ref) < tolerance
+        ), "CoR estimation failed for %s: expected %.3f, got %.3f (tol = %.2e)" % (
+            dataset_name,
+            cor_ref,
+            cor,
+            tolerance,
+        )
+
+    def test_cor_180(self):
+        self._test_cor("pencil", tolerance=0.6)
+
+    def test_cor_180_more_complex(self): ...
+
+    def test_cor_360_halftomo(self):
+        self._test_cor("bamboo_hercules", tolerance=0.1, halftomo=True)
+
+    def test_cor_360_halftomo_hard(self):
+        # This one is difficult
+        self._test_cor("mousebrains", tolerance=2, halftomo=True)
+
+    def test_cor_360_not_halftomo(self):
+        self._test_cor("coffee", tolerance=0.5, halftomo=False, is_360=True)

nabu/estimation/tests/test_focus.py

@@ -46,13 +46,13 @@ def get_focus_data(*dataset_path):
             ]
         )
 
-        angle_best_ind = hf["/calibration/focus/angle/best_img"][()]
-        angle_best_pos = hf["/calibration/focus/angle/best_pos"][()]
-        angle_tilt_v = hf["/calibration/focus/angle/tilt_v_rad"][()]
-        angle_tilt_h = hf["/calibration/focus/angle/tilt_h_rad"][()]
+        angle_best_ind = hf["/calibration/focus/angle/best_img"][()][0]
+        angle_best_pos = hf["/calibration/focus/angle/best_pos"][()][0]
+        angle_tilt_v = hf["/calibration/focus/angle/tilt_v_rad"][()][0]
+        angle_tilt_h = hf["/calibration/focus/angle/tilt_h_rad"][()][0]
 
-        std_best_ind = hf["/calibration/focus/std/best_img"][()]
-        std_best_pos = hf["/calibration/focus/std/best_pos"][()]
+        std_best_ind = hf["/calibration/focus/std/best_img"][()][0]
+        std_best_pos = hf["/calibration/focus/std/best_pos"][()][0]
 
     calib_data_angle = (angle_best_ind, angle_best_pos, angle_tilt_v, angle_tilt_h)
     calib_data_std = (std_best_ind, std_best_pos)

nabu/estimation/tilt.py

@@ -188,7 +188,7 @@ class CameraTilt(CenterOfRotation):
         img_fft_1 = img_fft_1[..., : img_fft_1.shape[-2] // 2, :]
         img_fft_2 = img_fft_2[..., : img_fft_2.shape[-2] // 2, :]
 
-        tilt_pix = self.find_shift(img_fft_1, img_fft_2, shift_axis=-2)
+        tilt_pix = self.find_shift(img_fft_1, img_fft_2, shift_axis=-2, return_relative_to_middle=True)
         tilt_deg = -(360 / img_shape[0]) * tilt_pix
 
         img_1 = skt.rotate(img_1, tilt_deg)
@@ -201,6 +201,7 @@ class CameraTilt(CenterOfRotation):
             peak_fit_radius=peak_fit_radius,
             high_pass=high_pass,
             low_pass=low_pass,
+            return_relative_to_middle=True,
         )
 
         if self.verbose:

nabu/estimation/utils.py

@@ -1,39 +1,11 @@
 import numpy as np
-from scipy.signal import find_peaks
 
 
-def is_fullturn_scan(angles):
+def is_fullturn_scan(angles_rad, tol=None):
     """
     Return True if the angles correspond to a full-turn (360 degrees) scan.
     """
-    angles = angles % (2 * np.pi)
-    angles -= angles.min()
-    sin_angles = np.sin(angles)
-    min_dist = 5  # TODO find a more robust angles-based min distance, though this should cover most of the cases
-    maxima = find_peaks(sin_angles, distance=min_dist)[0]
-    minima = find_peaks(-sin_angles, distance=min_dist)[0]
-    n_max = maxima.size
-    n_min = minima.size
-    # abs(n_max - n_min) actually means the following:
-    #  * 0: All turns are full (eg. 2pi, 4pi)
-    #  * 1: At least one half-turn remains (eg. pi, 3pi)
-    if abs(n_max - n_min) == 0:
-        return True
-    else:
-        return False
-
-
-def get_halfturn_indices(angles):
-    angles = angles % (2 * np.pi)
-    angles -= angles.min()
-    sin_angles = np.sin(angles)
-    min_dist = 5  # TODO find a more robust angles-based min distance, though this should cover most of the cases
-    maxima = find_peaks(sin_angles, distance=min_dist)[0]
-    minima = find_peaks(-sin_angles, distance=min_dist)[0]
-    extrema = np.sort(np.hstack([maxima, minima]))
-    extrema -= extrema.min()
-    extrema = np.hstack([extrema, [angles.size - 1]])
-    res = []
-    for i in range(extrema.size - 1):
-        res.append((extrema[i], extrema[i + 1]))
-    return res
+    angles_rad = np.sort(angles_rad)
+    if tol is None:
+        tol = np.min(np.abs(np.diff(angles_rad))) * 1.1
+    return np.abs((angles_rad.max() - angles_rad.min()) - (2 * np.pi)) < tol

nabu/io/__init__.py

@@ -1,2 +1,2 @@
 from .reader import NPReader, EDFReader, HDF5File, HDF5Loader, ChunkReader, Readers
-from .writer import NXProcessWriter, TIFFWriter, EDFWriter, JP2Writer, NPYWriter, NPZWriter
+from .writer import NXProcessWriter

nabu/io/cast_volume.py

@@ -66,7 +66,7 @@ def get_default_output_volume(
                 Constructor = EDFVolume
             elif output_type == "jp2":
                 Constructor = JP2KVolume
-            return Constructor(
+            return Constructor(  # pylint: disable=E0601
                 folder=os.path.join(
                     os.path.dirname(input_volume.data_url.file_path()),
                     output_dir,