nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/sinogram_cuda.py

@@ -1,250 +0,0 @@
-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/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/sinogram_opencl.py

@@ -1,40 +0,0 @@
-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/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/tests/__init__.py

@@ -1 +0,0 @@
-

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

@@ -1,308 +0,0 @@
-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