nabu 2024.2.13__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/reconstruction/sinogram_cuda.py

@@ -212,7 +212,6 @@ class CudaSinoNormalization(SinoNormalization):
         else:
             # This kernel seems to have an issue on arrays that are not C-contiguous.
             # We have to process image per image.
-            nz = np.int32(1)
             nthreadsperblock = (1, 32, 1)  # TODO tune
             nblocks = (1, int(updiv(self.n_angles, nthreadsperblock[1])), 1)
             for i in range(sinos.shape[0]):

nabu/reconstruction/tests/test_cone.py

@@ -460,6 +460,41 @@ class TestCone:
                 ConebeamReconstructor(*reconstructor_args, **{**reconstructor_kwargs_base, **reconstructor_kwargs_nabu})
                 assert "cannot use native astra FDK" in caplog.text
 
+    def test_reconstruct_noncontiguous_data(self):
+        n_z = 206
+        n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 50
+
+        volume, cone_data = generate_hollow_cube_cone_sinograms(
+            vol_shape=(n_z, n_y, n_x),
+            n_angles=n_a,
+            src_orig_dist=src_orig_dist,
+            orig_det_dist=orig_det_dist,
+            apply_filter=False,
+            rot_center_shift=10,
+        )
+        cone_reconstructor = ConebeamReconstructor(
+            cone_data.shape,
+            src_orig_dist,
+            orig_det_dist,
+            volume_shape=volume.shape,
+            rot_center=(n_x - 1) / 2 + 10,
+            cuda_options={"ctx": self.ctx},
+            extra_options={"use_astra_fdk": False},
+        )
+        ref = cone_reconstructor.reconstruct(cone_data)
+
+        radios = cone_reconstructor.cuda.allocate_array("_radios", (n_a, n_z, n_x))
+        for i in range(n_a):
+            radios[i] = cone_data[:, i, :]
+
+        sinos_discontig = radios.transpose(axes=(1, 0, 2))
+        assert cone_reconstructor.cuda.is_contiguous(sinos_discontig) is False
+        res = cone_reconstructor.reconstruct(sinos_discontig)
+        assert np.allclose(res, ref), "Reconstructing non-contiguous data failed"
+
 
 def generate_hollow_cube_cone_sinograms(
     vol_shape,
@@ -476,13 +511,13 @@ def generate_hollow_cube_cone_sinograms(
     vol_geom = astra.create_vol_geom(n_y, n_x, n_z)
 
     prj_width = prj_width or n_x
-    prj_height = n_z
+    # prj_height = n_z
     angles = np.linspace(0, 2 * np.pi, n_angles, True)
 
     proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, n_z, prj_width, angles, src_orig_dist, orig_det_dist)
     if rot_center_shift is not None:
         proj_geom = astra.geom_postalignment(proj_geom, (-rot_center_shift, 0))
-    magnification = 1 + orig_det_dist / src_orig_dist
+    # magnification = 1 + orig_det_dist / src_orig_dist
 
     # hollow cube
     cube = np.zeros(astra.geom_size(vol_geom), dtype="f")

nabu/reconstruction/tests/test_deringer.py

@@ -38,7 +38,7 @@ if __do_long_tests__:
             "sigma": [1.0, 2.0],
             "wname": ["db15", "haar", "rbio4.4"],
             "padding": [None, (100, 100), (50, 71)],
-            "fft_implem": ["skcuda", "vkfft"],
+            "fft_implem": ["vkfft"],
         }
     )
 
@@ -107,7 +107,7 @@ class TestDeringer:
 
     @pytest.mark.skipif(
         not (__has_cuda_deringer__) or munchetal_filter is None,
-        reason="Need pycuda, pycudwt and (scikit-cuda or pyvkfft) for this test",
+        reason="Need pycuda, pycudwt and (cupy? or pyvkfft) for this test",
     )
     @pytest.mark.parametrize("config", fw_scenarios)
     def test_cuda_munch_deringer(self, config):
@@ -139,9 +139,9 @@ class TestDeringer:
     )
     def test_vo_deringer(self):
         deringer = VoDeringer(self.sino.shape)
-        sino_deringed = deringer.remove_rings_sinogram(self.sino)
+        sino_deringed = deringer.remove_rings_sinogram(self.sino)  # noqa: F841
         sinos = np.tile(self.sino, (10, 1, 1))
-        sinos_deringed = deringer.remove_rings_sinograms(sinos)
+        sinos_deringed = deringer.remove_rings_sinograms(sinos)  # noqa: F841
         # TODO check result. The generated test sinogram is "too synthetic" for this kind of deringer
 
     @pytest.mark.skipif(

nabu/reconstruction/tests/test_fbp.py

@@ -7,10 +7,10 @@ from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
 
-from nabu.processing.fft_cuda import has_skcuda, has_vkfft as has_vkfft_cu
+from nabu.processing.fft_cuda import has_vkfft as has_vkfft_cu
 from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
 
-__has_pycuda__ = __has_pycuda__ and (has_skcuda() or has_vkfft_cu())
+__has_pycuda__ = __has_pycuda__ and has_vkfft_cu()
 __has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
 
 if __has_pycuda__:
@@ -40,7 +40,7 @@ def bootstrap(request):
     # always use contiguous arrays
     cls.sino_511 = np.ascontiguousarray(cls.sino_512[:, :-1])
     # Could be set to 5.0e-2 when using textures. When not using textures, interpolation slightly differs
-    cls.tol = 5.1e-2
+    cls.tol = 2e-2  # 5.1e-2
 
     if __has_pycuda__:
         cls.cuda_ctx = get_cuda_context(cleanup_at_exit=False)
@@ -62,7 +62,7 @@ class TestFBP:
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
             if not (__has_pycuda__):
-                pytest.skip("Need pycuda + (scikit-cuda or pyvkfft)")
+                pytest.skip("Need pycuda + (cupy? or pyvkfft)")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:
@@ -98,10 +98,14 @@ class TestFBP:
         B = self._get_backprojector(config, (500, 512))
         res = self.apply_fbp(config, B, self.sino_512)
 
-        delta_clipped = clip_to_inner_circle(res - self.ref_512)
-        err_max = np.max(np.abs(delta_clipped))
+        diff = res - self.ref_512
+        tol = self.tol
+        if not (B._use_textures):
+            diff = clip_to_inner_circle(diff)
+            tol = 5.1e-2
+        err_max = np.max(np.abs(diff))
 
-        assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
+        assert err_max < tol, "Something wrong with config=%s" % (str(config))
 
     @pytest.mark.parametrize("config", scenarios)
     def test_fbp_511(self, config):
@@ -112,10 +116,29 @@ class TestFBP:
         res = self.apply_fbp(config, B, self.sino_511)
         ref = self.ref_512[:-1, :-1]
 
-        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))
+        diff = clip_to_inner_circle(res - ref)
+        err_max = np.max(np.abs(diff))
+        tol = self.tol
+        if not (B._use_textures):
+            tol = 5.1e-2
+
+        assert err_max < tol, "Something wrong with config=%s" % (str(config))
+
+        # Cropping the singoram to sino[:, :-1]  gives a reconstruction
+        # that is not fully equivalent to rec512[:-1, :-1]  in the upper half of the image, outside FoV.
+        # However, nabu Backprojector gives the same results as astra
+        # Probably we should check this instead:
+
+        # B = self._get_backprojector(config, (500, 511), rot_center=255.5, extra_options={"centered_axis": True})
+        # res = self.apply_fbp(config, B, self.sino_511)
+        # import astra
+        # proj_geom = astra.create_proj_geom('parallel', 1, 511, B.angles)
+        # proj_geom = astra.geom_postalignment(proj_geom, - 0.5)
+        # vol_geom = astra.create_vol_geom(511, 511)
+        # proj_id = astra.create_projector("cuda", proj_geom, vol_geom)
+        # ref = astra.create_reconstruction("FBP_CUDA", proj_id, self.sino_511, proj_id)[1]
+        # err_max = np.max(np.abs(res - ref))
+        # assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
 
     @pytest.mark.parametrize("config", scenarios)
     def test_fbp_roi(self, config):
@@ -194,8 +217,7 @@ class TestFBP:
             )
             res_noclip = B0.fbp(sino)
             ref = clip_to_inner_circle(res_noclip, radius_factor=1)
-            abs_diff = np.abs(res - ref)
-            err_max = np.max(abs_diff)
+            err_max = np.max(np.abs(res - ref))
             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
@@ -223,7 +245,6 @@ class TestFBP:
         ref = B0.fbp(self.sino_512)
 
         # Check that "centered_axis" worked
-
         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
@@ -262,7 +283,7 @@ class TestFBP:
         # Need to translate the axis a little bit, because of non-centered differentiation.
         # prepend -> +0.5 ; append -> -0.5
         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)
+        rec = self.apply_fbp(config, B, sino_diff)  # noqa: F841
         # Looks good, but all frequencies are not recovered. Use a metric like SSIM or FRC ?
 
 

nabu/reconstruction/tests/test_filtering.py

@@ -14,11 +14,13 @@ if __has_pyopencl__:
     from nabu.opencl.processing import OpenCLProcessing
     from nabu.reconstruction.filtering_opencl import OpenCLSinoFilter, __has_vkfft__
 
-filters_to_test = ["ramlak", "shepp-logan", "tukey"]
+filters_to_test = ["ramlak", "shepp-logan"]
 padding_modes_to_test = ["constant", "edge"]
+crop_filtered_data = [True]
 if __do_long_tests__:
-    filters_to_test = ["ramlak", "shepp-logan", "cosine", "hamming", "hann", "tukey", "lanczos"]
+    filters_to_test.extend(["cosine", "hamming", "hann", "lanczos"])
     padding_modes_to_test = SinoFilter.available_padding_modes
+    crop_filtered_data = [True, False]
 
 tests_scenarios = generate_tests_scenarios(
     {
@@ -26,6 +28,7 @@ tests_scenarios = generate_tests_scenarios(
         "padding_mode": padding_modes_to_test,
         "output_provided": [True, False],
         "truncated_sino": [True, False],
+        "crop_filtered_data": crop_filtered_data,
     }
 )
 
@@ -61,9 +64,10 @@ class TestSinoFilter:
             sino.shape,
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
         if config["output_provided"]:
-            output = np.zeros_like(sino)
+            output = np.zeros(sino_filter.output_shape, "f")
         else:
             output = None
         res = sino_filter.filter_sino(sino, output=output)
@@ -71,7 +75,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            sino,
+            sino_filter.dwidth_padded,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res, ref, atol=4e-6)
@@ -86,10 +94,11 @@ class TestSinoFilter:
             sino.shape,
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
             cuda_options={"ctx": self.ctx_cuda},
         )
         if config["output_provided"]:
-            output = garray.zeros(sino.shape, "f")
+            output = garray.zeros(sino_filter.output_shape, "f")
         else:
             output = None
         res = sino_filter.filter_sino(sino, output=output)
@@ -97,7 +106,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            h_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"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res.get(), ref, atol=6e-5), "test_cuda_filter: something wrong with config=%s" % (
@@ -109,6 +122,8 @@ class TestSinoFilter:
     )
     @pytest.mark.parametrize("config", tests_scenarios)
     def test_opencl_filter(self, config):
+        if not (config["crop_filtered_data"]):
+            pytest.skip("crop_filtered_data=False is not supported for OpenCL backend yet")
         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
 
@@ -117,6 +132,7 @@ class TestSinoFilter:
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
             opencl_options={"ctx": self.cl.ctx},
+            crop_filtered_data=config["crop_filtered_data"],
         )
         if config["output_provided"]:
             output = parray.zeros(self.cl.queue, sino.shape, "f")
@@ -127,7 +143,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            h_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"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res.get(), ref, atol=6e-5), "test_opencl_filter: something wrong with config=%s" % (

nabu/reconstruction/tests/test_halftomo.py

@@ -42,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 or vkfft")
+                pytest.skip("Need pycuda + cupy? or vkfft")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:
@@ -99,10 +99,36 @@ class TestHalftomo:
         rot_center = sino.shape[-1] - 1 - self.rot_center
         return self.test_halftomo_right_side(config, sino=sino, rot_center=rot_center)
 
+    def test_halftomo_plain_backprojection(self, config):
+        backprojector = self._get_backprojector(
+            config,
+            self.sino.shape,
+            rot_center=self.rot_center,
+            halftomo=True,
+            padding_mode="edges",
+            extra_options={"centered_axis": True},
+        )
+        d_sino_filtered = backprojector.sino_filter.filter_sino(self.sino)  # device array
+        h_sino_filtered = d_sino_filtered.get()
+        reference_fbp = backprojector.fbp(self.sino)
+
+        def _check(rec, array_type):
+            assert (
+                np.max(np.abs(rec - reference_fbp)) < 1e-7
+            ), "Something wrong with halftomo backproj using %s array and configuration %s" % (array_type, str(config))
+
+        # Test with device array
+        rec_from_already_filtered_sino = backprojector.backproj(d_sino_filtered)
+        _check(rec_from_already_filtered_sino, "device")
+
+        # Test with numpy array
+        rec_from_already_filtered_sino = backprojector.backproj(h_sino_filtered)
+        _check(rec_from_already_filtered_sino, "numpy")
+
     def test_halftomo_cor_outside_fov(self, config):
         sino = np.ascontiguousarray(self.sino[:, : self.sino.shape[-1] // 2])
         backprojector = self._get_backprojector(config, sino.shape, rot_center=self.rot_center, halftomo=True)
-        res = backprojector.fbp(sino)
+        res = backprojector.fbp(sino)  # noqa: F841
         # Just check that it runs, but no reference results. Who does this anyway ?!
 
     @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda")

nabu/reconstruction/tests/test_mlem.py

@@ -1,6 +1,6 @@
 import pytest
 import numpy as np
-from nabu.testutils import get_data, __do_long_tests__
+from nabu.testutils import get_data
 
 from nabu.cuda.utils import __has_pycuda__
 from nabu.reconstruction.mlem import MLEMReconstructor, __have_corrct__
@@ -9,83 +9,113 @@ 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"]
+    datafile = get_data("test_mlem.npz")
+    cls.data_wvu = datafile["data_wvu"]
     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
+    cls.pixel_size_cm = datafile["pixel_size"] * 1e4  # pixel_size originally in um
+    cls.true_cor = datafile["true_cor"]
+    cls.mlem_cor_None_nosh = datafile["mlem_cor_None_nosh"]
+    cls.mlem_cor_truecor_nosh = datafile["mlem_cor_truecor_nosh"]
+    cls.mlem_cor_truecor_shifts_v0 = datafile["mlem_cor_truecor_shifts_v0"]
+    cls.shifts_uv_v0 = datafile["shifts_uv_v0"]
+    cls.shifts_uv = datafile["shifts_uv"]
+
+    cls.tol = 1.3e-4
 
 
 @pytest.mark.skipif(not (__has_pycuda__ and __have_corrct__), reason="Need pycuda and corrct for this test")
 @pytest.mark.usefixtures("bootstrap")
-class TestMLEM:
+class TestMLEMReconstructor:
     """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"""
+    the reconstruction object, but in the embedding reconstruction pipeline. See FullFieldReconstructor
+    It is compared against a reference reconstruction generated with the `rec_mlem` function
+    defined in the `generate_test_data.py` script.
+    """
+
+    def _rec_mlem(self, cor, shifts_uv, data_wvu, angles_rad):
+        n_angles, n_z, n_x = data_wvu.shape
 
-    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
+        mlem = MLEMReconstructor(
+            (n_z, n_angles, n_x),
+            angles_rad,
+            shifts_uv=shifts_uv,
+            cor=cor,
+            n_iterations=50,
+            extra_options={"centered_axis": True, "clip_outer_circle": True, "scale_factor": 1 / self.pixel_size_cm},
         )
+        rec_mlem = mlem.reconstruct(data_wvu.swapaxes(0, 1))
+        return rec_mlem
 
-    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)
+    def test_simple_mlem_recons_cor_None_nosh(self):
+        slice_index = 25
+        rec = self._rec_mlem(None, None, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_None_nosh)
         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_simple_mlem_recons_cor_truecor_nosh(self):
+        slice_index = 25
+        rec = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_truecor_nosh)
+        assert np.max(delta) < 2.6e-4
 
-    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_compare_with_fbp(self):
+        from nabu.reconstruction.fbp import Backprojector
+
+        def _rec_fbp(cor, shifts_uv, data_wvu, angles_rad):
+            n_angles, n_z, n_x = data_wvu.shape
 
-    def test_mlem_recons_with_constant_v_shifts(self):
-        from nabu.preproc.shift import VerticalShift
+            if shifts_uv is None:
+                fbp = Backprojector(
+                    (n_angles, n_x),
+                    angles=angles_rad,
+                    rot_center=cor,
+                    halftomo=False,
+                    padding_mode="edges",
+                    extra_options={
+                        "centered_axis": True,
+                        "clip_outer_circle": True,
+                        "scale_factor": 1 / self.pixel_size_cm,
+                    },
+                )
+            else:
+                fbp = Backprojector(
+                    (n_angles, n_x),
+                    angles=angles_rad,
+                    rot_center=cor,
+                    halftomo=False,
+                    padding_mode="edges",
+                    extra_options={
+                        "centered_axis": True,
+                        "clip_outer_circle": True,
+                        "scale_factor": 1 / self.pixel_size_cm,  # convert um to cm
+                        "axis_correction": shifts_uv[:, 0],
+                    },
+                )
 
+            rec_fbp = np.zeros((n_z, n_x, n_x), "f")
+            for i in range(n_z):
+                rec_fbp[i] = fbp.fbp(data_wvu[:, i])
+
+            return rec_fbp
+
+        fbp = _rec_fbp(self.true_cor, None, self.data_wvu, self.angles_rad)[25]
+        mlem = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)[25]
+        delta = np.abs(fbp - mlem)
+        assert (
+            np.max(delta) < 400
+        )  # These two should not be really equal. But the test should test that both algo FBP and MLEM behave similarly.
+
+    def test_mlem_zeroshifts_equal_noshifts(self):
         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).
-        """
+        rec_nosh = self._rec_mlem(self.true_cor, None, self.data_wvu, self.angles_rad)
+        rec_zerosh = self._rec_mlem(self.true_cor, shifts, self.data_wvu, self.angles_rad)
+        delta = np.abs(rec_nosh - rec_zerosh)
+        assert np.max(delta) < self.tol
+
+    def test_mlem_recons_with_u_shifts(self):
+        slice_index = 25
+        rec = self._rec_mlem(self.true_cor, self.shifts_uv_v0, self.data_wvu, self.angles_rad)[slice_index]
+        delta = np.abs(rec - self.mlem_cor_truecor_shifts_v0)
+        assert np.max(delta) < self.tol

nabu/reconstruction/tests/test_projector.py

@@ -3,14 +3,17 @@ import pytest
 from nabu.testutils import get_data
 from nabu.cuda.utils import __has_pycuda__
 
+textures_available = False
 if __has_pycuda__:
     import pycuda.gpuarray as garray
 
     # from pycuda.cumath import fabs
     from pycuda.elementwise import ElementwiseKernel
-    from nabu.cuda.utils import get_cuda_context
+    from nabu.cuda.utils import get_cuda_context, check_textures_availability
     from nabu.reconstruction.projection import Projector
     from nabu.reconstruction.fbp import Backprojector
+
+    textures_available = check_textures_availability()
 try:
     import astra
 
@@ -30,6 +33,7 @@ def bootstrap(request):
         cls.ctx = get_cuda_context()
 
 
+@pytest.mark.skipif(not (textures_available), reason="Textures not supported")
 @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for this test")
 @pytest.mark.usefixtures("bootstrap")
 class TestProjection:
@@ -63,7 +67,8 @@ class TestProjection:
     def test_odd_size(self):
         image = self.image[:511, :]
         P = Projector(image.shape, self.n_angles - 1)
-        res = P(image)
+        res = P(image)  # noqa: F841
+        # TODO check
 
     @pytest.mark.skipif(not (__has_astra__), reason="Need astra-toolbox for this test")
     def test_against_astra(self):

nabu/reconstruction/tests/test_reconstructor.py

@@ -48,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 or vkfft)")
+    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (cupy? or vkfft)")
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_reconstructor(self, config):
         data = self.projs

nabu/reconstruction/tests/test_sino_normalization.py

@@ -1,4 +1,3 @@
-import os.path as path
 import numpy as np
 import pytest
 from nabu.testutils import get_data