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

nabu/processing/processing_base.py

@@ -88,7 +88,7 @@ class ProcessingBase:
             self.allocate_array(array_name, array_ref.shape, dtype=dtype)
             getattr(self, array_name).set(array_ref)
         else:
-            raise ValueError("Expected numpy array or pycuda array")
+            raise TypeError("Expected numpy array or pycuda array")
         return getattr(self, array_name)
 
     def get_array(self, array_name):
@@ -99,6 +99,15 @@ class ProcessingBase:
     _recover_arrays_references = recover_arrays_references
     _allocate_array = allocate_array
     _set_array = set_array
+    # --
+
+    def is_contiguous(self, arr):
+        if isinstance(arr, self.array_class):
+            return arr.flags.c_contiguous
+        elif isinstance(arr, np.ndarray):
+            return arr.flags["C_CONTIGUOUS"]
+        else:
+            raise TypeError
 
     def check_array(self, arr, expected_shape, expected_dtype="f", check_contiguous=True):
         """
@@ -108,11 +117,8 @@ class ProcessingBase:
             raise ValueError("Expected shape %s but got %s" % (str(expected_shape), str(arr.shape)))
         if arr.dtype != np.dtype(expected_dtype):
             raise ValueError("Expected data type %s but got %s" % (str(expected_dtype), str(arr.dtype)))
-        if check_contiguous:
-            if isinstance(arr, np.ndarray) and not (arr.flags["C_CONTIGUOUS"]):
-                raise ValueError("Expected C-contiguous array")
-            if isinstance(arr, self.array_class) and not arr.flags.c_contiguous:
-                raise ValueError("Expected C-contiguous array")
+        if check_contiguous and not (self.is_contiguous(arr)):
+            raise ValueError("Expected C-contiguous array")
 
     def kernel(self, *args, **kwargs):
         raise ValueError("Base class")

nabu/processing/rotation_cuda.py

@@ -1,7 +1,7 @@
 import numpy as np
 from .rotation import Rotation
 from ..utils import get_cuda_srcfile, updiv
-from ..cuda.utils import __has_pycuda__, copy_array
+from ..cuda.utils import __has_pycuda__, copy_array, check_textures_availability
 from ..cuda.processing import CudaProcessing
 
 if __has_pycuda__:
@@ -11,6 +11,8 @@ if __has_pycuda__:
 
 class CudaRotation(Rotation):
     def __init__(self, shape, angle, center=None, mode="edge", reshape=False, cuda_options=None, **sk_kwargs):
+        if not (check_textures_availability()):
+            raise RuntimeError("Need cuda textures for this class")
         if center is None:
             center = ((shape[1] - 1) / 2.0, (shape[0] - 1) / 2.0)
         super().__init__(shape, angle, center=center, mode=mode, reshape=reshape, **sk_kwargs)

nabu/processing/tests/test_fft.py

@@ -4,14 +4,13 @@ import numpy as np
 from scipy.fft import fftn, ifftn, rfftn, irfftn
 from nabu.testutils import generate_tests_scenarios, get_data, get_array_of_given_shape, __do_long_tests__
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
-from nabu.processing.fft_cuda import SKCUFFT, VKCUFFT, get_available_fft_implems
+from nabu.processing.fft_cuda import VKCUFFT, get_available_fft_implems
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
 from nabu.processing.fft_opencl import VKCLFFT, has_vkfft as has_cl_vkfft
 from nabu.processing.fft_base import is_fast_axes
 
 available_cuda_fft = get_available_fft_implems()
 __has_vkfft__ = "vkfft" in available_cuda_fft
-__has_skcuda__ = "skcuda" in available_cuda_fft
 
 
 scenarios = {
@@ -113,67 +112,6 @@ class TestFFT:
         ref = ref_ifft_func(data, axes=axes)
         return ref
 
-    @pytest.mark.skipif(
-        not (__has_skcuda__ and __has_pycuda__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
-    @pytest.mark.parametrize("config", scenarios)
-    def test_sckcuda(self, config):
-        r2c = config["r2c"]
-        shape = config["shape"]
-        precision = config["precision"]
-        ndim = len(shape)
-        if ndim == 3 and not (__do_long_tests__):
-            pytest.skip("3D FFTs are done only for long tests - use NABU_LONG_TESTS=1")
-
-        data = self._get_data_array(config)
-
-        res, cufft = self._do_fft(data, r2c, return_fft_obj=True, backend_cls=SKCUFFT)
-        ref = self._do_reference_fft(data, r2c)
-
-        tol = self.abs_tol[precision][ndim]
-        self.check_result(res, ref, config, tol, name="skcuda")
-
-        # Complex-to-complex can also be performed on real data (as in numpy.fft.fft(real_data))
-        if not (r2c):
-            res = self._do_fft(data, False, backend_cls=SKCUFFT)
-            ref = self._do_reference_fft(data, False)
-            self.check_result(res, ref, config, tol, name="skcuda")
-
-        # IFFT
-        res = cufft.ifft(cufft.output_fft).get()
-        self.check_result(res, data, config, tol, name="skcuda")
-        # Perhaps we should also check against numpy/scipy ifft,
-        # but it does not yield the good shape for R2C on odd-sized data
-
-    @pytest.mark.skipif(
-        not (__has_skcuda__ and __has_pycuda__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
-    @pytest.mark.parametrize("config", scenarios)
-    def test_skcuda_batched(self, config):
-        shape = config["shape"]
-        if len(shape) == 1:
-            return
-        elif len(shape) == 3 and not (__do_long_tests__):
-            pytest.skip("3D FFTs are done only for long tests - use NABU_LONG_TESTS=1")
-        r2c = config["r2c"]
-        tol = self.abs_tol[config["precision"]][len(shape)]
-
-        data = self._get_data_array(config)
-
-        if data.ndim == 2:
-            axes_to_test = [(0,), (1,)]
-        elif data.ndim == 3:
-            # axes_to_test = [(1, 2), (2, 1), (2,)] # See fft.py: works for C2C but not R2C ?
-            axes_to_test = [(2,)]
-
-        for axes in axes_to_test:
-            res, cufft = self._do_fft(data, r2c, axes=axes, return_fft_obj=True, backend_cls=SKCUFFT)
-            ref = self._do_reference_fft(data, r2c, axes=axes)
-            self.check_result(res, ref, config, tol, name="skcuda batched axes=%s" % (str(axes)))
-            # IFFT
-            res = cufft.ifft(cufft.output_fft).get()
-            self.check_result(res, data, config, tol, name="skcuda")
-
     @pytest.mark.parametrize("config", scenarios)
     def test_vkfft(self, config):
         backend = config["backend"]
@@ -190,7 +128,7 @@ class TestFFT:
             pytest.skip("R2C with odd-sized fast dimension is not supported in VKFFT")
 
         # FIXME - vkfft + POCL fail for R2C in one dimension
-        if config["backend"] == "opencl" and r2c and ndim == 1:
+        if config["backend"] == "opencl" and r2c and ndim == 1:  # noqa: SIM102
             if self.cl_ctx.devices[0].platform.name.strip().lower() == "portable computing language":
                 pytest.skip("Something wrong with vkfft + pocl for R2C 1D")
         # ---

nabu/processing/tests/test_fftshift.py

@@ -2,7 +2,7 @@ import numpy as np
 import pytest
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
-from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.testutils import get_data, generate_tests_scenarios
 
 if __has_pyopencl__:
     from nabu.processing.fftshift import OpenCLFFTshift

nabu/processing/tests/test_medfilt.py

@@ -34,16 +34,14 @@ def bootstrap(request):
 
 @pytest.mark.skipif(not (__has_pycuda__), reason="Need Cuda/pycuda for this test")
 @pytest.mark.usefixtures("bootstrap")
-class TestMedianFilter(object):
+class TestMedianFilter:
     @classmethod
     def allocate_numpy_arrays(cls):
-        shape = cls.data.shape
         cls.input = cls.data
         cls.input3d = np.tile(cls.input, (2, 1, 1))
 
     @classmethod
     def allocate_cuda_arrays(cls):
-        shape = cls.data.shape
         cls.d_input = garray.to_gpu(cls.input)
         cls.d_output = garray.zeros_like(cls.d_input)
         cls.d_input3d = garray.to_gpu(cls.input3d)

nabu/processing/tests/test_padding.py

@@ -108,7 +108,7 @@ class TestPadding:
             d_img.set(data)
             d_out = padding.processing.allocate_array("d_out", padding.padded_shape, dtype="f")
 
-            res = padding.pad(d_img, output=d_out)
+            padding.pad(d_img, output=d_out)
 
             ref = np.roll(np.pad(data, pad_width, mode=mode), (-pad_width[0][0], -pad_width[1][0]), axis=(0, 1))
 

nabu/processing/tests/test_roll.py

@@ -2,7 +2,7 @@ import numpy as np
 import pytest
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
-from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.testutils import get_data, generate_tests_scenarios
 from nabu.processing.roll_opencl import OpenCLRoll
 
 configs_roll = {

nabu/processing/tests/test_rotation.py

@@ -3,7 +3,7 @@ import pytest
 from nabu.testutils import generate_tests_scenarios
 from nabu.processing.rotation_cuda import Rotation
 from nabu.processing.rotation import __have__skimage__
-from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context, check_textures_availability
 
 if __have__skimage__:
     from skimage.transform import rotate
@@ -68,7 +68,9 @@ class TestRotation:
         res = R(self.image)
         self._check_result(res, config, 1e-6)
 
-    @pytest.mark.skipif(not (__has_pycuda__), reason="Need cuda rotation")
+    @pytest.mark.skipif(
+        not (__has_pycuda__) or not (check_textures_availability()), reason="Need cuda rotation (and textures)"
+    )
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_rotation(self, config):
         R = CudaRotation(

nabu/processing/unsharp_opencl.py

@@ -1,5 +1,5 @@
 try:
-    import pyopencl.array as parray
+    import pyopencl.array as parray  # noqa: F401
     from pyopencl.elementwise import ElementwiseKernel
     from ..opencl.processing import OpenCLProcessing
 

nabu/reconstruction/astra.py

@@ -0,0 +1,245 @@
+# ruff: noqa
+try:
+    import astra
+
+    __have_astra__ = True
+except ImportError:
+    __have_astra__ = False
+    astra = None
+
+
+class AstraReconstructor:
+    """
+    Base class for reconstructors based on the Astra toolbox
+    """
+
+    default_extra_options = {
+        "axis_correction": None,
+        "clip_outer_circle": False,
+        "scale_factor": None,
+        "filter_cutoff": 1.0,
+        "outer_circle_value": 0.0,
+    }
+
+    def __init__(
+        self,
+        sinos_shape,
+        angles=None,
+        volume_shape=None,
+        rot_center=None,
+        pixel_size=None,
+        padding_mode="zeros",
+        filter_name=None,
+        slice_roi=None,
+        cuda_options=None,
+        extra_options=None,
+    ):
+        self._configure_extra_options(extra_options)
+        self._init_cuda(cuda_options)
+        self._set_sino_shape(sinos_shape)
+        self._orig_prog_geom = None
+        self._init_geometry(
+            source_origin_dist,
+            origin_detector_dist,
+            pixel_size,
+            angles,
+            volume_shape,
+            rot_center,
+            relative_z_position,
+            slice_roi,
+        )
+        self._init_fdk(padding_mode, filter_name)
+        self._alg_id = None
+        self._vol_id = None
+        self._proj_id = None
+
+    def _configure_extra_options(self, extra_options):
+        self.extra_options = self.default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def _init_cuda(self, cuda_options):
+        cuda_options = cuda_options or {}
+        self.cuda = CudaProcessing(**cuda_options)
+
+    def _set_sino_shape(self, sinos_shape):
+        if len(sinos_shape) != 3:
+            raise ValueError("Expected a 3D shape")
+        self.sinos_shape = sinos_shape
+        self.n_sinos, self.n_angles, self.prj_width = sinos_shape
+
+    def _set_pixel_size(self, pixel_size):
+        if pixel_size is None:
+            det_spacing_y = det_spacing_x = 1
+        elif np.iterable(pixel_size):
+            det_spacing_y, det_spacing_x = pixel_size
+        else:
+            # assuming scalar
+            det_spacing_y = det_spacing_x = pixel_size
+        self._det_spacing_y = det_spacing_y
+        self._det_spacing_x = det_spacing_x
+
+    def _set_slice_roi(self, slice_roi):
+        self.slice_roi = slice_roi
+        self._vol_geom_n_x = self.n_x
+        self._vol_geom_n_y = self.n_y
+        self._crop_data = True
+        if slice_roi is None:
+            return
+        start_x, end_x, start_y, end_y = slice_roi
+        if roi_is_centered(self.volume_shape[1:], (slice(start_y, end_y), slice(start_x, end_x))):
+            # Astra can only reconstruct subregion centered around the origin
+            self._vol_geom_n_x = self.n_x - start_x * 2
+            self._vol_geom_n_y = self.n_y - start_y * 2
+        else:
+            raise NotImplementedError(
+                "Astra supports only slice_roi centered around origin (got slice_roi=%s with n_x=%d, n_y=%d)"
+                % (str(slice_roi), self.n_x, self.n_y)
+            )
+
+    def _init_geometry(
+        self,
+        source_origin_dist,
+        origin_detector_dist,
+        pixel_size,
+        angles,
+        volume_shape,
+        rot_center,
+        relative_z_position,
+        slice_roi,
+    ):
+        if angles is None:
+            self.angles = np.linspace(0, 2 * np.pi, self.n_angles, endpoint=True)
+        else:
+            self.angles = angles
+        if volume_shape is None:
+            volume_shape = (self.sinos_shape[0], self.sinos_shape[2], self.sinos_shape[2])
+        self.volume_shape = volume_shape
+        self.n_z, self.n_y, self.n_x = self.volume_shape
+        self.source_origin_dist = source_origin_dist
+        self.origin_detector_dist = origin_detector_dist
+        self.magnification = 1 + origin_detector_dist / source_origin_dist
+        self._set_slice_roi(slice_roi)
+        self.vol_geom = astra.create_vol_geom(self._vol_geom_n_y, self._vol_geom_n_x, self.n_z)
+        self.vol_shape = astra.geom_size(self.vol_geom)
+        self._cor_shift = 0.0
+        self.rot_center = rot_center
+        if rot_center is not None:
+            self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
+        self._set_pixel_size(pixel_size)
+        self._axis_corrections = self.extra_options.get("axis_correction", None)
+        self._create_astra_proj_geometry(relative_z_position)
+
+    def _create_astra_proj_geometry(self, relative_z_position):
+        # This object has to be re-created each time, because once the modifications below are done,
+        # it is no more a "cone" geometry but a "cone_vec" geometry, and cannot be updated subsequently
+        # (see astra/functions.py:271)
+        self.proj_geom = astra.create_proj_geom(
+            "cone",
+            self._det_spacing_x,
+            self._det_spacing_y,
+            self.n_sinos,
+            self.prj_width,
+            self.angles,
+            self.source_origin_dist,
+            self.origin_detector_dist,
+        )
+        self.relative_z_position = relative_z_position or 0.0
+        # This will turn the geometry of type "cone" into a geometry of type "cone_vec"
+        if self._orig_prog_geom is None:
+            self._orig_prog_geom = self.proj_geom
+        self.proj_geom = astra.geom_postalignment(self.proj_geom, (self._cor_shift, 0))
+        # (src, detector_center, u, v) = (srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ)
+        vecs = self.proj_geom["Vectors"]
+
+        # To adapt the center of rotation:
+        # dX = cor_shift * cos(theta) - origin_detector_dist * sin(theta)
+        # dY = origin_detector_dist * cos(theta) + cor_shift * sin(theta)
+        if self._axis_corrections is not None:
+            # should we check that dX and dY match the above formulas ?
+            cor_shifts = self._cor_shift + self._axis_corrections
+            vecs[:, 3] = cor_shifts * np.cos(self.angles) - self.origin_detector_dist * np.sin(self.angles)
+            vecs[:, 4] = self.origin_detector_dist * np.cos(self.angles) + cor_shifts * np.sin(self.angles)
+
+        # To adapt the z position:
+        # Component 2 of vecs is the z coordinate of the source, component 5 is the z component of the detector position
+        # We need to re-create the same inclination of the cone beam, thus we need to keep the inclination of the two z positions.
+        # The detector is centered on the rotation axis, thus moving it up or down, just moves it out of the reconstruction volume.
+        # We can bring back the detector in the correct volume position, by applying a rigid translation of both the detector and the source.
+        # The translation is exactly the amount that brought the detector up or down, but in the opposite direction.
+        vecs[:, 2] = -self.relative_z_position
+
+    def _set_output(self, volume):
+        if volume is not None:
+            expected_shape = self.vol_shape  # if not (self._crop_data) else self._output_cropped_shape
+            self.cuda.check_array(volume, expected_shape)
+            self.cuda.set_array("output", volume)
+        if volume is None:
+            self.cuda.allocate_array("output", self.vol_shape)
+        d_volume = self.cuda.get_array("output")
+        z, y, x = d_volume.shape
+        self._vol_link = astra.data3d.GPULink(d_volume.ptr, x, y, z, d_volume.strides[-2])
+        self._vol_id = astra.data3d.link("-vol", self.vol_geom, self._vol_link)
+
+    def _set_input(self, sinos):
+        self.cuda.check_array(sinos, self.sinos_shape)
+        self.cuda.set_array("sinos", sinos)  # self.cuda.sinos is now a GPU array
+        # TODO don't create new link/proj_id if ptr is the same ?
+        # But it seems Astra modifies the input sinogram while doing FDK, so this might be not relevant
+        d_sinos = self.cuda.get_array("sinos")
+
+        # self._proj_data_link = astra.data3d.GPULink(d_sinos.ptr, self.prj_width, self.n_angles, self.n_z, sinos.strides[-2])
+        self._proj_data_link = astra.data3d.GPULink(
+            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, d_sinos.strides[-2]
+        )
+        self._proj_id = astra.data3d.link("-sino", self.proj_geom, self._proj_data_link)
+
+    def _preprocess_data(self):
+        d_sinos = self.cuda.sinos
+        for i in range(d_sinos.shape[0]):
+            self.sino_filter.filter_sino(d_sinos[i], output=d_sinos[i])
+
+    def _update_reconstruction(self):
+        cfg = astra.astra_dict("BP3D_CUDA")
+        cfg["ReconstructionDataId"] = self._vol_id
+        cfg["ProjectionDataId"] = self._proj_id
+        if self._alg_id is not None:
+            astra.algorithm.delete(self._alg_id)
+        self._alg_id = astra.algorithm.create(cfg)
+
+    def reconstruct(self, sinos, output=None, relative_z_position=None):
+        """
+        sinos: numpy.ndarray or pycuda.gpuarray
+            Sinograms, with shape (n_sinograms, n_angles, width)
+        output: pycuda.gpuarray, optional
+            Output array. If not provided, a new numpy array is returned
+        relative_z_position: int, optional
+            Position of the central slice of the slab, with respect to the full stack of slices.
+            By default it is set to zero, meaning that the current slab is assumed in the middle of the stack
+        """
+        self._create_astra_proj_geometry(relative_z_position)
+        self._set_input(sinos)
+        self._set_output(output)
+        self._preprocess_data()
+        self._update_reconstruction()
+        astra.algorithm.run(self._alg_id)
+        #
+        # NB: Could also be done with
+        # from astra.experimental import direct_BP3D
+        # projector_id = astra.create_projector("cuda3d", self.proj_geom, self.vol_geom, options=None)
+        # direct_BP3D(projector_id, self._vol_link, self._proj_data_link)
+        #
+        result = self.cuda.get_array("output")
+        if output is None:
+            result = result.get()
+        if self.extra_options.get("scale_factor", None) is not None:
+            result *= np.float32(self.extra_options["scale_factor"])  # in-place for pycuda
+        self.cuda.recover_arrays_references(["sinos", "output"])
+        return result
+
+    def __del__(self):
+        if getattr(self, "_alg_id", None) is not None:
+            astra.algorithm.delete(self._alg_id)
+        if getattr(self, "_vol_id", None) is not None:
+            astra.data3d.delete(self._vol_id)
+        if getattr(self, "_proj_id", None) is not None:
+            astra.data3d.delete(self._proj_id)

nabu/reconstruction/cone.py

@@ -31,6 +31,7 @@ class ConebeamReconstructor:
         "outer_circle_value": 0.0,
         # "use_astra_fdk": True,
         "use_astra_fdk": False,
+        "crop_filtered_data": True,
     }
 
     def __init__(
@@ -131,6 +132,7 @@ class ConebeamReconstructor:
         self._init_cuda(cuda_options)
         self._set_sino_shape(sinos_shape)
         self._orig_prog_geom = None
+        self._use_astra_fdk = bool(self.extra_options.get("use_astra_fdk", True))
         self._init_geometry(
             source_origin_dist,
             origin_detector_dist,
@@ -149,6 +151,7 @@ class ConebeamReconstructor:
     def _configure_extra_options(self, extra_options):
         self.extra_options = self.default_extra_options.copy()
         self.extra_options.update(extra_options or {})
+        self._crop_filtered_data = self.extra_options.get("crop_filtered_data", True)
 
     def _init_cuda(self, cuda_options):
         cuda_options = cuda_options or {}
@@ -162,7 +165,6 @@ class ConebeamReconstructor:
 
     def _init_fdk(self, padding_mode, filter_name):
         self.padding_mode = padding_mode
-        self._use_astra_fdk = bool(self.extra_options.get("use_astra_fdk", True))
         if self._use_astra_fdk and padding_mode not in ["zeros", "constant", None, "none"]:
             self._use_astra_fdk = False
             _logger.warning("padding_mode was set to %s, cannot use native astra FDK" % padding_mode)
@@ -172,6 +174,7 @@ class ConebeamReconstructor:
             self.sinos_shape[1:],
             filter_name=filter_name,
             padding_mode=self.padding_mode,
+            crop_filtered_data=self.extra_options.get("crop_filtered_data", True),
             # TODO (?) configure FFT backend
             extra_options={"cutoff": self.extra_options.get("filter_cutoff", 1.0)},
             cuda_options={"ctx": self.cuda.ctx},
@@ -248,12 +251,18 @@ class ConebeamReconstructor:
         # This object has to be re-created each time, because once the modifications below are done,
         # it is no more a "cone" geometry but a "cone_vec" geometry, and cannot be updated subsequently
         # (see astra/functions.py:271)
+
+        if not (self._crop_filtered_data) and hasattr(self, "sino_filter"):
+            prj_width = self.sino_filter.sino_padded_shape[-1]
+        else:
+            prj_width = self.prj_width
+
         self.proj_geom = astra.create_proj_geom(
             "cone",
             self._det_spacing_x,
             self._det_spacing_y,
             self.n_sinos,
-            self.prj_width,
+            prj_width,
             self.angles,
             self.source_origin_dist,
             self.origin_detector_dist,
@@ -283,6 +292,11 @@ class ConebeamReconstructor:
         # The translation is exactly the amount that brought the detector up or down, but in the opposite direction.
         vecs[:, 2] = -self.relative_z_position
 
+    def reset_rot_center(self, rot_center):
+        self.rot_center = rot_center
+        self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
+        self._create_astra_proj_geometry(self.relative_z_position)
+
     def _set_output(self, volume):
         if volume is not None:
             expected_shape = self.vol_shape  # if not (self._crop_data) else self._output_cropped_shape
@@ -296,15 +310,25 @@ class ConebeamReconstructor:
         self._vol_id = astra.data3d.link("-vol", self.vol_geom, self._vol_link)
 
     def _set_input(self, sinos):
-        self.cuda.check_array(sinos, self.sinos_shape)
-        self.cuda.set_array("sinos", sinos)  # self.cuda.sinos is now a GPU array
+        self.cuda.check_array(sinos, self.sinos_shape, check_contiguous=False)
         # TODO don't create new link/proj_id if ptr is the same ?
         # But it seems Astra modifies the input sinogram while doing FDK, so this might be not relevant
-        d_sinos = self.cuda.get_array("sinos")
-
-        # self._proj_data_link = astra.data3d.GPULink(d_sinos.ptr, self.prj_width, self.n_angles, self.n_z, sinos.strides[-2])
+        d_sinos = self.cuda.set_array("sinos", sinos)  # self.cuda.sinos is now a GPU array
+
+        self._reallocate_sinos = False
+        if not (self.cuda.is_contiguous(d_sinos)) or not (self._crop_filtered_data):
+            self._reallocate_sinos = True
+            if self._crop_filtered_data:
+                sinos_shape = self.sinos_shape
+            # Sometimes, the user does not want to crop data after filtering
+            # In this case, the backprojector input should be directly the filtered-but-uncropped data.
+            # For cone-beam reconstruction, the FDK pre-weighting takes place on input sinogram (not filtered yet),
+            # then filter, then 3D backprojection the un-cropped data.
+            else:
+                sinos_shape = (self.n_z,) + self.sino_filter.sino_padded_shape
+            d_sinos = self.cuda.allocate_array("sinos_contig", sinos_shape)
         self._proj_data_link = astra.data3d.GPULink(
-            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, d_sinos.strides[-2]
+            d_sinos.ptr, d_sinos.shape[-1], self.n_angles, self.n_sinos, d_sinos.strides[-2]
         )
         self._proj_id = astra.data3d.link("-sino", self.proj_geom, self._proj_data_link)
 
@@ -315,8 +339,12 @@ class ConebeamReconstructor:
         fdk_preweighting(
             d_sinos, self._orig_prog_geom, relative_z_position=self.relative_z_position, cor_shift=self._cor_shift
         )
+        d_sinos_filtered = d_sinos
+        if self._reallocate_sinos:
+            d_sinos_filtered = self.cuda.sinos_contig
+
         for i in range(d_sinos.shape[0]):
-            self.sino_filter.filter_sino(d_sinos[i], output=d_sinos[i])
+            self.sino_filter.filter_sino(d_sinos[i], output=d_sinos_filtered[i])
 
     def _update_reconstruction(self):
         if self._use_astra_fdk:
@@ -385,11 +413,13 @@ def roi_is_centered(shape, slice_):
 
 
 def fdk_preweighting(d_sinos, proj_geom, relative_z_position=0.0, cor_shift=0.0):
+    discontiguous_sinograms = not (d_sinos.flags.c_contiguous)
 
     preweight_kernel = CudaKernel(
         "devFDK_preweight",
         filename=get_cuda_srcfile("cone.cu"),
         signature="Piiifffffiii",
+        options=["-DRADIOS_LAYOUT"] if discontiguous_sinograms else None,
     )
 
     n_z, n_angles, n_x = d_sinos.shape

nabu/reconstruction/fbp.py

@@ -56,6 +56,13 @@ class CudaBackprojector(BackprojectorBase):
         if self._use_textures:
             self.texref_proj = self.gpu_projector.module.get_texref(self._kernel_options["texture_name"])
             self.texref_proj.set_filter_mode(cuda.filter_mode.LINEAR)
+            # Set boundary extension to "zero", i.e array[n] = 0 for n < 0 and n >= array.size
+            # address_mode.BORDER : extension with zeros
+            # address_mode.CLAMP : extension with edges
+            # pycuda does not tell if first argument "dim" is 0-based ?
+            self.texref_proj.set_address_mode(0, cuda.address_mode.BORDER)
+            self.texref_proj.set_address_mode(1, cuda.address_mode.BORDER)
+            self.texref_proj.set_address_mode(2, cuda.address_mode.BORDER)
             self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [self.texref_proj])
             # Bind texture
             self._d_sino_cua = cuda.np_to_array(np.zeros(self.sino_shape, "f"), "C")
@@ -79,6 +86,13 @@ class CudaBackprojector(BackprojectorBase):
             self.sino_mult = CudaSinoMult(self.sino_shape, self.rot_center, ctx=self._processing.ctx)
         self._prepare_textures()  # has to be done after compilation for Cuda (to bind texture to built kernel)
 
+    def _get_filter_init_extra_options(self):
+        return {
+            "cuda_options": {
+                "ctx": self._processing.ctx,
+            },
+        }
+
     def _transfer_to_texture(self, sino, do_checks=True):
         if do_checks and not (sino.flags.c_contiguous):
             raise ValueError("Expected C-Contiguous array")