nabu 2024.1.0rc4__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/nabu/reconstruction/sinogram_cuda.py

@@ -0,0 +1,250 @@
+import numpy as np
+from ..utils import get_cuda_srcfile, updiv, deprecated_class
+from .sinogram import SinoBuilder, SinoNormalization, SinoMult
+from .sinogram import _convert_halftomo_right  # FIXME Temporary patch
+from ..cuda.processing import CudaProcessing
+
+
+class CudaSinoBuilder(SinoBuilder):
+    def __init__(
+        self, sinos_shape=None, radios_shape=None, rot_center=None, halftomo=False, angles=None, cuda_options=None
+    ):
+        """
+        Initialize a CudaSinoBuilder instance.
+        Please see the documentation of nabu.reconstruction.sinogram.Builder
+        and nabu.cuda.processing.CudaProcessing.
+        """
+        super().__init__(
+            sinos_shape=sinos_shape, radios_shape=radios_shape, rot_center=rot_center, halftomo=halftomo, angles=angles
+        )
+        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
+        self._init_cuda_halftomo()
+
+    def _init_cuda_halftomo(self):
+        if not (self.halftomo):
+            return
+        kernel_name = "halftomo_kernel"
+        self.halftomo_kernel = self.cuda_processing.kernel(
+            kernel_name,
+            get_cuda_srcfile("halftomo.cu"),
+            signature="PPPiii",
+        )
+        blk = (32, 32, 1)  # tune ?
+        self._halftomo_blksize = blk
+        self._halftomo_gridsize = (updiv(self.extended_sino_width, blk[0]), updiv((self.n_angles + 1) // 2, blk[1]), 1)
+        d = self.n_x - self.extended_sino_width // 2  # will have to be adapted for varying axis pos
+        self.halftomo_weights = np.linspace(0, 1, 2 * abs(d), endpoint=True, dtype="f")
+        self.d_halftomo_weights = self.cuda_processing.to_device("d_halftomo_weights", self.halftomo_weights)
+        # Allocate one single sinogram (kernel needs c-contiguous array).
+        # If odd number of angles: repeat last angle.
+        self.d_sino = self.cuda_processing.allocate_array(
+            "d_sino", (self.n_angles + (self.n_angles & 1), self.n_x), "f"
+        )
+        self.h_sino = self.d_sino.get()
+        #
+        self.cuda_processing.init_arrays_to_none(["d_output"])
+        if self._halftomo_flip:
+            self.xflip_kernel = self.cuda_processing.kernel(
+                "reverse2D_x", get_cuda_srcfile("ElementOp.cu"), signature="Pii"
+            )
+            blk = (32, 32, 1)
+            self._xflip_blksize = blk
+            self._xflip_gridsize_1 = (updiv(self.n_x, blk[0]), updiv(self.n_angles, blk[1]), 1)
+            self._xflip_gridsize_2 = self._halftomo_gridsize
+
+    #
+    # 2D
+    #
+
+    def _get_sino_halftomo(self, sino, output=None):
+        if output is None:
+            output = self.cuda_processing.allocate_array("d_output", self.output_shape[1:])
+        elif output.shape != self.output_shape[1:]:
+            raise ValueError("Expected output to have shape %s but got %s" % (self.output_shape[1:], output.shape))
+
+        d_sino = self.d_sino
+        n_a, n_x = sino.shape
+        d_sino[:n_a] = sino[:]
+        if self.n_angles & 1:
+            d_sino[-1, :].fill(0)
+        if self._halftomo_flip:
+            self.xflip_kernel(d_sino, n_x, n_a, grid=self._xflip_gridsize_1, block=self._xflip_blksize)
+        # Sometimes CoR is set well outside the FoV. Not supported by cuda backend for now.
+        # TODO/FIXME: TEMPORARY PATCH, waiting for cuda implementation
+        if self.rot_center > self.n_x:
+            d_sino.get(self.h_sino)  # copy D2H
+            res = _convert_halftomo_right(self.h_sino, self.extended_sino_width)
+            output.set(res)  # copy H2D
+        #
+        else:
+            self.halftomo_kernel(
+                d_sino,
+                output,
+                self.d_halftomo_weights,
+                n_a,
+                n_x,
+                self.extended_sino_width // 2,
+                grid=self._halftomo_gridsize,
+                block=self._halftomo_blksize,
+            )
+        if self._halftomo_flip:
+            self.xflip_kernel(
+                output, self.extended_sino_width, (n_a + 1) // 2, grid=self._xflip_gridsize_2, block=self._xflip_blksize
+            )
+        return output
+
+    #
+    # 3D
+    #
+
+    def _get_sinos_simple(self, radios, output=None):
+        if output is None:
+            return radios.transpose(axes=(1, 0, 2))  # view
+        else:
+            # why can't I do a discontig single copy ?
+            for i in range(radios.shape[1]):
+                output[i] = radios[:, i, :]
+            return output
+
+    def _get_sinos_halftomo(self, radios, output=None):
+        if output is None:
+            output = self.cuda_processing.allocate_array("output", self.output_shape, "f")
+        elif output.shape != self.output_shape:
+            raise ValueError("Expected output to have shape %s but got %s" % (self.output_shape, output.shape))
+        for i in range(self.n_z):
+            sino = self._get_sino_simple(radios, i)
+            self._get_sino_halftomo(sino, output=output[i])
+        return output
+
+
+CudaSinoProcessing = deprecated_class("'CudaSinoProcessing' was renamed 'CudaSinoBuilder'", do_print=True)(
+    CudaSinoBuilder
+)
+
+
+class CudaSinoMult(SinoMult):
+    def __init__(self, sino_shape, rot_center, **cuda_options):
+        super().__init__(sino_shape, rot_center)
+        self.cuda_processing = CudaProcessing(**cuda_options)
+        self._init_kernel()
+
+    def _init_kernel(self):
+        self.halftomo_kernel = self.cuda_processing.kernel(
+            "halftomo_prepare_sinogram", filename=get_cuda_srcfile("halftomo.cu"), signature="PPiiii"
+        )
+        self.d_weights = self.cuda_processing.set_array("d_weights", self.weights)
+        self._halftomo_kernel_other_args = [
+            self.d_weights,
+            np.int32(self.n_a),
+            np.int32(self.n_x),
+            np.int32(self.start_x),
+            np.int32(self.end_x),
+        ]
+        self._grid = (self.n_x, self.n_a)
+        self._blk = (32, 32, 1)  # tune ?
+
+    def prepare_sino(self, sino):
+        sino = self.cuda_processing.set_array("d_sino", sino)
+        self.halftomo_kernel(sino, *self._halftomo_kernel_other_args, grid=self._grid, block=self._blk)
+        return sino
+
+
+class CudaSinoNormalization(SinoNormalization):
+    def __init__(
+        self, kind="chebyshev", sinos_shape=None, radios_shape=None, normalization_array=None, cuda_options=None
+    ):
+        super().__init__(
+            kind=kind, sinos_shape=sinos_shape, radios_shape=radios_shape, normalization_array=normalization_array
+        )
+        self._get_shapes(sinos_shape, radios_shape)
+        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
+        self._init_cuda_normalization()
+
+    _get_shapes = SinoBuilder._get_shapes
+
+    #
+    # Chebyshev normalization
+    #
+
+    def _init_cuda_normalization(self):
+        self._d_tmp = self.cuda_processing.allocate_array("_d_tmp", self.sinos_shape[-2:], "f")
+        if self.normalization_kind == "chebyshev":
+            self._chebyshev_kernel = self.cuda_processing.kernel(
+                "normalize_chebyshev",
+                filename=get_cuda_srcfile("normalization.cu"),
+                signature="Piii",
+            )
+            self._chebyshev_kernel_args = [np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
+            blk = (1, 64, 16)  # TODO tune ?
+            self._chebyshev_kernel_kwargs = {
+                "block": blk,
+                "grid": (1, int(updiv(self.n_angles, blk[1])), int(updiv(self.n_z, blk[2]))),
+            }
+        elif self.normalization_array is not None:
+            normalization_array = self.normalization_array
+            # If normalization_array is 1D, make a 2D array by repeating the line
+            if normalization_array.ndim == 1:
+                normalization_array = np.tile(normalization_array, (self.n_angles, 1))
+            self._d_normalization_array = self.cuda_processing.to_device(
+                "_d_normalization_array", normalization_array.astype("f")
+            )
+            if self.normalization_kind == "subtraction":
+                generic_op_val = 1
+            elif self.normalization_kind == "division":
+                generic_op_val = 3
+            self._norm_kernel = self.cuda_processing.kernel(
+                "inplace_generic_op_2Dby2D",
+                filename=get_cuda_srcfile("ElementOp.cu"),
+                signature="PPii",
+                options=["-DGENERIC_OP=%d" % generic_op_val],
+            )
+            self._norm_kernel_args = [self._d_normalization_array, np.int32(self.n_angles), np.int32(self.n_x)]
+            blk = (32, 32, 1)
+            self._norm_kernel_kwargs = {
+                "block": blk,
+                "grid": (int(updiv(self.n_angles, blk[0])), int(updiv(self.n_x, blk[1])), 1),
+            }
+
+    def _normalize_chebyshev(self, sinos):
+        if sinos.flags.c_contiguous:
+            self._chebyshev_kernel(sinos, *self._chebyshev_kernel_args, **self._chebyshev_kernel_kwargs)
+        else:
+            # This kernel seems to have an issue on arrays that are not C-contiguous.
+            # We have to process image per image.
+            nz = np.int32(1)
+            nthreadsperblock = (1, 32, 1)  # TODO tune
+            nblocks = (1, int(updiv(self.n_angles, nthreadsperblock[1])), 1)
+            for i in range(sinos.shape[0]):
+                self._d_tmp[:] = sinos[i][:]
+                self._chebyshev_kernel(
+                    self._d_tmp,
+                    np.int32(self.n_x),
+                    np.int32(self.n_angles),
+                    np.int32(1),
+                    grid=nblocks,
+                    block=nthreadsperblock,
+                )
+                sinos[i][:] = self._d_tmp[:]
+        return sinos
+
+    #
+    # Array subtraction/division
+    #
+
+    def _normalize_op(self, sino):
+        if sino.ndim == 2:
+            # Things can go wrong if "sino" is a non-contiguous 2D array
+            # But this should be handled outside this function, as the processing is in-place
+            self._norm_kernel(sino, *self._norm_kernel_args, **self._norm_kernel_kwargs)
+        else:
+            if sino.flags.forc:
+                # Contiguous 3D array. But pycuda wants the same shape for both operands.
+                for i in range(sino.shape[0]):
+                    self._norm_kernel(sino[i], *self._norm_kernel_args, **self._norm_kernel_kwargs)
+            else:
+                # Non-contiguous 2D array. Make a temp. copy
+                for i in range(sino.shape[0]):
+                    self._d_tmp[:] = sino[i][:]
+                    self._norm_kernel(self._d_tmp, *self._norm_kernel_args, **self._norm_kernel_kwargs)
+                    sino[i][:] = self._d_tmp[:]
+        return sino

build/lib/nabu/reconstruction/sinogram_opencl.py

@@ -0,0 +1,40 @@
+import numpy as np
+from ..opencl.kernel import OpenCLKernel
+from ..opencl.processing import OpenCLProcessing
+from ..utils import get_opencl_srcfile
+from .sinogram import SinoMult
+
+
+class OpenCLSinoMult(SinoMult):
+    def __init__(self, sino_shape, rot_center, **opencl_options):
+        super().__init__(sino_shape, rot_center)
+        self.opencl_processing = OpenCLProcessing(**opencl_options)
+        self._init_kernel()
+
+    def _init_kernel(self):
+        self.halftomo_kernel = OpenCLKernel(
+            "halftomo_prepare_sinogram",
+            self.opencl_processing.ctx,
+            filename=get_opencl_srcfile("halftomo.cl"),
+        )
+        self.d_weights = self.opencl_processing.set_array("d_weights", self.weights)
+        self._halftomo_kernel_other_args = [
+            self.d_weights,
+            np.int32(self.n_a),
+            np.int32(self.n_x),
+            np.int32(self.start_x),
+            np.int32(self.end_x),
+        ]
+        self._global_size = (self.n_x, self.n_a)
+        self._local_size = None  # (32, 32, 1)  # tune ?
+
+    def prepare_sino(self, sino):
+        sino = self.opencl_processing.set_array("d_sino", sino)
+        self.halftomo_kernel(
+            self.opencl_processing.queue,
+            sino,
+            *self._halftomo_kernel_other_args,
+            global_size=self._global_size,
+            local_size=self._local_size,
+        )
+        return sino

build/lib/nabu/reconstruction/tests/__init__.py

@@ -0,0 +1 @@
+

build/lib/nabu/reconstruction/tests/test_cone.py

@@ -0,0 +1,308 @@
+import pytest
+import numpy as np
+from scipy.ndimage import gaussian_filter
+from nabu.utils import subdivide_into_overlapping_segment
+
+try:
+    import astra
+
+    __has_astra__ = True
+except ImportError:
+    __has_astra__ = False
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+
+if __has_pycuda__:
+    from nabu.reconstruction.cone import ConebeamReconstructor
+if __has_astra__:
+    from astra.extrautils import clipCircle
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.vol_shape = (128, 126, 126)
+    cls.n_angles = 180
+    cls.prj_width = 192  # detector larger than the sample
+    cls.src_orig_dist = 1000
+    cls.orig_det_dist = 100
+    cls.volume, cls.cone_data = generate_hollow_cube_cone_sinograms(
+        cls.vol_shape, cls.n_angles, cls.src_orig_dist, cls.orig_det_dist, prj_width=cls.prj_width
+    )
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context()
+
+
+@pytest.mark.skipif(not (__has_pycuda__ and __has_astra__), reason="Need pycuda and astra for this test")
+@pytest.mark.usefixtures("bootstrap")
+class TestCone:
+    def _create_cone_reconstructor(self, relative_z_position=None):
+        return ConebeamReconstructor(
+            self.cone_data.shape,
+            self.src_orig_dist,
+            self.orig_det_dist,
+            relative_z_position=relative_z_position,
+            volume_shape=self.volume.shape,
+            cuda_options={"ctx": self.ctx},
+        )
+
+    def test_simple_cone_reconstruction(self):
+        C = self._create_cone_reconstructor()
+        res = C.reconstruct(self.cone_data)
+        delta = np.abs(res - self.volume)
+
+        # Can we do better ? We already had to lowpass-filter the volume!
+        # First/last slices are OK
+        assert np.max(delta[:8]) < 1e-5
+        assert np.max(delta[-8:]) < 1e-5
+        # Middle region has a relatively low error
+        assert np.max(delta[40:-40]) < 0.11
+        # Transition zones between "zero" and "cube" has a large error
+        assert np.max(delta[10:25]) < 0.2
+        assert np.max(delta[-25:-10]) < 0.2
+        # End of transition zones have a smaller error
+        assert np.max(delta[25:40]) < 0.125
+        assert np.max(delta[-40:-25]) < 0.125
+
+    def test_against_explicit_astra_calls(self):
+        C = self._create_cone_reconstructor()
+
+        res = C.reconstruct(self.cone_data)
+        #
+        # Check that ConebeamReconstructor is consistent with these calls to astra
+        #
+        # "vol_geom" shape layout is (y, x, z). But here this geometry is used for the reconstruction
+        # (i.e sinogram -> volume)and not for projection (volume -> sinograms).
+        # So we assume a square slice. Mind that this is a particular case.
+        vol_geom = astra.create_vol_geom(self.vol_shape[2], self.vol_shape[2], self.vol_shape[0])
+
+        angles = np.linspace(0, 2 * np.pi, self.n_angles, True)
+        proj_geom = astra.create_proj_geom(
+            "cone",
+            1.0,
+            1.0,
+            self.cone_data.shape[0],
+            self.prj_width,
+            angles,
+            self.src_orig_dist,
+            self.orig_det_dist,
+        )
+        sino_id = astra.data3d.create("-sino", proj_geom, data=self.cone_data)
+        rec_id = astra.data3d.create("-vol", vol_geom)
+
+        cfg = astra.astra_dict("FDK_CUDA")
+        cfg["ReconstructionDataId"] = rec_id
+        cfg["ProjectionDataId"] = sino_id
+        alg_id = astra.algorithm.create(cfg)
+        astra.algorithm.run(alg_id)
+
+        res_astra = astra.data3d.get(rec_id)
+
+        # housekeeping
+        astra.algorithm.delete(alg_id)
+        astra.data3d.delete(rec_id)
+        astra.data3d.delete(sino_id)
+
+        assert (
+            np.max(np.abs(res - res_astra)) < 5e-4
+        ), "ConebeamReconstructor results are inconsistent with plain calls to astra"
+
+    def test_projection_full_vs_partial(self):
+        """
+        In the ideal case, all the data volume (and reconstruction) fits in memory.
+        In practice this is rarely the case, so we have to reconstruct the volume slabs by slabs.
+        The slabs should be slightly overlapping to avoid "stitching" artefacts at the edges.
+        """
+        # Astra seems to duplicate the projection data, even if all GPU memory is handled externally
+        # Let's try with (n_z * n_y * n_x + 2 * n_a * n_z * n_x) * 4  <  mem_limit
+        # 256^3 seems OK with n_a = 200 (180 MB)
+        n_z = n_y = n_x = 256
+        n_a = 200
+        src_orig_dist = 1000
+        orig_det_dist = 100
+
+        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
+        )
+        C_full = ConebeamReconstructor(cone_data.shape, src_orig_dist, orig_det_dist, cuda_options={"ctx": self.ctx})
+
+        vol_geom = astra.create_vol_geom(n_y, n_x, n_z)
+
+        proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, n_z, n_x, C_full.angles, src_orig_dist, orig_det_dist)
+        proj_id, projs_full_geom = astra.create_sino3d_gpu(volume, proj_geom, vol_geom)
+        astra.data3d.delete(proj_id)
+
+        # Do the same slab-by-slab
+        inner_slab_size = 64
+        overlap = 16
+        slab_size = inner_slab_size + overlap * 2
+        slabs = subdivide_into_overlapping_segment(n_z, slab_size, overlap)
+
+        projs_partial_geom = np.zeros_like(projs_full_geom)
+        for slab in slabs:
+            z_min, z_inner_min, z_inner_max, z_max = slab
+            rel_z_pos = (z_min + z_max) / 2 - n_z / 2
+            subvolume = volume[z_min:z_max, :, :]
+            C = ConebeamReconstructor(
+                (z_max - z_min, n_a, n_x),
+                src_orig_dist,
+                orig_det_dist,
+                relative_z_position=rel_z_pos,
+                cuda_options={"ctx": self.ctx},
+            )
+            proj_id, projs = astra.create_sino3d_gpu(subvolume, C.proj_geom, C.vol_geom)
+            astra.data3d.delete(proj_id)
+
+            projs_partial_geom[z_inner_min:z_inner_max] = projs[z_inner_min - z_min : z_inner_max - z_min]
+
+        error_profile = [
+            np.max(np.abs(proj_partial - proj_full))
+            for proj_partial, proj_full in zip(projs_partial_geom, projs_full_geom)
+        ]
+        assert np.all(np.isclose(error_profile, 0.0, atol=0.0375)), "Mismatch between full-cone and slab geometries"
+
+    def test_cone_reconstruction_magnified_vs_demagnified(self):
+        """
+        This will only test the astra toolbox.
+        When reconstructing a volume from cone-beam data, the volume "should" have a smaller shape than the projection
+        data shape (because of cone magnification).
+        But astra provides the same results when backprojecting on a "de-magnified grid" and the original grid shape.
+        """
+        n_z = n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 100
+        magnification = 1 + orig_det_dist / src_orig_dist
+        angles = np.linspace(0, 2 * np.pi, n_a, True)
+
+        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,
+        )
+        rec_original_grid = astra_cone_beam_reconstruction(
+            cone_data, angles, src_orig_dist, orig_det_dist, demagnify_volume=False
+        )
+        rec_reduced_grid = astra_cone_beam_reconstruction(
+            cone_data, angles, src_orig_dist, orig_det_dist, demagnify_volume=True
+        )
+
+        m_z = (n_z - int(n_z / magnification)) // 2
+        m_y = (n_y - int(n_y / magnification)) // 2
+        m_x = (n_x - int(n_x / magnification)) // 2
+
+        assert np.allclose(rec_original_grid[m_z:-m_z, m_y:-m_y, m_x:-m_x], rec_reduced_grid)
+
+    def test_reconstruction_full_vs_partial(self):
+        n_z = n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 100
+        angles = np.linspace(0, 2 * np.pi, n_a, True)
+
+        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,
+        )
+
+        rec_full_volume = astra_cone_beam_reconstruction(cone_data, angles, src_orig_dist, orig_det_dist)
+
+        rec_partial = np.zeros_like(rec_full_volume)
+        inner_slab_size = 64
+        overlap = 18
+        slab_size = inner_slab_size + overlap * 2
+        slabs = subdivide_into_overlapping_segment(n_z, slab_size, overlap)
+        for slab in slabs:
+            z_min, z_inner_min, z_inner_max, z_max = slab
+            m1, m2 = z_inner_min - z_min, z_max - z_inner_max
+            C = ConebeamReconstructor((z_max - z_min, n_a, n_x), src_orig_dist, orig_det_dist)
+            rec = C.reconstruct(
+                cone_data[z_min:z_max],
+                relative_z_position=((z_min + z_max) / 2) - n_z / 2,  #  (z_min + z_max)/2.
+            )
+            rec_partial[z_inner_min:z_inner_max] = rec[m1 : (-m2) or None]
+
+        # Compare volumes in inner circle
+        for i in range(n_z):
+            clipCircle(rec_partial[i])
+            clipCircle(rec_full_volume[i])
+
+        diff = np.abs(rec_partial - rec_full_volume)
+        err_max_profile = np.max(diff, axis=(-1, -2))
+        err_median_profile = np.median(diff, axis=(-1, -2))
+
+        assert np.max(err_max_profile) < 2e-3
+        assert np.max(err_median_profile) < 5e-6
+
+
+def generate_hollow_cube_cone_sinograms(
+    vol_shape, n_angles, src_orig_dist, orig_det_dist, prj_width=None, apply_filter=True
+):
+    # Adapted from Astra toolbox python samples
+
+    n_z, n_y, n_x = vol_shape
+    vol_geom = astra.create_vol_geom(n_y, n_x, n_z)
+
+    prj_width = prj_width or n_x
+    prj_height = n_z
+    angles = np.linspace(0, 2 * np.pi, n_angles, True)
+
+    proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, prj_width, prj_width, angles, src_orig_dist, orig_det_dist)
+    magnification = 1 + orig_det_dist / src_orig_dist
+
+    # hollow cube
+    cube = np.zeros(astra.geom_size(vol_geom), dtype="f")
+
+    d = int(min(n_x, n_y) / 2 * (1 - np.sqrt(2) / 2))
+    cube[20:-20, d:-d, d:-d] = 1
+    cube[40:-40, d + 20 : -(d + 20), d + 20 : -(d + 20)] = 0
+
+    # d = int(min(n_x, n_y) / 2 * (1 - np.sqrt(2) / 2) * magnification)
+    # d1 = d + 10
+    # d2 = d + 20
+    # cube[40:-40, d1:-d1, d1:-d1] = 1
+    # cube[60:-60, d2 : -d2, d2 : -d2] = 0
+
+    # High-frequencies yield cannot be accurately retrieved
+    if apply_filter:
+        cube = gaussian_filter(cube, (1.0, 1.0, 1.0))
+
+    proj_id, proj_data = astra.create_sino3d_gpu(cube, proj_geom, vol_geom)
+    astra.data3d.delete(proj_id)  # (n_z, n_angles, n_x)
+
+    return cube, proj_data
+
+
+def astra_cone_beam_reconstruction(cone_data, angles, src_orig_dist, orig_det_dist, demagnify_volume=False):
+    """
+    Handy (but data-inefficient) function to reconstruct data from cone-beam geometry
+    """
+
+    n_z, n_a, n_x = cone_data.shape
+
+    proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, n_z, n_x, angles, src_orig_dist, orig_det_dist)
+    sino_id = astra.data3d.create("-sino", proj_geom, data=cone_data)
+
+    m = 1 + orig_det_dist / src_orig_dist if demagnify_volume else 1.0
+    n_z_vol, n_y_vol, n_x_vol = int(n_z / m), int(n_x / m), int(n_x / m)
+    vol_geom = astra.create_vol_geom(n_y_vol, n_x_vol, n_z_vol)
+    rec_id = astra.data3d.create("-vol", vol_geom)
+
+    cfg = astra.astra_dict("FDK_CUDA")
+    cfg["ReconstructionDataId"] = rec_id
+    cfg["ProjectionDataId"] = sino_id
+    alg_id = astra.algorithm.create(cfg)
+
+    astra.algorithm.run(alg_id)
+
+    rec = astra.data3d.get(rec_id)
+
+    astra.data3d.delete(sino_id)
+    astra.data3d.delete(rec_id)
+    astra.algorithm.delete(alg_id)
+
+    return rec