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

nabu/pipeline/fullfield/processconfig.py

@@ -1,6 +1,7 @@
 import os
 import posixpath
 import numpy as np
+from .get_double_flatfield import get_double_flatfield
 from silx.io import get_data
 from silx.io.url import DataUrl
 from ...utils import copy_dict_items, compare_dicts
@@ -32,6 +33,7 @@ class ProcessConfig(ProcessConfigBase):
 
     (2) update_dataset_info_with_user_config
       - Update flats/darks
+      - Double-flat-field
       - CoR  (value or estimation method) # no estimation yet
       - rotation angles
       - translations files
@@ -89,12 +91,29 @@ class ProcessConfig(ProcessConfigBase):
         self.subsampling_factor = subsampling_factor or 1
         self.subsampling_start = subsampling_start or 0
 
+        self._get_double_flatfield()
         self._update_dataset_with_user_overwrites()
         self._get_rotation_axis_position()
         self._update_rotation_angles()
         self._get_translation_file("reconstruction", "translation_movements_file", "translations")
         self._get_user_sino_normalization()
 
+    def _get_double_flatfield(self):
+        self._dff_file = None
+        dff_mode = self.nabu_config["preproc"]["double_flatfield"]
+        if not (dff_mode):
+            return
+        self._dff_file = get_double_flatfield(
+            self.dataset_info,
+            dff_mode,
+            output_dir=self.nabu_config["output"]["location"],
+            darks_flats_dir=self.nabu_config["dataset"]["darks_flats_dir"],
+            dff_options={
+                "dff_sigma": self.nabu_config["preproc"]["dff_sigma"],
+                "do_flatfield": (self.nabu_config["preproc"]["flatfield"] is not False),
+            },
+        )
+
     def _update_dataset_with_user_overwrites(self):
         user_overwrites = self.nabu_config["dataset"]["overwrite_metadata"].strip()
         if user_overwrites in ("", None):
@@ -451,11 +470,11 @@ class ProcessConfig(ProcessConfigBase):
         #
         # Double flat field
         #
-        if nabu_config["preproc"]["double_flatfield_enabled"]:
+        if nabu_config["preproc"]["double_flatfield"]:
             tasks.append("double_flatfield")
             options["double_flatfield"] = {
                 "sigma": nabu_config["preproc"]["dff_sigma"],
-                "processes_file": nabu_config["preproc"]["processes_file"],
+                "processes_file": self._dff_file or nabu_config["preproc"]["processes_file"],
                 "log_min_clip": nabu_config["preproc"]["log_min_clip"],
                 "log_max_clip": nabu_config["preproc"]["log_max_clip"],
             }
@@ -575,6 +594,7 @@ class ProcessConfig(ProcessConfigBase):
                     "sample_detector_dist",
                     "hbp_legs",
                     "hbp_reduction_steps",
+                    "crop_filtered_data",
                 ],
             )
             rec_options = options["reconstruction"]

nabu/pipeline/fullfield/reconstruction.py

@@ -120,7 +120,7 @@ class FullFieldReconstructor:
         vm = virtual_memory()
         self.resources["mem_avail_GB"] = vm.available / 1e9
         # Account for other memory constraints. There might be a better way
-        slurm_mem_constraint_MB = int(environ.get("SLURM_MEM_PER_NODE", 0))
+        slurm_mem_constraint_MB = int(environ.get("SLURM_MEM_PER_NODE", 0))  # noqa: PLW1508
         if slurm_mem_constraint_MB > 0:
             self.resources["mem_avail_GB"] = slurm_mem_constraint_MB / 1e3
         #
@@ -131,8 +131,12 @@ class FullFieldReconstructor:
         self.resources["gpus"] = avail_gpus
         if len(avail_gpus) == 0:
             return
-        # pick first GPU by default. TODO: handle user's nabu_config["resources"]["gpu_id"]
-        self.resources["gpu_id"] = self._gpu_id = first_generator_item(avail_gpus.keys())
+        user_gpus = self.process_config.nabu_config.get("resources", {}).get("gpu_id", [])
+        if len(user_gpus) == 0:
+            user_gpus = [0]
+        # For now nabu does not support multi-GPU reconstruction. Take the first one.
+        user_gpu_idx = user_gpus[0]
+        self.resources["gpu_id"] = self._gpu_id = list(avail_gpus.keys())[user_gpu_idx]
 
     def _get_backend(self, backend, cuda_options):
         self._pipeline_cls = ChunkedPipeline
@@ -145,6 +149,7 @@ class FullFieldReconstructor:
                 backend = "numpy"
             else:
                 self.gpu_mem = self.resources["gpus"][self._gpu_id]["memory_GB"] * self.gpu_mem_fraction
+                self.cuda_options = {"device_id": self._gpu_id}
         if backend == "cuda":
             if not (__has_pycuda__):
                 raise RuntimeError("pycuda not avilable")
@@ -307,7 +312,7 @@ class FullFieldReconstructor:
         sigma = opts["unsharp_sigma"]
         # nabu uses cutoff = 4
         cutoff = 4
-        gaussian_kernel_size = int(ceil(2 * cutoff * sigma + 1))
+        gaussian_kernel_size = ceil(2 * cutoff * sigma + 1)
         self.logger.debug("Unsharp mask margin: %d pixels" % gaussian_kernel_size)
         return (gaussian_kernel_size, gaussian_kernel_size)
 

nabu/pipeline/helical/gridded_accumulator.py

@@ -532,7 +532,7 @@ def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_ma
     # regridded dataset, estimating a meaningul angular step representative
     # of the raw data
     my_angle_step = abs(np.diff(span_info.projection_angles_deg).mean())
-    n_gridded_angles = int(round(360.0 / my_angle_step))
+    n_gridded_angles = round(360.0 / my_angle_step)
 
     radios_h = phase_margin_pix + (my_z_end - my_z_min) + phase_margin_pix
 

nabu/pipeline/helical/helical_reconstruction.py

@@ -168,8 +168,8 @@ class HelicalReconstructorRegridded:
 
             # the meaming of z_min and z_max is: position in slices units from the
             # first available slice and in the direction of the scan
-            self.z_min = int(round(z_start * (0 - z_fract_min) + z_max * z_fract_min))
-            self.z_max = int(round(z_start * (0 - z_fract_max) + z_max * z_fract_max)) + 1
+            self.z_min = round(z_start * (0 - z_fract_min) + z_max * z_fract_min)
+            self.z_max = round(z_start * (0 - z_fract_max) + z_max * z_fract_max) + 1
 
     def _compute_translations_margin(self):
         return 0, 0

nabu/pipeline/helical/nabu_config.py

@@ -43,7 +43,7 @@ nabu_config["preproc"]["processes_file"] = {
     "validator": optional_file_location_validator,
     "type": "required",
 }
-nabu_config["preproc"]["double_flatfield_enabled"]["default"] = 1
+nabu_config["preproc"]["double_flatfield"]["default"] = 1
 
 
 nabu_config["reconstruction"].update(

nabu/pipeline/helical/weight_balancer.py

@@ -83,7 +83,7 @@ def shift(arr, shift, fill_value=0.0):
     """
     result = np.zeros_like(arr)
 
-    num1 = int(math.floor(shift))
+    num1 = math.floor(shift)
     num2 = num1 + 1
     partition = shift - num1
 

nabu/pipeline/params.py

@@ -25,12 +25,17 @@ unsharp_methods = {
     "": None,
 }
 
+# see PaddingBase.supported_modes
 padding_modes = {
-    "edges": "edge",
-    "edge": "edge",
-    "mirror": "mirror",
     "zeros": "zeros",
     "zero": "zeros",
+    "constant": "zeros",
+    "edges": "edge",
+    "edge": "edge",
+    "mirror": "reflect",
+    "reflect": "reflect",
+    "symmetric": "symmetric",
+    "wrap": "wrap",
 }
 
 reconstruction_methods = {

nabu/preproc/shift.py

@@ -42,7 +42,7 @@ class VerticalShift:
     def _init_interp_coefficients(self):
         self.interp_infos = []
         for s in self.shifts:
-            s0 = int(floor(s))
+            s0 = floor(s)
             f = s - s0
             self.interp_infos.append([s0, f])
 

nabu/processing/fft_base.py

@@ -93,6 +93,10 @@ class _BaseFFT:
         pass
 
 
+def raise_base_class_error(slf, *args, **kwargs):
+    raise ValueError
+
+
 class _BaseVKFFT(_BaseFFT):
     """
     FFT using VKFFT backend
@@ -101,7 +105,7 @@ class _BaseVKFFT(_BaseFFT):
     implem = "vkfft"
     backend = "none"
     ProcessingCls = BaseClassError
-    vkffs_cls = BaseClassError
+    get_fft_obj = raise_base_class_error
 
     def _configure_batched_transform(self):
         if self.axes is not None and len(self.shape) == len(self.axes):
@@ -128,7 +132,7 @@ class _BaseVKFFT(_BaseFFT):
         self._vkfft_ndim = None
 
     def _compute_fft_plans(self):
-        self._vkfft_plan = self.vkffs_cls(
+        self._vkfft_plan = self.get_fft_obj(
             self.shape,
             self.dtype,
             ndim=self._vkfft_ndim,

nabu/processing/fft_cuda.py

@@ -1,18 +1,19 @@
 import os
 import warnings
+from functools import lru_cache
 from multiprocessing import get_context
 from multiprocessing.pool import Pool
 import numpy as np
-from ..utils import check_supported
+from ..utils import BaseClassError, check_supported, no_decorator
 from .fft_base import _BaseFFT, _BaseVKFFT
 
 try:
-    from pyvkfft.cuda import VkFFTApp as vk_cufft
+    from pyvkfft.cuda import VkFFTApp as CudaVkFFTApp
 
     __has_vkfft__ = True
 except (ImportError, OSError):
     __has_vkfft__ = False
-    vk_cufft = None
+    CudaVkFFTApp = BaseClassError
 from ..cuda.processing import CudaProcessing
 
 Plan = None
@@ -20,6 +21,8 @@ cu_fft = None
 cu_ifft = None
 __has_skcuda__ = None
 
+n_cached_ffts = int(os.getenv("NABU_FFT_CACHE", "0"))
+
 
 def init_skcuda():
     # This needs to be done here, because scikit-cuda creates a Cuda context at import,
@@ -146,6 +149,18 @@ class SKCUFFT(_BaseFFT):
         return output
 
 
+maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
+
+
+@maybe_cached
+def _get_vkfft_cuda(*args, **kwargs):
+    return CudaVkFFTApp(*args, **kwargs)
+
+
+def get_vkfft_cuda(slf, *args, **kwargs):
+    return _get_vkfft_cuda(*args, **kwargs)
+
+
 class VKCUFFT(_BaseVKFFT):
     """
     Cuda FFT, using VKFFT backend
@@ -154,7 +169,7 @@ class VKCUFFT(_BaseVKFFT):
     implem = "vkfft"
     backend = "cuda"
     ProcessingCls = CudaProcessing
-    vkffs_cls = vk_cufft
+    get_fft_obj = get_vkfft_cuda
 
     def _init_backend(self, backend_options):
         super()._init_backend(backend_options)
@@ -175,6 +190,7 @@ def _has_vkfft(x):
     return avail
 
 
+@lru_cache(maxsize=2)
 def has_vkfft(safe=True):
     """
     Determine whether pyvkfft is available.
@@ -208,6 +224,7 @@ def _has_skfft(x):
     return avail
 
 
+@lru_cache(maxsize=2)
 def has_skcuda(safe=True):
     """
     Determine whether scikit-cuda/CUFFT is available.
@@ -227,6 +244,7 @@ def has_skcuda(safe=True):
     return v
 
 
+@lru_cache(maxsize=2)
 def get_fft_class(backend="vkfft"):
     backends = {
         "scikit-cuda": SKCUFFT,
@@ -256,6 +274,7 @@ def get_fft_class(backend="vkfft"):
     return get_fft_cls(backend)
 
 
+@lru_cache(maxsize=1)
 def get_available_fft_implems():
     avail_implems = []
     if has_vkfft(safe=True):

nabu/processing/fft_opencl.py

@@ -1,15 +1,32 @@
+from functools import lru_cache
+import os
 from multiprocessing import get_context
 from multiprocessing.pool import Pool
+
+from ..utils import BaseClassError, no_decorator
 from .fft_base import _BaseVKFFT
 from ..opencl.processing import OpenCLProcessing
 
 try:
-    from pyvkfft.opencl import VkFFTApp as vk_clfft
+    from pyvkfft.opencl import VkFFTApp as OpenCLVkFFTApp
 
     __has_vkfft__ = True
 except (ImportError, OSError):
     __has_vkfft__ = False
     vk_clfft = None
+    OpenCLVkFFTApp = BaseClassError
+
+n_cached_ffts = int(os.getenv("NABU_FFT_CACHE", "0"))
+maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
+
+
+@maybe_cached
+def _get_vkfft_opencl(*args, **kwargs):
+    return OpenCLVkFFTApp(*args, **kwargs)
+
+
+def get_vkfft_opencl(slf, *args, **kwargs):
+    return _get_vkfft_opencl(*args, **kwargs)
 
 
 class VKCLFFT(_BaseVKFFT):
@@ -20,7 +37,7 @@ class VKCLFFT(_BaseVKFFT):
     implem = "vkfft"
     backend = "opencl"
     ProcessingCls = OpenCLProcessing
-    vkffs_cls = vk_clfft
+    get_fft_obj = get_vkfft_opencl
 
     def _init_backend(self, backend_options):
         super()._init_backend(backend_options)

nabu/processing/padding_cuda.py

@@ -11,7 +11,6 @@ class CudaPadding(PaddingBase):
 
     backend = "cuda"
 
-    # TODO docstring from base class
     def __init__(self, shape, pad_width, mode="constant", cuda_options=None, **kwargs):
         super().__init__(shape, pad_width, mode=mode, **kwargs)
         self.cuda_processing = self.processing = CudaProcessing(**(cuda_options or {}))

nabu/processing/processing_base.py

@@ -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/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)