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

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2025.1.0-dev12"
+__version__ = "2025.1.0-dev13"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/app/multicor.py

@@ -59,23 +59,34 @@ def main():
     ######
 
     cors = get_user_cors(args["cor"])
+    options = reconstructor.process_config.processing_options["reconstruction"]
+    reconstruct_from_sinos_stack = (options["method"].lower() == "cone") or (
+        options["method"].lower() == "mlem" and options["implementation"].lower() == "corrct"
+    )
+    do_halftomo = pipeline.process_config.do_halftomo
 
     rec_instance = pipeline.reconstruction
 
+    # Get sinogram
+    if reconstruct_from_sinos_stack:
+        sino = pipeline._d_radios.transpose(axes=(1, 0, 2))
+    else:
+        # Get sinogram into contiguous array
+        # TODO Can't do memcpy2D ?! It used to work in cuda 11.
+        # For now: transfer to host... not optimal
+        sino = pipeline._d_radios[:, pipeline._d_radios.shape[1] // 2, :].get()  # pylint: disable=E1136
+
     for cor in cors:
         # Re-configure with new CoR
         pipeline.processing_options["reconstruction"]["rotation_axis_position"] = cor
         pipeline.processing_options["save"]["file_prefix"] = file_prefix + "_%.03f" % cor
         pipeline._init_writer(create_subfolder=False, single_output_file_initialized=False)
 
-        # Get sinogram into contiguous array
-        # TODO Can't do memcpy2D ?! It used to work in cuda 11.
-        # For now: transfer to host... not optimal
-        sino = pipeline._d_radios[:, pipeline._d_radios.shape[1] // 2, :].get()  # pylint: disable=E1136
-
-        if pipeline.process_config.do_halftomo:
+        # Reconfigure center of rotation
+        if not (do_halftomo):
+            pipeline.reconstruction.reset_rot_center(cor)
+        else:
             # re-initialize FBP object, because in half-tomography the output slice size is a function of CoR
-            options = pipeline.processing_options["reconstruction"]
             rec_instance = pipeline.FBPClass(
                 sino.shape,
                 angles=options["angles"],
@@ -92,11 +103,15 @@ def main():
                     "filter_cutoff": options["fbp_filter_cutoff"],
                 },
             )
-        else:
-            pipeline.reconstruction.reset_rot_center(cor)
 
         # Run reconstruction
-        rec = rec_instance.fbp(sino)
+        if reconstruct_from_sinos_stack:
+            # Need to copy the sino each time, as it is modified by FDK
+            rec = rec_instance.reconstruct(sino.copy())
+            # take the middle slice
+            rec = rec[rec.shape[0] // 2]
+        else:
+            rec = rec_instance.fbp(sino)
         # if return_all_recs:
         # all_recs.append(rec)
         rec_3D = view_as_images_stack(rec)  # writer wants 3D data

nabu/io/cast_volume.py

@@ -206,6 +206,9 @@ def cast_volume(
         data_min = data_min if data_min is not None else found_data_min
         data_max = data_max if data_max is not None else found_data_max
 
+    if isinstance(output_volume, JP2KVolume):
+        output_volume.rescale_data = False
+
     data = []
     for input_slice, frame_dumper in zip(
         input_volume.browse_slices(),

nabu/pipeline/fullfield/processconfig.py

@@ -577,6 +577,7 @@ class ProcessConfig(ProcessConfigBase):
                 self.rec_params,
                 [
                     "method",
+                    "iterations",
                     "implementation",
                     "fbp_filter_type",
                     "fbp_filter_cutoff",
@@ -613,8 +614,6 @@ class ProcessConfig(ProcessConfigBase):
                 voxel_size,
             )  # pix size is in microns in dataset_info
 
-            rec_options["iterations"] = nabu_config["reconstruction"]["iterations"]
-
             # x/y/z position information
             def get_mean_pos(position_array):
                 if position_array is None:
@@ -636,6 +635,8 @@ class ProcessConfig(ProcessConfigBase):
                 rec_options["position"] = mean_positions_xyz
             if rec_options["method"] == "cone" and rec_options["sample_detector_dist"] is None:
                 rec_options["sample_detector_dist"] = self.dataset_info.distance  # was checked to be not None earlier
+            if rec_options["method"].lower() == "mlem" and rec_options["implementation"] in [None, ""]:
+                rec_options["implementation"] = "corrct"
 
             # New key
             rec_options["cor_estimated_auto"] = isinstance(nabu_config["reconstruction"]["rotation_axis_position"], str)

nabu/preproc/tests/test_ctf.py

@@ -223,7 +223,7 @@ class TestCtf:
             # phase_fft = ctf_fft.retrieve_phase(img)
             self.check_result(phase_r2c, self.ref_plain, "Something wrong with CtfFilter-FFT")
 
-    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="pycuda and (scikit-cuda or vkfft)")
+    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="pycuda and (cupy? or vkfft)")
     def test_cuda_ctf(self):
         data = nabu_get_data("brain_phantom.npz")["data"]
         delta_beta = 50.0

nabu/preproc/tests/test_paganin.py

@@ -77,9 +77,7 @@ class TestPaganin:
         errmax = np.max(np.abs(res - res_tomopy) / np.max(res_tomopy))
         assert errmax < self.rtol_pag, "Max error is too high"
 
-    @pytest.mark.skipif(
-        not (__has_pycuda__ and __has_cufft__), reason="Need pycuda and (scikit-cuda or vkfft) for this test"
-    )
+    @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="Need pycuda and (cupy? or vkfft) for this test")
     @pytest.mark.parametrize("config", scenarios)
     def test_gpu_paganin(self, config):
         paganin, data, pag_kwargs = self.get_paganin_instance_and_data(config, self.data)

nabu/processing/fft_cuda.py

@@ -3,9 +3,8 @@ import warnings
 from functools import lru_cache
 from multiprocessing import get_context
 from multiprocessing.pool import Pool
-import numpy as np
 from ..utils import BaseClassError, check_supported, no_decorator
-from .fft_base import _BaseFFT, _BaseVKFFT
+from .fft_base import _BaseVKFFT
 
 try:
     from pyvkfft.cuda import VkFFTApp as CudaVkFFTApp
@@ -16,139 +15,9 @@ except (ImportError, OSError):
     CudaVkFFTApp = BaseClassError
 from ..cuda.processing import CudaProcessing
 
-Plan = None
-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,
-    # which can mess things up in some cases.
-    # Ugly solution to an ugly problem.
-    # ruff: noqa: PLW0603
-    global __has_skcuda__, Plan, cu_fft, cu_ifft
-    try:
-        from skcuda.fft import Plan
-        from skcuda.fft import fft as cu_fft
-        from skcuda.fft import ifft as cu_ifft
-
-        __has_skcuda__ = True
-    except ImportError:
-        __has_skcuda__ = False
-
-
-class SKCUFFT(_BaseFFT):
-    implem = "skcuda"
-    backend = "cuda"
-    ProcessingCls = CudaProcessing
-
-    def _configure_batched_transform(self):
-        if __has_skcuda__ is None:
-            init_skcuda()
-        if not (__has_skcuda__):
-            raise ImportError("Please install pycuda and scikit-cuda to use the CUDA back-end")
-
-        self.cufft_batch_size = 1
-        self.cufft_shape = self.shape
-        self._cufft_plan_kwargs = {}
-        if (self.axes is not None) and (len(self.axes) < len(self.shape)):
-            # In the easiest case, the transform is computed along the fastest dimensions:
-            #  - 1D transforms of lines of 2D data
-            #  - 2D transforms of images of 3D data (stacked along slow dim)
-            #  - 1D transforms of 3D data along fastest dim
-            # Otherwise, we have to configure cuda "advanced memory layout".
-            data_ndims = len(self.shape)
-
-            if data_ndims == 2:
-                n_y, n_x = self.shape
-                along_fast_dim = self.axes[0] == 1
-                self.cufft_shape = n_x if along_fast_dim else n_y
-                self.cufft_batch_size = n_y if along_fast_dim else n_x
-                if not (along_fast_dim):
-                    # Batched vertical 1D FFT on 2D data need advanced data layout
-                    # http://docs.nvidia.com/cuda/cufft/#advanced-data-layout
-                    self._cufft_plan_kwargs = {
-                        "inembed": np.int32([0]),
-                        "istride": n_x,
-                        "idist": 1,
-                        "onembed": np.int32([0]),
-                        "ostride": n_x,
-                        "odist": 1,
-                    }
-
-            if data_ndims == 3:
-                # TODO/FIXME - the following work for C2C but not R2C ?!
-                # fast_axes = [(1, 2), (2, 1), (2,)]
-                fast_axes = [(2,)]
-                if self.axes not in fast_axes:
-                    raise NotImplementedError(
-                        "With the CUDA backend, batched transform on 3D data is only supported along fastest dimensions"
-                    )
-                self.cufft_batch_size = self.shape[0]
-                self.cufft_shape = self.shape[1:]
-                if len(self.axes) == 1:
-                    # 1D transform on 3D data: here only supported along fast dim, so batch_size is Nx*Ny
-                    self.cufft_batch_size = np.prod(self.shape[:2])
-                    self.cufft_shape = (self.shape[-1],)
-                if len(self.cufft_shape) == 1:
-                    self.cufft_shape = self.cufft_shape[0]
-
-    def _configure_normalization(self, normalize):
-        self.normalize = normalize
-        if self.normalize == "ortho":
-            # TODO
-            raise NotImplementedError("Normalization mode 'ortho' is not implemented with CUDA backend yet.")
-        self.cufft_scale_inverse = self.normalize == "rescale"
-
-    def _compute_fft_plans(self):
-        self.plan_forward = Plan(  # pylint: disable = E1102
-            self.cufft_shape,
-            self.dtype,
-            self.dtype_out,
-            batch=self.cufft_batch_size,
-            stream=self.processing.stream,
-            **self._cufft_plan_kwargs,
-            # cufft extensible plan API is only supported after 0.5.1
-            # (commit 65288d28ca0b93e1234133f8d460dc6becb65121)
-            # but there is still no official 0.5.2
-            # ~ auto_allocate=True # cufft extensible plan API
-        )
-        self.plan_inverse = Plan(  # pylint: disable = E1102
-            self.cufft_shape,  # not shape_out
-            self.dtype_out,
-            self.dtype,
-            batch=self.cufft_batch_size,
-            stream=self.processing.stream,
-            **self._cufft_plan_kwargs,
-            # cufft extensible plan API is only supported after 0.5.1
-            # (commit 65288d28ca0b93e1234133f8d460dc6becb65121)
-            # but there is still no official 0.5.2
-            # ~ auto_allocate=True
-        )
-
-    def fft(self, array, output=None):
-        if output is None:
-            output = self.output_fft = self.processing.allocate_array(
-                "output_fft", self.shape_out, dtype=self.dtype_out
-            )
-        cu_fft(array, output, self.plan_forward, scale=False)  # pylint: disable = E1102
-        return output
-
-    def ifft(self, array, output=None):
-        if output is None:
-            output = self.output_ifft = self.processing.allocate_array("output_ifft", self.shape, dtype=self.dtype)
-        cu_ifft(  # pylint: disable = E1102
-            array,
-            output,
-            self.plan_inverse,
-            scale=self.cufft_scale_inverse,
-        )
-        return output
-
-
 maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
 
 
@@ -212,45 +81,9 @@ def has_vkfft(safe=True):
     return v
 
 
-def _has_skfft(x):
-    # should be run from within a Process
-    try:
-        from nabu.processing.fft_cuda import SKCUFFT
-
-        _ = SKCUFFT((16,), "f")
-        avail = True
-    except (ImportError, RuntimeError, OSError, NameError):
-        avail = False
-    return avail
-
-
-@lru_cache(maxsize=2)
-def has_skcuda(safe=True):
-    """
-    Determine whether scikit-cuda/CUFFT is available.
-    Currently, scikit-cuda will create a Cuda context for Cublas, which can mess up the current execution.
-    Do it in a separate thread.
-    """
-    if not safe:
-        return _has_skfft(None)
-    try:
-        ctx = get_context("spawn")
-        with Pool(1, context=ctx) as p:
-            v = p.map(_has_skfft, [1])[0]
-    except AssertionError:
-        # Can get AssertionError: daemonic processes are not allowed to have children
-        # if the calling code is already a subprocess
-        return _has_skfft(None)
-    return v
-
-
 @lru_cache(maxsize=2)
 def get_fft_class(backend="vkfft"):
     backends = {
-        "scikit-cuda": SKCUFFT,
-        "skcuda": SKCUFFT,
-        "cufft": SKCUFFT,
-        "scikit": SKCUFFT,
         "vkfft": VKCUFFT,
         "pyvkfft": VKCUFFT,
     }
@@ -266,7 +99,7 @@ def get_fft_class(backend="vkfft"):
 
     avail_fft_implems = get_available_fft_implems()
     if len(avail_fft_implems) == 0:
-        raise RuntimeError("Could not any Cuda FFT implementation. Please install either scikit-cuda or pyvkfft")
+        raise RuntimeError("Could not any Cuda FFT implementation. Please install pyvkfft")
     if backend not in avail_fft_implems:
         warnings.warn("Could not get FFT backend '%s'" % backend, RuntimeWarning)
         backend = avail_fft_implems[0]
@@ -279,6 +112,4 @@ def get_available_fft_implems():
     avail_implems = []
     if has_vkfft(safe=True):
         avail_implems.append("vkfft")
-    if has_skcuda(safe=True):
-        avail_implems.append("skcuda")
     return avail_implems

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"]

nabu/reconstruction/cone.py

@@ -292,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

nabu/reconstruction/mlem.py

@@ -66,6 +66,9 @@ class MLEMReconstructor:
             self.shifts_uv = shifts_uv.copy()
         self.cor = cor
 
+    def reset_rot_center(self, cor):
+        self.cor = cor
+
     def reconstruct(self, data_vwu):
         """
         data_align_vwu: numpy.ndarray or pycuda.gpuarray

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):

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__:
@@ -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:

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:

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-2025.1.0.dev12.dist-info → nabu-2025.1.0.dev13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabu
-Version: 2025.1.0.dev12
+Version: 2025.1.0.dev13
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2025.1.0.dev12.dist-info → nabu-2025.1.0.dev13.dist-info}/RECORD

@@ -1,8 +1,7 @@
 doc/conf.py,sha256=3xtCarCHrXPr50GbeRDuH-o3Jzojw7mpr7vpGfZPLAE,3787
 doc/create_conf_doc.py,sha256=IVOdP70KvbW9WS_UQu3Iyd0YfS60E2fJ5IDtQ_s4cDw,1143
-doc/doc_config.py,sha256=anqeOVjqE2e7eVzg7yuh9dvIneTkrA5doGl1cVBqT7Q,730
 doc/get_mathjax.py,sha256=VIvKRCdDuF2VoY8JD3mSey9XX13AZMmwTJBHdt1tUs4,1012
-nabu/__init__.py,sha256=SepTZaSbWOl9F3YCRbhVcmClf__zXKUWG0_aoxyUv4I,276
+nabu/__init__.py,sha256=ArHDO8a36q5KpcPAtV9nZ2qBWX2x49EWkvGtd6goCII,276
 nabu/tests.py,sha256=hOJD1GGxn_KE1bWMoxfjnjzI7d9JBUpoc9B2_tVFiEk,1370
 nabu/testutils.py,sha256=PmQVGkQmLjq1oX8C_rE8N5yceVNbUifPuNMiE6cQq7k,8667
 nabu/utils.py,sha256=XFk8_sUupngl5g1aFEE7IL_AzL9eJUV_ikmjiGfJNDA,26727
@@ -20,7 +19,7 @@ nabu/app/diag_to_rot.py,sha256=tBaF1Oy0-bjCqkLFK-Bu_n74easzLlRkI_FTC1cAH2Q,16933
 nabu/app/double_flatfield.py,sha256=1yquRUIHYXmrIg7NGHMDIXpkUCS_muEioUeqLyWf8PI,5641
 nabu/app/generate_header.py,sha256=Voo-FAvwS_mU5gtDxyqpZnSpP_mlMSfd_6bEtgdi_tg,8919
 nabu/app/histogram.py,sha256=gyLXKwFrU5WPQMkM1k8OdpIXSwGEEKC-f8RcTHKOho4,7930
-nabu/app/multicor.py,sha256=25v7tmN2_p1OQNhsI0qbCn3rpBmXzpJUDhHSVwzkLKo,4068
+nabu/app/multicor.py,sha256=Q9sxHSaCmahhf9hFZxX2jlfhk0me4ORBnHYfEwLo2dY,4725
 nabu/app/nx_z_splitter.py,sha256=p54jR-PAAw-AkGolM9fZE5lM2vbNLspCNCy5zBnJNP4,4976
 nabu/app/parse_reconstruction_log.py,sha256=msOtA3xaqLZpISRqS0F9_SrkvbdvKNPE99tdWhPrkY0,4745
 nabu/app/prepare_weights_double.py,sha256=jy78aP1UNKqSk82Wy6ZCkKjpYXxaGmlIj_vjB4SxS8A,5443
@@ -79,7 +78,7 @@ nabu/estimation/tests/test_focus.py,sha256=cMxEeTLlfVHOvG_4oGMLpp6bVI6okYz0u4aNc
 nabu/estimation/tests/test_tilt.py,sha256=KIgTJqQvNfWndm8f3aRSdznWFl3AdQhYXiZPKLseYOs,1672
 nabu/estimation/tests/test_translation.py,sha256=RkOnCYgk9DZGKlIka1snqTv4wbIz_nG7-EHAxnBHsJU,2999
 nabu/io/__init__.py,sha256=AbQgj4-fCCHOKynO_PyAR9ejnFSuWKgroxxhxWVpjyQ,120
-nabu/io/cast_volume.py,sha256=DVLCohBte7mkZooSIs3CyoDIqIY1HLDU1_2px0SiXrE,17483
+nabu/io/cast_volume.py,sha256=56HDNQ3mr7krylMGWW8aBXZ6d3FAGfKK-syppDv1P8k,17573
 nabu/io/detector_distortion.py,sha256=qO1Z6gejkBrixThvU_sLwH3UfLAe8aAO63YQ8z7PH78,11750
 nabu/io/reader.py,sha256=D5pOhOPadySvl7YkZmIIb9ZUJGpv5dITvb6r5RHZAkE,40525
 nabu/io/reader_helical.py,sha256=q3LOmu6F_4Uxi3rZZWJ-rsix2Lgu_saXXdiJF8TLi24,4533
@@ -144,7 +143,7 @@ nabu/pipeline/fullfield/computations.py,sha256=uqf7LvuDPm7n51BpP8eb8vTewDgRFyzSD
 nabu/pipeline/fullfield/dataset_validator.py,sha256=HK_bmlII9pc59PXCgKJOyLv7Xu3DYv_jbH3RmQSgzvI,2933
 nabu/pipeline/fullfield/get_double_flatfield.py,sha256=uYFDAii6Nw4RCUQO_6Id6tXLdmtVbj_pxAHQWennSeE,5411
 nabu/pipeline/fullfield/nabu_config.py,sha256=gSsWXEyQsCpQnrWtqhMSYAiNZLXdYnWwCiQzmYplxWI,32700
-nabu/pipeline/fullfield/processconfig.py,sha256=lF874kU1_TbPCKDtB8gYZ4iZQ46fJUUyWY5JfOFDZHM,37616
+nabu/pipeline/fullfield/processconfig.py,sha256=MISwEwb57hJRWr4Vih2cPA503CVMccqrsaTzmUt-BFk,37726
 nabu/pipeline/fullfield/reconstruction.py,sha256=sXI0NIFUc9nAhbAW6M52mbqalc6mFO315rrCl5r1RoY,37775
 nabu/pipeline/helical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/pipeline/helical/dataset_validator.py,sha256=HdKjUSj3PIpJb1dKSzJg8s4zXbAnMPWaPn8kvp_xQEs,657
@@ -182,16 +181,16 @@ nabu/preproc/shift.py,sha256=CT1i-G7Bs36hK5CGYBik05qAcKj82YpBZKNL3brcbzw,3419
 nabu/preproc/shift_cuda.py,sha256=4YOVRZ4oECEVWOQ6MzDBh8cOY2RtOOhlU7tir0Tp77M,4125
 nabu/preproc/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 nabu/preproc/tests/test_ccd_corr.py,sha256=KIpwaWYWT_6OPVXyVuLxXIIWreBkYF0rOnDMiegiLMU,2249
-nabu/preproc/tests/test_ctf.py,sha256=5C-PKzMcIQQFR4RsNh6au8TVGqbKhPV3_5djVaSB9p8,9992
+nabu/preproc/tests/test_ctf.py,sha256=4KtjLdiMqwtv3ZJgk-q5xzxoxSnKL_wleZtEgEgEw2A,9986
 nabu/preproc/tests/test_double_flatfield.py,sha256=qUmgAktFHqzKJBHHfj3GJzorey0yk7R0e4nr8dRmbTo,2870
 nabu/preproc/tests/test_flatfield.py,sha256=8_vmTtfmrpbuKUr4fW8NmtH-PtGWkSQkMBFD6hs0ul4,21055
-nabu/preproc/tests/test_paganin.py,sha256=aHfNsJcVALVYkbNHrhcO9lFYfco2qYA5PnzAjKTG2BU,2998
+nabu/preproc/tests/test_paganin.py,sha256=Ixlp624o0xtFs12akN6sDn-gHWXm1wVlcdumm2prqh4,2978
 nabu/preproc/tests/test_vshift.py,sha256=Gq9sDtbbAAdLTJALH2qcbeYXE5dINQ8QpBnCgZM0tFQ,2972
 nabu/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/processing/azim.py,sha256=GIv_C1NYjUP3IYd51qvfECTDu-rfs3Dl2Hb5-ZhdhHY,7080
 nabu/processing/convolution_cuda.py,sha256=jOLKdEwzBwNZPTEjXIBWStZp22ieeukc6KGnuSNVnaA,15421
 nabu/processing/fft_base.py,sha256=wSLiyJEwX51chfZG3CWPl0DvKp182qAmTnRY8N1mWW0,5741
-nabu/processing/fft_cuda.py,sha256=9afmklpiN9F5Xqh7ikC6thBvVPJ8sR6XJEOTABf_8yo,9891
+nabu/processing/fft_cuda.py,sha256=0JNzdSPPQ1xS38mjsgriN3-Cj9MXCtADLVHzIQjQjWc,3467
 nabu/processing/fft_opencl.py,sha256=Qhd9F32XCN22tet-en8S-yGkZDNsOMapqHlS0eTiPp0,2082
 nabu/processing/fftshift.py,sha256=mFOKuqQtxDPXoFPPP_G-YMA4WFmmO0oPFXjBWrrfDO8,4880
 nabu/processing/histogram.py,sha256=CumzHFjOw0JaHWlMnhCnj7I2Guam1HYqPVJeijKqC40,11376
@@ -212,7 +211,7 @@ nabu/processing/unsharp.py,sha256=XqoieKlX5sEHalxObi5JBOjauRUSbiHc6rqYT_buTa4,26
 nabu/processing/unsharp_cuda.py,sha256=uKFCEk8bRqgJzR8HB_OeKYuwC5jKqaXpFI6pRv_pDY4,2152
 nabu/processing/unsharp_opencl.py,sha256=vBVq5wA-rxOkULE-sv6WzNt5Pq9hc3gFcp4mM0kCo44,2651
 nabu/processing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/processing/tests/test_fft.py,sha256=BlUvHjpLtyrn_kpAhM7rldhrdQ8tb_APY1Q2IwntoN0,10260
+nabu/processing/tests/test_fft.py,sha256=9UnMcqnmzlBz5SHeJV9b8VOX-cAm35DBIbEP84l4nlM,7587
 nabu/processing/tests/test_fftshift.py,sha256=Qwg3oOwNh_MRmg9BS1kMVhQSSfzQzrCOsppsvY3v5rg,2599
 nabu/processing/tests/test_histogram.py,sha256=25CLs1WZpLF9xZ2DR82x4_YokA5Z76Qsnn6zY8YdJj8,2283
 nabu/processing/tests/test_medfilt.py,sha256=rnReK3MMCsc74-NoycYSRSMp7bN4Qdg4cZbHfWQ9ZWQ,2652
@@ -223,8 +222,7 @@ nabu/processing/tests/test_rotation.py,sha256=vedRXV9RePJywBKoyBkGANP1dhZCjphbYO
 nabu/processing/tests/test_transpose.py,sha256=hTG17wTaB5Wv6twbW3ZFhBv6BYfqJY7DTQPoO0-KdkM,2760
 nabu/processing/tests/test_unsharp.py,sha256=R3ovbwDDp3ccy2A8t6CcUVELXRWkED5EnQdN2FQOfQM,4391
 nabu/reconstruction/__init__.py,sha256=EmKVvx_-FJvzJngG4ielIC7FhMCpI1Waaflg_lF44tk,163
-nabu/reconstruction/astra.py,sha256=qnFYabU-Bzgys8hXjIBcwO2NazrvhNXUYFIkMHc6BmM,10444
-nabu/reconstruction/cone.py,sha256=JH3o5gYP3CsvMWwVwDWrhj2_BXd55-zAXUcz8_OP4sc,20338
+nabu/reconstruction/cone.py,sha256=tSjaMDHeFV-h_IFbxUqSbhqlWmvlBcJQ8u89Y9Q9gg8,20559
 nabu/reconstruction/fbp.py,sha256=Tiz-CkYnDZ6YL6YB-e-BfwPdQEbw1X4GhGPX8gUs7Ng,5520
 nabu/reconstruction/fbp_base.py,sha256=NaHGF33TERTB-mCeMJPYLEn_FkZCKCUioSYkNXaA-Xg,17553
 nabu/reconstruction/fbp_opencl.py,sha256=coEGLq65PCuvWnhAbIyLPHACkWjMB0XOceMp9ZIDWtc,3274
@@ -232,7 +230,7 @@ nabu/reconstruction/filtering.py,sha256=monJnA_kk9k_Gy7bMAos9I-XgU8czWhf9vBth6ik
 nabu/reconstruction/filtering_cuda.py,sha256=_S-BZMhtnNt8ugePSmf-LF7JvMPCOyGPUMSseymgwZw,4019
 nabu/reconstruction/filtering_opencl.py,sha256=s65EWrjfUFdScicmNAGyRv8-8OQgapy_HvwMm-J7Lh4,3705
 nabu/reconstruction/hbp.py,sha256=Qll7i20LWxUo1-SHRxemkYAolBTP8HScwt1OvWmD2r0,18642
-nabu/reconstruction/mlem.py,sha256=66_porIK6Fn4KO6NIO3ZZHBPEEA1rf2Qk23YYwaZwzg,3568
+nabu/reconstruction/mlem.py,sha256=CD9RppEzHgWRTEwzkY1hQXsfP9xXn1n8p3Lk8H1ya5Y,3629
 nabu/reconstruction/projection.py,sha256=SNocaOY9HuNiHs-VxkW9IS707JPJnd3sDjAbf7aIw2E,9081
 nabu/reconstruction/reconstructor.py,sha256=16xxHcK4iie-uh-trf6x_IuvgxJKBvQRTE5B8tnc4F8,7358
 nabu/reconstruction/reconstructor_cuda.py,sha256=m_3GzG44PRyiSEfTvYjgr5atLwl26hMfZOMyqTWxp0g,1644
@@ -243,13 +241,13 @@ nabu/reconstruction/sinogram_cuda.py,sha256=DBF06ruzkZ5zn8x06Ron2NkB_FBKiZC2oM7k
 nabu/reconstruction/sinogram_opencl.py,sha256=vxJa5BeOd2NVdUayXYfQGAfO1AEbJfTGotuijT8qgCs,1486
 nabu/reconstruction/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 nabu/reconstruction/tests/test_cone.py,sha256=yRx0k1Nv1bTP2IyiwygtIoafQ6v18-qf9J1Rkg_OxSI,22732
-nabu/reconstruction/tests/test_deringer.py,sha256=HsEPlqa5sup1NoayjZjBATy67Y7MBlB-PsN780y02Rw,8368
-nabu/reconstruction/tests/test_fbp.py,sha256=rZxMke2AYoQm8bh9BhLOm2dXqumGa3jibDGfRaZqZMo,16404
+nabu/reconstruction/tests/test_deringer.py,sha256=3xT7YltisnXa-NUd7aoMe88wOfTiTj-uxC6JFxGXtUA,8352
+nabu/reconstruction/tests/test_fbp.py,sha256=SLdNjpWp3c7XVRUlR9nKyUvvzEcu9CkFE7WaP6nFxQc,16368
 nabu/reconstruction/tests/test_filtering.py,sha256=RXQAEvNIjwiQ-zU6xrkV4h-MkDg3uVBAUyz0tOSIfIw,5581
-nabu/reconstruction/tests/test_halftomo.py,sha256=FFv58sSA-5WDcJ_Y5tSm1P7QQwNX4SUIYtHQQb_G3xM,6532
+nabu/reconstruction/tests/test_halftomo.py,sha256=zCAOFGRaLicr2PLw3628Kdcuj_bhGZz8QZvWBL-c7As,6526
 nabu/reconstruction/tests/test_mlem.py,sha256=JWby9nqWqockgUh2RQoqrC8BtfB4v5SCNayk4bBJ4TM,3791
 nabu/reconstruction/tests/test_projector.py,sha256=QcHLnNWQ6HC9pJo9CdalaaeEDQ_vFpNMn5yXEpfBDXI,6259
-nabu/reconstruction/tests/test_reconstructor.py,sha256=3p2Wk_OqgZqkNOkhK_NJWlHkOIENTJhLuwVRI8Y1_Ak,3385
+nabu/reconstruction/tests/test_reconstructor.py,sha256=xzfEM0j48ScQoGqWVcAK74HG97tcF7FsVVLzvX_TgHE,3379
 nabu/reconstruction/tests/test_sino_normalization.py,sha256=qNnpVUp3UcFGyLlSP0rCzE5hxdV6YENL9AF6mo72WcQ,3669
 nabu/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/resources/cor.py,sha256=-mcrTbj3G7o4PP5E_gIRo2j6_-ADmMkkOc_0CyQv84c,170
@@ -314,9 +312,9 @@ nabu/thirdparty/pore3d_deringer_munch.py,sha256=o4bisnFc-wMjuohWBT8wgWmfNehPQGtC
 nabu/thirdparty/tomocupy_remove_stripe.py,sha256=Khe4zFf0kRzu65Yxnvq58gt1ljOztqJGdMDhVAiM7lM,24363
 nabu/thirdparty/tomopy_phase.py,sha256=hK4oPpkogLOhv23XzzEXQY2u3r8fJvASY_bINVs6ERE,8634
 nabu/thirdparty/tomwer_load_flats_darks.py,sha256=ZNoVAinUb_wGYbfvs_4BVnWsjsQmNxSvCh1bWhR2WWg,5611
-nabu-2025.1.0.dev12.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2025.1.0.dev12.dist-info/METADATA,sha256=T4u5bDQORSj-JCgYQ-CRSK07KKomiK3iR6HMZsIerOo,4327
-nabu-2025.1.0.dev12.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nabu-2025.1.0.dev12.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
-nabu-2025.1.0.dev12.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2025.1.0.dev12.dist-info/RECORD,,
+nabu-2025.1.0.dev13.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2025.1.0.dev13.dist-info/METADATA,sha256=lwL6b68kmLzJUclKbi3MMeCZ1ltGOyS1NviEUbSuUiI,4327
+nabu-2025.1.0.dev13.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nabu-2025.1.0.dev13.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
+nabu-2025.1.0.dev13.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2025.1.0.dev13.dist-info/RECORD,,

doc/doc_config.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-from nabu.resources.nabu_config import nabu_config
-
-
-def generate(file_):
-    def write(content):
-        print(content, file=file_)
-    for section, values in nabu_config.items():
-        if section == "about":
-            continue
-        write("## %s\n" % section)
-        for key, val in values.items():
-            if val["type"] == "unsupported":
-                continue
-            write(val["help"] + "\n")
-            write(
-                "```ini\n%s = %s\n```"
-                % (key, val["default"])
-            )
-
-
-
-if __name__ == "__main__":
-
-    import sys, os
-    print(os.path.abspath(__file__))
-    exit(0)
-
-    fname = "/tmp/test.md"
-    with open(fname, "w") as f:
-        generate(f)

nabu/reconstruction/astra.py

@@ -1,245 +0,0 @@
-# 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)