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

nabu/reconstruction/tests/test_cone.py

@@ -236,7 +236,7 @@ class TestCone:
         err_median_profile = np.median(diff, axis=(-1, -2))
 
         assert np.max(err_max_profile) < 2e-3
-        assert np.max(err_median_profile) < 5e-6
+        assert np.max(err_median_profile) < 5.1e-6
 
     def test_reconstruction_horizontal_translations(self):
         n_z = n_y = n_x = 256
@@ -273,7 +273,7 @@ class TestCone:
         # Error tolerance has to be higher for these shifts.
         for shift_type, shifts, err_tol in [
             ("integer shifts", shifts_int, 5e-3),
-            ("float shifts", shifts_float, 1.4e-1),
+            ("float shifts", shifts_float, 1.5e-1),
         ]:
             cone_data_shifted = np.zeros_like(cone_data)
             [shift(cone_data[:, i, :], (0, shifts[i]), output=cone_data_shifted[:, i, :]) for i in range(n_a)]
@@ -281,8 +281,8 @@ class TestCone:
             # Reconstruct with horizontal shifts
             cone_reconstructor_with_correction = ConebeamReconstructor(
                 *reconstructor_args,
-                axis_correction=shifts,
                 **reconstructor_kwargs,
+                extra_options={"axis_correction": -shifts},
             )
 
             rec_with_correction = cone_reconstructor_with_correction.reconstruct(cone_data_shifted)
@@ -330,7 +330,6 @@ class TestCone:
 
             metric = lambda img: np.max(np.abs(clip_circle(img, radius=int(0.85 * 128))))
             error_profile = np.array([metric(rec[i] - rec_z[i]) for i in range(n_z)])
-            assert error_profile.max() < 3e-2, "Max error for padding=%s is too high" % padding_mode
 
             # import matplotlib.pyplot as plt
             # plt.figure()
@@ -338,6 +337,12 @@ class TestCone:
             # plt.legend([padding_mode])
             # plt.show()
 
+            assert error_profile.max() < 3.1e-2, "Max error for padding=%s is too high" % padding_mode
+            if padding_mode != "zeros":
+                assert not (np.allclose(rec[n_z // 2], rec_z[n_z // 2])), (
+                    "Reconstruction should be different when padding_mode=%s" % padding_mode
+                )
+
     def test_roi(self):
         n_z = n_y = n_x = 256
         n_a = 500
@@ -367,7 +372,7 @@ class TestCone:
         ref = cone_reconstructor_full.reconstruct(cone_data)
 
         # roi is in the form (start_x, end_x, start_y, end_y)
-        for roi in ((20, -20, 10, -10), (0, n_x, 0, n_y), (15, -15, 15, -15)):
+        for roi in ((20, -20, 10, -10), (0, n_x, 0, n_y), (50, -50, 15, -15)):
             # convert negative indices
             start_x, end_x, start_y, end_y = roi
             if start_y < 0:

nabu/reconstruction/tests/test_deringer.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 from nabu.reconstruction.rings_cuda import CudaSinoMeanDeringer
-from nabu.testutils import compare_arrays, get_data, generate_tests_scenarios, __do_long_tests__, __do_large_mem_tests__
+from nabu.testutils import compare_arrays, get_data, generate_tests_scenarios, __do_long_tests__
 from nabu.reconstruction.rings import MunchDeringer, SinoMeanDeringer, VoDeringer, __has_algotom__
 from nabu.thirdparty.pore3d_deringer_munch import munchetal_filter
 from nabu.cuda.utils import __has_pycuda__, get_cuda_context
@@ -9,11 +9,12 @@ from nabu.cuda.utils import __has_pycuda__, get_cuda_context
 if __has_pycuda__:
     import pycuda.gpuarray as garray
     from nabu.processing.fft_cuda import get_available_fft_implems
+    from nabu.thirdparty.tomocupy_remove_stripe import __have_tomocupy_deringer__
+
     from nabu.reconstruction.rings_cuda import (
         CudaMunchDeringer,
         can_use_cuda_deringer,
         CudaVoDeringer,
-        __have_tomocupy_deringer__,
     )
 
     __has_cuda_deringer__ = can_use_cuda_deringer()
@@ -27,7 +28,7 @@ fw_scenarios = generate_tests_scenarios(
         "sigma": [1.0],
         "wname": ["db15"],
         "padding": [(100, 100)],
-        "fft_implem": ["skcuda"],
+        "fft_implem": ["vkfft"],
     }
 )
 if __do_long_tests__:
@@ -58,7 +59,7 @@ def bootstrap(request):
 
 
 @pytest.mark.usefixtures("bootstrap")
-class TestMunchDeringer:
+class TestDeringer:
     @staticmethod
     def add_stripes_to_sino(sino, rings_desc):
         """
@@ -144,8 +145,8 @@ class TestMunchDeringer:
         # TODO check result. The generated test sinogram is "too synthetic" for this kind of deringer
 
     @pytest.mark.skipif(
-        not (__have_tomocupy_deringer__ and __do_large_mem_tests__),
-        reason="Need cupy for this test, and use NABU_LARGE_MEM_TESTS",
+        not (__have_tomocupy_deringer__),
+        reason="Need cupy for this test",
     )
     def test_cuda_vo_deringer(self):
         # Beware, this deringer seems to be buggy for "too-small" sinograms

nabu/reconstruction/tests/test_fbp.py

@@ -15,6 +15,7 @@ __has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
 
 if __has_pycuda__:
     from nabu.reconstruction.fbp import CudaBackprojector
+    from nabu.reconstruction.hbp import HierarchicalBackprojector
 if __has_pyopencl__:
     from nabu.reconstruction.fbp_opencl import OpenCLBackprojector
 
@@ -50,12 +51,13 @@ def bootstrap(request):
         cls.cuda_ctx.pop()
 
 
+def clip_to_inner_circle(img, radius_factor=0.99, out_value=0):
+    radius = int(radius_factor * max(img.shape) / 2)
+    return clip_circle(img, radius=radius, out_value=out_value)
+
+
 @pytest.mark.usefixtures("bootstrap")
 class TestFBP:
-    @staticmethod
-    def clip_to_inner_circle(img, radius_factor=0.99):
-        radius = int(radius_factor * max(img.shape) / 2)
-        return clip_circle(img, radius=radius)
 
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
@@ -96,7 +98,7 @@ class TestFBP:
         B = self._get_backprojector(config, (500, 512))
         res = self.apply_fbp(config, B, self.sino_512)
 
-        delta_clipped = self.clip_to_inner_circle(res - self.ref_512)
+        delta_clipped = clip_to_inner_circle(res - self.ref_512)
         err_max = np.max(np.abs(delta_clipped))
 
         assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
@@ -110,7 +112,7 @@ class TestFBP:
         res = self.apply_fbp(config, B, self.sino_511)
         ref = self.ref_512[:-1, :-1]
 
-        delta_clipped = self.clip_to_inner_circle(res - ref)
+        delta_clipped = clip_to_inner_circle(res - ref)
         err_max = np.max(np.abs(delta_clipped))
 
         assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
@@ -191,12 +193,24 @@ class TestFBP:
                 config, sino.shape, rot_center=rot_center, extra_options={"clip_outer_circle": False}
             )
             res_noclip = B0.fbp(sino)
-            ref = self.clip_to_inner_circle(res_noclip, radius_factor=1)
-
+            ref = clip_to_inner_circle(res_noclip, radius_factor=1)
             abs_diff = np.abs(res - ref)
             err_max = np.max(abs_diff)
             assert err_max < tol, "Max error is too high for rot_center=%s ; %s" % (str(rot_center), str(config))
 
+            # Test with custom outer circle value
+            B1 = self._get_backprojector(
+                config,
+                sino.shape,
+                rot_center=rot_center,
+                extra_options={"clip_outer_circle": True, "outer_circle_value": np.nan},
+            )
+            res1 = self.apply_fbp(config, B1, sino)
+            ref1 = clip_to_inner_circle(res_noclip, radius_factor=1, out_value=np.nan)
+            abs_diff1 = np.abs(res1 - ref1)
+            err_max1 = np.nanmax(abs_diff1)
+            assert err_max1 < tol, "Max error is too high for rot_center=%s ; %s" % (str(rot_center), str(config))
+
     @pytest.mark.parametrize("config", scenarios)
     def test_fbp_centered_axis(self, config):
         """
@@ -213,7 +227,7 @@ class TestFBP:
         B = self._get_backprojector(config, sino.shape, rot_center=rot_center, extra_options={"centered_axis": True})
         res = self.apply_fbp(config, B, sino)
         # The outside region (outer circle) is different as "res" is a wider slice
-        diff = self.clip_to_inner_circle(res[50:-50, 50:-50] - ref)
+        diff = clip_to_inner_circle(res[50:-50, 50:-50] - ref)
         err_max = np.max(np.abs(diff))
         assert err_max < 5e-2, "centered_axis without clip_circle: something wrong"
 
@@ -228,7 +242,7 @@ class TestFBP:
             },
         )
         res2 = self.apply_fbp(config, B, sino)
-        diff = res2 - self.clip_to_inner_circle(res, radius_factor=1)
+        diff = res2 - clip_to_inner_circle(res, radius_factor=1)
         err_max = np.max(np.abs(diff))
         assert err_max < 1e-5, "centered_axis with clip_circle: something wrong"
 
@@ -250,3 +264,103 @@ class TestFBP:
         B = self._get_backprojector(config, sino_diff.shape, filter_name="hilbert", rot_center=255.5 + 0.5)
         rec = self.apply_fbp(config, B, sino_diff)
         # Looks good, but all frequencies are not recovered. Use a metric like SSIM or FRC ?
+
+
+@pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for using HBP")
+@pytest.mark.usefixtures("bootstrap")
+class TestHBP:
+
+    def _compare_to_reference(self, res, ref, err_msg="", radius_factor=0.9, rel_tol=0.02):
+        delta_clipped = clip_to_inner_circle(res - ref, radius_factor=radius_factor)
+        err_max = np.max(np.abs(delta_clipped))
+        err_max_rel = err_max / ref.max()
+        assert err_max_rel < rel_tol, err_msg
+
+    def test_hbp_simple(self):
+        B = HierarchicalBackprojector(self.sino_512.shape)
+        res = B.fbp(self.sino_512)
+        self._compare_to_reference(res, self.ref_512)
+
+    def test_hbp_input_output(self):
+        B = HierarchicalBackprojector(self.sino_512.shape)
+
+        d_sino = B._processing.to_device("d_sino2", self.sino_512)
+        d_slice = B._processing.allocate_array("d_slice2", self.ref_512.shape)
+        h_slice = np.zeros_like(self.ref_512)
+
+        # in: host, out: host (not provided)
+        # see test above
+
+        # in: host, out: host (provided)
+        res = B.fbp(self.sino_512, output=h_slice)
+        self._compare_to_reference(h_slice, self.ref_512, err_msg="in: host, out: host (provided)")
+        h_slice.fill(0)
+
+        # in: host, out: device
+        res = B.fbp(self.sino_512, output=d_slice)
+        self._compare_to_reference(d_slice.get(), self.ref_512, err_msg="in: host, out: device")
+        d_slice.fill(0)
+
+        # in: device, out: host (not provided)
+        res = B.fbp(d_sino)
+        self._compare_to_reference(res, self.ref_512, err_msg="in: device, out: host (not provided)")
+
+        # in: device, out: host (provided)
+        res = B.fbp(d_sino, output=h_slice)
+        self._compare_to_reference(h_slice, self.ref_512, err_msg="in: device, out: host (provided)")
+        h_slice.fill(0)
+
+        # in: device, out: device
+        res = B.fbp(d_sino, output=d_slice)
+        self._compare_to_reference(d_slice.get(), self.ref_512, err_msg="in: device, out: device")
+        d_slice.fill(0)
+
+    def test_hbp_cor(self):
+        """
+        Test HBP with various sinogram shapes, obtained by truncating horizontally the original sinogram.
+        The Center of rotation is always 255.5 (the one of original sinogram), so it also tests reconstruction with a shifted CoR.
+        """
+        for crop in [1, 2, 5, 10]:
+            sino = np.ascontiguousarray(self.sino_512[:, :-crop])
+            B = HierarchicalBackprojector(sino.shape, rot_center=255.5)
+            res = B.fbp(sino)
+
+            # HBP always uses "centered_axis=1", so we cannot compare non-integer shifts
+            if crop % 2 == 0:
+                ref = self.ref_512[crop // 2 : -crop // 2, crop // 2 : -crop // 2]
+                self._compare_to_reference(res, ref, radius_factor=0.95, rel_tol=0.02)
+
+    def test_hbp_clip_circle(self):
+        B_clip = HierarchicalBackprojector(self.sino_512.shape, extra_options={"clip_outer_circle": True})
+        B_noclip = HierarchicalBackprojector(self.sino_512.shape, extra_options={"clip_outer_circle": False})
+        res_clip = B_clip.fbp(self.sino_512)
+        res_noclip = B_noclip.fbp(self.sino_512)
+        self._compare_to_reference(res_clip, clip_to_inner_circle(res_noclip, radius_factor=1), "clip_circle")
+
+    def test_hbp_axis_corr(self):
+        sino = self.sino_512
+
+        # Create a sinogram with a drift in the rotation axis
+        def create_drifted_sino(sino, drifts):
+            out = np.zeros_like(sino)
+            for i in range(sino.shape[0]):
+                out[i] = shift(sino[i], drifts[i])
+            return out
+
+        drifts = np.linspace(0, 20, sino.shape[0])
+        sino = create_drifted_sino(sino, drifts)
+
+        B = HierarchicalBackprojector(sino.shape, extra_options={"axis_correction": drifts})
+        res = B.fbp(sino)
+
+        # Max error is relatively high, migh be due to interpolation of scipy shift in sinogram
+        self._compare_to_reference(res, self.ref_512, radius_factor=0.95, rel_tol=0.04, err_msg="axis_corr")
+
+    @pytest.mark.skipif(not (__do_long_tests__), reason="need NABU_LONG_TESTS=1 for this test")
+    def test_hbp_scale_factor(self):
+        scale_factor = 0.03125
+        B_scaled = HierarchicalBackprojector(self.sino_512.shape, extra_options={"scale_factor": scale_factor})
+        B_unscaled = HierarchicalBackprojector(self.sino_512.shape)
+        res_scaled = B_scaled.fbp(self.sino_512)
+        res_unscaled = B_unscaled.fbp(self.sino_512)
+        self._compare_to_reference(res_scaled, res_unscaled * scale_factor, rel_tol=1e-7, err_msg="scale_factor")

nabu/reconstruction/tests/test_filtering.py

@@ -25,6 +25,7 @@ tests_scenarios = generate_tests_scenarios(
         "filter_name": filters_to_test,
         "padding_mode": padding_modes_to_test,
         "output_provided": [True, False],
+        "truncated_sino": [True, False],
     }
 )
 
@@ -33,12 +34,16 @@ tests_scenarios = generate_tests_scenarios(
 def bootstrap(request):
     cls = request.cls
     cls.sino = get_data("mri_sino500.npz")["data"]
+    cls.sino_truncated = np.ascontiguousarray(cls.sino[:, 160:-160])
+
     if __has_pycuda__:
         cls.ctx_cuda = get_cuda_context(cleanup_at_exit=False)
         cls.sino_cuda = garray.to_gpu(cls.sino)
+        cls.sino_truncated_cuda = garray.to_gpu(cls.sino_truncated)
     if __has_pyopencl__:
         cls.cl = OpenCLProcessing(device_type="all")
         cls.sino_cl = parray.to_device(cls.cl.queue, cls.sino)
+        cls.sino_truncated_cl = parray.to_device(cls.cl.queue, cls.sino_truncated)
 
     yield
 
@@ -50,7 +55,7 @@ def bootstrap(request):
 class TestSinoFilter:
     @pytest.mark.parametrize("config", tests_scenarios)
     def test_filter(self, config):
-        sino = self.sino
+        sino = self.sino if not (config["truncated_sino"]) else self.sino_truncated
 
         sino_filter = SinoFilter(
             sino.shape,
@@ -69,12 +74,13 @@ class TestSinoFilter:
             sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
         )
 
-        assert np.allclose(res, ref, atol=1e-6)
+        assert np.allclose(res, ref, atol=4e-6)
 
     @pytest.mark.skipif(not (__has_pycuda__), reason="Need Cuda + pycuda to use CudaSinoFilter")
     @pytest.mark.parametrize("config", tests_scenarios)
     def test_cuda_filter(self, config):
-        sino = self.sino_cuda
+        sino = self.sino_cuda if not (config["truncated_sino"]) else self.sino_truncated_cuda
+        h_sino = self.sino if not (config["truncated_sino"]) else self.sino_truncated
 
         sino_filter = CudaSinoFilter(
             sino.shape,
@@ -91,14 +97,9 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            self.sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            h_sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
         )
 
-        if not np.allclose(res.get(), ref, atol=6e-5):
-            from spire.utils import ims
-
-            ims([res.get(), ref, res.get() - ref])
-
         assert np.allclose(res.get(), ref, atol=6e-5), "test_cuda_filter: something wrong with config=%s" % (
             str(config)
         )
@@ -108,7 +109,8 @@ class TestSinoFilter:
     )
     @pytest.mark.parametrize("config", tests_scenarios)
     def test_opencl_filter(self, config):
-        sino = self.sino_cl
+        sino = self.sino_cl if not (config["truncated_sino"]) else self.sino_truncated_cl
+        h_sino = self.sino if not (config["truncated_sino"]) else self.sino_truncated
 
         sino_filter = OpenCLSinoFilter(
             sino.shape,
@@ -125,7 +127,7 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            self.sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            h_sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
         )
 
         assert np.allclose(res.get(), ref, atol=6e-5), "test_opencl_filter: something wrong with config=%s" % (

nabu/reconstruction/tests/test_halftomo.py

@@ -1,16 +1,21 @@
 import numpy as np
 import pytest
+from nabu.processing.fft_cuda import get_available_fft_implems
 from nabu.testutils import get_data, generate_tests_scenarios, compare_shifted_images
-from nabu.cuda.utils import get_cuda_context, __has_pycuda__, __has_cufft__
+from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
-from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
 from nabu.thirdparty.algotom_convert_sino import extend_sinogram
 
+__has_cufft__ = False
+if __has_pycuda__:
+    avail_fft = get_available_fft_implems()
+    __has_cufft__ = len(avail_fft) > 0
 __has_pycuda__ = __has_pycuda__ and __has_cufft__  # need both for using Cuda backprojector
-__has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
+
 
 if __has_pycuda__:
     from nabu.reconstruction.fbp import CudaBackprojector
+    from nabu.reconstruction.hbp import HierarchicalBackprojector
 if __has_pyopencl__:
     from nabu.reconstruction.fbp_opencl import OpenCLBackprojector
 
@@ -37,7 +42,7 @@ class TestHalftomo:
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
             if not (__has_pycuda__):
-                pytest.skip("Need pycuda + scikit-cuda")
+                pytest.skip("Need pycuda + scikit-cuda or vkfft")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:
@@ -99,3 +104,24 @@ class TestHalftomo:
         backprojector = self._get_backprojector(config, sino.shape, rot_center=self.rot_center, halftomo=True)
         res = backprojector.fbp(sino)
         # Just check that it runs, but no reference results. Who does this anyway ?!
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda")
+    def test_hbp_halftomo(self, config):
+        if config["backend"] == "opencl":
+            pytest.skip("No HBP available in OpenCL")
+        B = HierarchicalBackprojector(self.sino.shape, halftomo=True, rot_center=self.rot_center, padding_mode="edge")
+        res = B.fbp(self.sino)
+
+        sino_extended, rot_center_ext = extend_sinogram(self.sino, self.rot_center, apply_log=False)
+        sino_extended *= 2  # compat. with nabu normalization
+        B_extended = HierarchicalBackprojector(
+            sino_extended.shape,
+            rot_center=rot_center_ext,
+            padding_mode="edge",
+            angles=np.linspace(0, 2 * np.pi, self.sino.shape[0], True),
+        )
+        res_e = B_extended.fbp(sino_extended)
+
+        # see notes in test_halftomo_right_side()
+        metric, upper_bound = compare_shifted_images(res, res_e, return_upper_bound=True)
+        assert metric < 5, "Something wrong for halftomo with HBP"

nabu/reconstruction/tests/test_mlem.py

@@ -0,0 +1,91 @@
+import pytest
+import numpy as np
+from nabu.testutils import get_data, __do_long_tests__
+
+from nabu.cuda.utils import __has_pycuda__
+from nabu.reconstruction.mlem import MLEMReconstructor, __have_corrct__
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    datafile = get_data("sl_mlem.npz")
+    cls.data = datafile["data"]
+    cls.angles_rad = datafile["angles_rad"]
+    cls.random_u_shifts = datafile["random_u_shifts"]
+    cls.ref_rec_noshifts = datafile["ref_rec_noshifts"]
+    cls.ref_rec_shiftsu = datafile["ref_rec_shiftsu"]
+    cls.ref_rec_u_rand = datafile["ref_rec_u_rand"]
+    cls.ref_rec_shiftsv = datafile["ref_rec_shiftsv"]
+    # cls.ref_rec_v_rand = datafile["ref_rec_v_rand"]
+    cls.tol = 2e-4
+
+
+@pytest.mark.skipif(not (__has_pycuda__ and __have_corrct__), reason="Need pycuda and corrct for this test")
+@pytest.mark.usefixtures("bootstrap")
+class TestMLEM:
+    """These tests test the general MLEM reconstruction algorithm
+    and the behavior of the reconstruction with respect to horizontal shifts.
+    Only horizontal shifts are tested here because vertical shifts are handled outside
+    the reconstruction object, but in the embedding reconstruction pipeline. See FullFieldReconstructor"""
+
+    def _create_MLEM_reconstructor(self, shifts_uv=None):
+        return MLEMReconstructor(
+            self.data.shape, -self.angles_rad, shifts_uv, cor=0.0, n_iterations=10  # mind the sign
+        )
+
+    def test_simple_mlem_recons(self):
+        R = self._create_MLEM_reconstructor()
+        rec = R.reconstruct(self.data)
+        delta = np.abs(rec[:, ::-1, :] - self.ref_rec_noshifts)
+        assert np.max(delta) < self.tol
+
+    def test_mlem_recons_with_u_shifts(self):
+        shifts = np.zeros((len(self.angles_rad), 2))
+        shifts[:, 0] = -5
+        R = self._create_MLEM_reconstructor(shifts)
+        rec = R.reconstruct(self.data)
+        delta = np.abs(rec[:, ::-1] - self.ref_rec_shiftsu)
+        assert np.max(delta) < self.tol
+
+    def test_mlem_recons_with_random_u_shifts(self):
+        R = self._create_MLEM_reconstructor(self.random_u_shifts)
+        rec = R.reconstruct(self.data)
+        delta = np.abs(rec[:, ::-1] - self.ref_rec_u_rand)
+        assert np.max(delta) < self.tol
+
+    def test_mlem_recons_with_constant_v_shifts(self):
+        from nabu.preproc.shift import VerticalShift
+
+        shifts = np.zeros((len(self.angles_rad), 2))
+        shifts[:, 1] = -20
+
+        nv, n_angles, nu = self.data.shape
+        radios_movements = VerticalShift(
+            (n_angles, nv, nu), -shifts[:, 1]
+        )  # Minus sign here mimics what is  done in the pipeline.
+        tmp_in = np.swapaxes(self.data, 0, 1).copy()
+        tmp_out = np.zeros_like(tmp_in)
+        radios_movements.apply_vertical_shifts(tmp_in, list(range(n_angles)), output=tmp_out)
+        data = np.swapaxes(tmp_out, 0, 1).copy()
+
+        R = self._create_MLEM_reconstructor(shifts)
+        rec = R.reconstruct(data)
+
+        axslice = 120
+        trslice = 84
+        axslice1 = self.ref_rec_shiftsv[axslice]
+        axslice2 = rec[axslice, ::-1]
+        trslice1 = self.ref_rec_shiftsv[trslice]
+        trslice2 = rec[trslice, ::-1]
+        # delta = np.abs(rec[:, ::-1] - self.ref_rec_shiftsv)
+        delta_ax = np.abs(axslice1 - axslice2)
+        delta_tr = np.abs(trslice1 - trslice2)
+        assert max(np.max(delta_ax), np.max(delta_tr)) < self.tol
+
+    @pytest.mark.skip(reason="No valid reference reconstruction for this test.")
+    def test_mlem_recons_with_random_v_shifts(self):
+        """NOT YET IMPLEMENTED.
+        This is a temporary version due to unpexcted behavior of CorrCT/Astra to
+        compute a reference implementation. See [question on Astra's github](https://github.com/astra-toolbox/astra-toolbox/discussions/520).
+        """

nabu/reconstruction/tests/test_reconstructor.py

@@ -1,13 +1,18 @@
 import numpy as np
 import pytest
+from nabu.processing.fft_cuda import get_available_fft_implems
 from nabu.testutils import (
     get_big_data,
     __big_testdata_dir__,
-    compare_arrays,
     generate_tests_scenarios,
     __do_long_tests__,
 )
-from nabu.cuda.utils import __has_pycuda__, __has_cufft__, get_cuda_context
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+
+__has_cufft__ = False
+if __has_pycuda__:
+    avail_fft = get_available_fft_implems()
+    __has_cufft__ = len(avail_fft) > 0
 
 __has_cuda_fbp__ = __has_cufft__ and __has_pycuda__
 if __has_cuda_fbp__:
@@ -43,7 +48,7 @@ def bootstrap(request):
 )
 @pytest.mark.usefixtures("bootstrap")
 class TestReconstructor:
-    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and scikit-cuda")
+    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (scikit-cuda or vkfft)")
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_reconstructor(self, config):
         data = self.projs