nabu 2025.1.0.dev5__py3-none-any.whl → 2025.1.0.dev12__py3-none-any.whl

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,
@@ -296,15 +305,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 +334,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 +408,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")

nabu/reconstruction/fbp_base.py

@@ -1,3 +1,4 @@
+import warnings
 import numpy as np
 from ..utils import updiv, nextpow2, convert_index, deprecation_warning
 from ..processing.processing_base import ProcessingBase
@@ -22,6 +23,7 @@ class BackprojectorBase:
         "scale_factor": None,
         "filter_cutoff": 1.0,
         "outer_circle_value": 0.0,
+        "crop_filtered_data": True,
     }
 
     kernel_filename = None
@@ -245,6 +247,11 @@ class BackprojectorBase:
         sinofilter_other_kwargs = {}
         if self.backend != "numpy":
             sinofilter_other_kwargs["%s_options" % self.backend] = {"ctx": self._processing.ctx}
+        sinofilter_other_kwargs["crop_filtered_data"] = self.extra_options.get("crop_filtered_data", True)
+        # TODO
+        if not (self.extra_options.get("crop_filtered_data", True)):
+            warnings.warn("crop_filtered_data = False is not supported for FBP yet", RuntimeWarning)
+        #
         self.sino_filter = self.SinoFilterClass(
             self.sino_shape,
             filter_name=self.filter_name,
@@ -376,6 +383,7 @@ class BackprojectorBase:
             # if a new device array was allocated for sinogram, then the filtering can overwrite it,
             # since it won't affect user argument
             if id(d_sino) != id(sino):
+                # if id(d_sino) != id(sino) and self.extra_options.get("crop_filtered_data", True):
                 filt_kwargs = {"output": d_sino}
             #
             sino_to_backproject = self.sino_filter(d_sino, **filt_kwargs)

nabu/reconstruction/filtering.py

@@ -5,15 +5,6 @@ from silx.image.tomography import compute_fourier_filter, get_next_power
 from ..processing.padding_base import PaddingBase
 from ..utils import check_supported, get_num_threads
 
-# # COMPAT.
-# from .filtering_cuda import CudaSinoFilter
-
-# SinoFilter = deprecated_class(
-#     "From version 2023.1, 'filtering_cuda.CudaSinoFilter' should be used instead of 'filtering.SinoFilter'. In the future, 'filtering.SinoFilter' will be a numpy-only class.",
-#     do_print=True,
-# )(CudaSinoFilter)
-# #
-
 
 class SinoFilter:
     available_filters = [
@@ -44,11 +35,44 @@ class SinoFilter:
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
     ):
+        """
+        Initialize a SinoFilter instance.
+
+        Parameters
+        ----------
+        sino_shape: tuple
+            Shape of sinogram, in the form (n_angles, detector_width) or (n_sinos, n_angles, detector_width)
+        filter_name: str, optional
+            Name of the filter. Default is ram-lak.
+        padding_mode: str, optional
+            How to pad the data prior to filtering. Default is zero-padding, corresponding to linear convolution with the filter kernel.
+            In practice this value is often set to "edges" for interior tomography.
+        crop_filtered_data: bool, optional
+            Whether to crop the final, filtered sinogram. Default is True. See notes below.
+        extra_options: dict, optional
+            Dictionary of advanced extra options.
+
+        Notes
+        -----
+        Sinogram filtering done in the Filtered Back-Projection (FBP) method consists, in theory, in applying a high-pass filter
+        to the sinogram prior to backprojection. This high-pass filter is normally the Ramachandran-Lakshminarayanan (Ram-Lak) filter
+        yielding a close-to-ideal reconstruction (see Natterer's "Mathematical methods in image reconstruction").
+        As the filter kernel has a large extent in spatial domain, it's best performed in Fourier domain via the Fourier-convolution theorem.
+        Filtering in Fourier domain should be done with a data padded to at least twice its size.
+        Zero-padding should be used for mathematical correctness (so that multiplication in Fourier domain corresponds to an actual linear convolution).
+        However if the sinogram does not decay to "zero" near the edges (i.e in interior tomography), padding with zeros usually gives artefacts after filtering.
+        In this case, padding with edges is preferred (corresponding to a convolution with the "edges" extension mode).
+
+        After inverse Fourier transform, the (padded and filtered) data is cropped back to its original size.
+        In some cases, it's preferable to keep the data un-cropped for further processing.
+        """
+
         self._init_extra_options(extra_options)
         self._set_padding_mode(padding_mode)
-        self._calculate_shapes(sino_shape)
+        self._calculate_shapes(sino_shape, crop_filtered_data)
         self._init_fft()
         self._allocate_memory()
         self._compute_filter(filter_name)
@@ -67,7 +91,7 @@ class SinoFilter:
         check_supported(padding_mode, self.available_padding_modes, "padding mode")
         self.padding_mode = padding_mode
 
-    def _calculate_shapes(self, sino_shape):
+    def _calculate_shapes(self, sino_shape, crop_filtered_data):
         self.ndim = len(sino_shape)
         if self.ndim == 2:
             n_angles, dwidth = sino_shape
@@ -90,6 +114,11 @@ class SinoFilter:
         self.pad_left = (self.dwidth_padded - self.dwidth) // 2
         self.pad_right = self.dwidth_padded - self.dwidth - self.pad_left
 
+        self.crop_filtered_data = crop_filtered_data
+        self.output_shape = self.sino_shape
+        if not (self.crop_filtered_data):
+            self.output_shape = self.sino_padded_shape
+
     def _init_fft(self):
         pass
 
@@ -147,19 +176,16 @@ class SinoFilter:
         if arr.shape != self.sino_shape:
             raise ValueError("Expected sinogram shape %s, got %s" % (self.sino_shape, arr.shape))
 
-    def filter_sino(self, sino, output=None, no_output=False):
+    def filter_sino(self, sino, output=None):
         """
         Perform the sinogram siltering.
 
         Parameters
         ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
+        sino: array
             Input sinogram (2D or 3D)
-        output: numpy.ndarray or pycuda.gpuarray.GPUArray, optional
+        output: array, optional
             Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
         """
         self._check_array(sino)
         # sino_padded = np.pad(
@@ -169,16 +195,21 @@ class SinoFilter:
         sino_padded_f = rfft(sino_padded, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
         sino_padded_f *= self.filter_f
         sino_filtered = irfft(sino_padded_f, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
+
         if output is None:
-            res = np.zeros(self.sino_shape, dtype=np.float32)
+            if not (self.crop_filtered_data):
+                # No need to allocate extra memory here
+                return sino_filtered
+            res = np.zeros(self.output_shape, dtype=np.float32)
         else:
             res = output
-        if self.ndim == 2:
-            # res[:] = sino_filtered[:, : self.dwidth]  # pylint: disable=E1126 # ?!
-            res[:] = sino_filtered[:, self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
+
+        if self.crop_filtered_data:
+            # res[:] = sino_filtered[..., : self.dwidth]  # pylint: disable=E1126 # ?!
+            res[:] = sino_filtered[..., self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
         else:
-            # res[:] = sino_filtered[:, :, : self.dwidth]  # pylint: disable=E1126 # ?!
-            res[:] = sino_filtered[:, :, self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
+            res[:] = sino_filtered[:]
+
         return res
 
     __call__ = filter_sino
@@ -191,6 +222,7 @@ def filter_sinogram(
     padding_mode="constant",
     normalize=True,
     filter_cutoff=1.0,
+    crop_filtered_data=True,
     **padding_kwargs,
 ):
     """
@@ -228,6 +260,8 @@ def filter_sinogram(
     fourier_filter = fourier_filter[: padded_width // 2 + 1]  # R2C
     sino_f = rfft(sinogram_padded, axis=1)
     sino_f *= fourier_filter
-    # sino_filtered = irfft(sino_f, axis=1)[:, :width]  # pylint: disable=E1126 # ?!
-    sino_filtered = irfft(sino_f, axis=1)[:, pad_left:-pad_right]  # pylint: disable=E1126 # ?!
+    sino_filtered = irfft(sino_f, axis=1)
+    if crop_filtered_data:
+        # sino_filtered = sino_filtered[:, :width]  # pylint: disable=E1126 # ?!
+        sino_filtered = sino_filtered[:, pad_left:-pad_right]  # pylint: disable=E1126 # ?!
     return sino_filtered

nabu/reconstruction/filtering_cuda.py

@@ -1,6 +1,6 @@
 import numpy as np
 from ..cuda.processing import CudaProcessing
-from ..utils import get_cuda_srcfile
+from ..utils import docstring, get_cuda_srcfile
 from ..processing.padding_cuda import CudaPadding
 from ..processing.fft_cuda import get_fft_class
 from .filtering import SinoFilter
@@ -9,17 +9,25 @@ from .filtering import SinoFilter
 class CudaSinoFilter(SinoFilter):
     default_extra_options = {**SinoFilter.default_extra_options, "fft_backend": "vkfft"}
 
+    @docstring(SinoFilter)
     def __init__(
         self,
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
         cuda_options=None,
     ):
         self._cuda_options = cuda_options or {}
         self.cuda = CudaProcessing(**self._cuda_options)
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
+        super().__init__(
+            sino_shape,
+            filter_name=filter_name,
+            padding_mode=padding_mode,
+            crop_filtered_data=crop_filtered_data,
+            extra_options=extra_options,
+        )
         self._init_kernels()
 
     def _init_fft(self):
@@ -60,25 +68,12 @@ class CudaSinoFilter(SinoFilter):
         )
 
     def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
-            Input sinogram (2D or 3D)
-        output: pycuda.gpuarray.GPUArray, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
         self._check_array(sino)
         if not (isinstance(sino, self.cuda.array_class)):
             sino = self.cuda.set_array("sino", sino)
         elif not (sino.flags.c_contiguous):
             # Transfer the device array into another, c-contiguous, device array
-            # We can throw an error as well in this case, but often we so something like fbp(radios[:, i, :])
+            # We can throw an error as well in this case, but often we do something like fbp(radios[:, i, :])
             sino_tmp = self.cuda.allocate_array("sino_contig", sino.shape)
             sino_tmp.set(sino)
             sino = sino_tmp
@@ -97,13 +92,19 @@ class CudaSinoFilter(SinoFilter):
 
         # return
         if output is None:
-            res = self.cuda.allocate_array("output", self.sino_shape)
+            if not (self.crop_filtered_data):
+                # No need to allocate extra memory here
+                return self.d_sino_padded
+            res = self.cuda.allocate_array("output", self.output_shape)
         else:
             res = output
-        if self.ndim == 2:
-            res[:] = self.d_sino_padded[:, self.pad_left : self.pad_left + self.dwidth]
+
+        if self.crop_filtered_data:
+            # res[:] = sino_filtered[..., : self.dwidth]  # pylint: disable=E1126 # ?!
+            res[:] = self.d_sino_padded[..., self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
         else:
-            res[:] = self.d_sino_padded[:, :, self.pad_left : self.pad_left + self.dwidth]
+            res[:] = self.d_sino_padded[:]
+
         return res
 
     __call__ = filter_sino

nabu/reconstruction/filtering_opencl.py

@@ -19,13 +19,20 @@ class OpenCLSinoFilter(SinoFilter):
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
         opencl_options=None,
     ):
         self._opencl_options = opencl_options or {}
         self.opencl = OpenCLProcessing(**self._opencl_options)
         self.queue = self.opencl.queue
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
+        super().__init__(
+            sino_shape,
+            filter_name=filter_name,
+            padding_mode=padding_mode,
+            crop_filtered_data=crop_filtered_data,
+            extra_options=extra_options,
+        )
         self._init_kernels()
 
     def _init_fft(self):
@@ -61,19 +68,6 @@ class OpenCLSinoFilter(SinoFilter):
         self.memcpy2D = OpenCLMemcpy2D(queue=self.queue)
 
     def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pyopencl.array
-            Input sinogram (2D or 3D)
-        output: pyopencl.array, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
         self._check_array(sino)
         sino = self.opencl.set_array("sino", sino)
 

nabu/reconstruction/hbp.py

@@ -73,7 +73,7 @@ class HierarchicalBackprojector(CudaBackprojector):
 
         # to do the reconstruction in reduction_steps steps
         self.reduction_steps = self.extra_options.get("hbp_reduction_steps", 2)
-        reduction_factor = int(math.ceil((sino_shape[-2]) ** (1 / self.reduction_steps)))
+        reduction_factor = math.ceil((sino_shape[-2]) ** (1 / self.reduction_steps))
 
         # TODO customize
         axis_source_meters = 1.0e9
@@ -153,13 +153,13 @@ class HierarchicalBackprojector(CudaBackprojector):
 
         angularRange = abs(np.ptp(self.angles)) / self.sino_shape[0] * reductionFactor
 
-        ngrids = int(math.ceil(self.sino_shape[0] / reductionFactor))
+        ngrids = math.ceil(self.sino_shape[0] / reductionFactor)
 
         grid_width = int(
             np.rint(2 * N * self.whf[0])
         )  # double sampling to account/compensate for diamond shaped grid of ray-intersections
-        grid_height = int(
-            math.ceil(angularRange * N * self.whf[1])
+        grid_height = math.ceil(
+            angularRange * N * self.whf[1]
         )  # small-angle approximation, generates as much "lines" as needed to account for all intersection levels
 
         m = (len(self.angles) // reductionFactor) * reductionFactor
@@ -179,7 +179,7 @@ class HierarchicalBackprojector(CudaBackprojector):
             )
         ]
         self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
-        self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+        self.grids += [(grid_height, grid_width, math.ceil(ngrids / legs))]
         self.reductionFactors += [reductionFactor]
 
         ### intermediate level grids: accumulation grids ###
@@ -190,13 +190,13 @@ class HierarchicalBackprojector(CudaBackprojector):
             # for a reasonable (with regard to memory requirement) grid-aspect ratio in the intermediate levels,
             # the covered angular range per grid should not exceed 28.6°, i.e.,
             # fewer than 7 (6.3) or 13 (12.6)  grids for a 180° / 360° scan is not reasonable
-            if int(math.ceil(ngrids / reductionFactor)) < 20:
+            if math.ceil(ngrids / reductionFactor) < 20:
                 break
             angularRange *= reductionFactor
-            ngrids = int(math.ceil(ngrids / reductionFactor))
+            ngrids = math.ceil(ngrids / reductionFactor)
 
-            grid_height = int(
-                math.ceil(angularRange * N * self.whf[1])
+            grid_height = math.ceil(
+                angularRange * N * self.whf[1]
             )  # implicit small angle approximation, whose validity is
             # asserted by the preceding "break"
             gridAinvT = self._getAinvT(N, grid_height, grid_width)
@@ -218,7 +218,7 @@ class HierarchicalBackprojector(CudaBackprojector):
                 )
             ]
             self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
-            self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+            self.grids += [(grid_height, grid_width, math.ceil(ngrids / legs))]
             self.reductionFactors += [reductionFactor]
 
         ##### final accumulation grid #################

nabu/reconstruction/rings_cuda.py

@@ -264,13 +264,7 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             filename=get_cuda_srcfile("normalization.cu"),
             signature="PPiii",
         )
-        self._mean_kernel_block = (32, 1, 32)
-        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._mean_kernel_block)]
-        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
-        self._mean_kernel_kwargs = {
-            "grid": self._mean_kernel_grid,
-            "block": self._mean_kernel_block,
-        }
+        self._set_kernel_args_normalization()
 
         self._op_kernel = self.processing.kernel(
             "inplace_generic_op_3Dby1D",
@@ -278,9 +272,25 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             signature="PPiii",
             options=["-DGENERIC_OP=%d" % (3 if self.mode == "divide" else 1)],
         )
-        self._op_kernel_block = (16, 16, 4)
-        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._op_kernel_block)]
-        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
+        self._set_kernel_args_mult()
+
+    def _set_kernel_args_normalization(self, blk_z=32, n_z=None):
+        n_z = n_z or self.n_z
+        self._mean_kernel_block = (32, 1, blk_z)
+        sinos_shape_xyz = self.sinos_shape[1:][::-1] + (n_z,)
+        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(sinos_shape_xyz, self._mean_kernel_block)]
+        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(n_z)]
+        self._mean_kernel_kwargs = {
+            "grid": self._mean_kernel_grid,
+            "block": self._mean_kernel_block,
+        }
+
+    def _set_kernel_args_mult(self, blk_z=4, n_z=None):
+        n_z = n_z or self.n_z
+        self._op_kernel_block = (16, 16, blk_z)
+        sinos_shape_xyz = self.sinos_shape[1:][::-1] + (n_z,)
+        self._op_kernel_grid = [updiv(a, b) for a, b in zip(sinos_shape_xyz, self._op_kernel_block)]
+        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(n_z)]
         self._op_kernel_kwargs = {
             "grid": self._op_kernel_grid,
             "block": self._op_kernel_block,
@@ -315,23 +325,41 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
         self.d_sino_profile[:] = sino_profile_p[self._pad_left : -self._pad_right]
         return self.d_sino_profile
 
+    def _remove_rings_sino(self, d_sino):
+        self._mean_kernel(d_sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
+        self._apply_filter(self.d_sino_profile)
+        self._op_kernel(d_sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+
     def remove_rings_sinogram(self, sino, output=None):
         #
         if output is not None:
             raise NotImplementedError
         #
         if not (sino.flags.c_contiguous):
+            # If the sinogram (or stack of sinogram) is not C-Contiguous, we'll proceed by looping over each
+            # C-Contiguous sinogram
             d_sino = self.processing.allocate_array("d_sino", sino.shape, np.float32)
             d_sino[:] = sino[:]
         else:
             d_sino = sino
-        self._mean_kernel(d_sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
-        self._apply_filter(self.d_sino_profile)
-        self._op_kernel(d_sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+        self._remove_rings_sino(d_sino)
         if not (sino.flags.c_contiguous):
             sino[:] = self.processing.d_sino[:]
         return sino
 
     def remove_rings_sinograms(self, sinograms):
+        if sinograms.flags.c_contiguous:
+            self._remove_rings_sino(sinograms)
+            return sinograms
+
+        # If the stack of sinograms is not C-Contiguous, we have to proceed by looping over each C-Contiguous sinogram
+        # (i.e don't copy the entire stack, just one sinogram at a time)
+        self._set_kernel_args_normalization(blk_z=1, n_z=1)
+        self._set_kernel_args_mult(blk_z=1, n_z=1)
         for i in range(sinograms.shape[0]):
             self.remove_rings_sinogram(sinograms[i])
+        self._set_kernel_args_normalization()
+        self._set_kernel_args_mult()
+        return sinograms
+
+    remove_rings = remove_rings_sinograms

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,