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/nabu/reconstruction/fbp.py

@@ -1,124 +0,0 @@
-import numpy as np
-import pycuda.driver as cuda
-from ..utils import updiv, get_cuda_srcfile
-from ..cuda.utils import copy_array, check_textures_availability
-from ..cuda.processing import CudaProcessing
-from ..cuda.kernel import CudaKernel
-from .filtering_cuda import CudaSinoFilter
-from .sinogram_cuda import CudaSinoMult
-from .fbp_base import BackprojectorBase
-
-
-class CudaBackprojector(BackprojectorBase):
-    backend = "cuda"
-    kernel_filename = "backproj.cu"
-    backend_processing_class = CudaProcessing
-    SinoFilterClass = CudaSinoFilter
-    SinoMultClass = CudaSinoMult
-
-    def _check_textures_availability(self):
-        self._use_textures = self.extra_options.get("use_textures", True) and check_textures_availability()
-
-    def _get_kernel_signature(self):
-        kern_full_sig = list("PPiifiiffPPPf")
-        if self._axis_correction is None:
-            kern_full_sig[11] = ""
-        if self._use_textures:
-            # texture references - no object is passed (deprecated, removed in Cuda 12)
-            kern_full_sig[1] = ""
-        return "".join(kern_full_sig)
-
-    def _get_kernel_options(self):
-        super()._get_kernel_options()
-        self._kernel_options.update(
-            {
-                "file_name": get_cuda_srcfile(self.kernel_filename),
-                "kernel_signature": self._get_kernel_signature(),
-                "texture_name": "tex_projections",
-            }
-        )
-
-    def _prepare_kernel_args(self):
-        super()._prepare_kernel_args()
-        self.kern_proj_kwargs.update(
-            {
-                "shared_size": self._kernel_options["shared_size"],
-            }
-        )
-        # texture references - no object is passed (deprecated, removed in Cuda 12)
-        if self._use_textures:
-            self.kern_proj_args.pop(1)
-        else:
-            self._d_sino = self._processing.allocate_array("_d_sino", self.sino_shape)
-            self.kern_proj_args[1] = self._d_sino.gpudata
-
-    def _prepare_textures(self):
-        if self._use_textures:
-            self.texref_proj = self.gpu_projector.module.get_texref(self._kernel_options["texture_name"])
-            self.texref_proj.set_filter_mode(cuda.filter_mode.LINEAR)
-            self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [self.texref_proj])
-            # Bind texture
-            self._d_sino_cua = cuda.np_to_array(np.zeros(self.sino_shape, "f"), "C")
-            self.texref_proj.set_array(self._d_sino_cua)
-        else:
-            # d_sino_ref = self._d_sino.gpudata
-            # self.kern_proj_args.insert(2, d_sino_ref)
-            self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [])
-
-    def _compile_kernels(self):
-        self._prepare_kernel_args()
-        if self._use_textures:
-            self._kernel_options["sourcemodule_options"].append("-DUSE_TEXTURES")
-        self.gpu_projector = CudaKernel(
-            self._kernel_options["kernel_name"],
-            filename=self._kernel_options["file_name"],
-            options=self._kernel_options["sourcemodule_options"],
-        )
-        if self.halftomo and self.rot_center < self.dwidth:
-            self.sino_mult = CudaSinoMult(self.sino_shape, self.rot_center, ctx=self._processing.ctx)
-        self._prepare_textures()  # has to be done after compilation for Cuda (to bind texture to built kernel)
-
-    def _transfer_to_texture(self, sino, do_checks=True):
-        if self._use_textures:
-            copy_array(self._d_sino_cua, sino, check=do_checks)
-        else:
-            if id(self._d_sino) == id(sino):
-                return
-            self._d_sino[:] = sino[:]
-
-
-# COMPAT.
-Backprojector = CudaBackprojector
-
-
-class PolarBackprojector(Backprojector):
-    """
-    Cuda Backprojector with output in polar coordinates.
-    """
-
-    cuda_fname = "backproj_polar.cu"
-    cuda_kernel_name = "backproj_polar"
-
-    # patch parent method: force slice_shape to (n_angles, n_x)
-    def _set_angles(self, angles, n_angles):
-        Backprojector._set_angles(self, angles, n_angles)
-        self.slice_shape = (self.n_angles, self.n_x)
-
-    # patch parent method:
-    def _set_slice_roi(self, slice_roi):
-        if slice_roi is not None:
-            raise ValueError("slice_roi is not supported with this class")
-        Backprojector._set_slice_roi(self, slice_roi)
-
-    # patch parent method: don't do the 4X compute-workload optimization for this kernel
-    def _get_kernel_options(self):
-        Backprojector._get_kernel_options(self)
-        block = self._kernel_options["block"]
-        self._kernel_options["grid"] = (updiv(self.n_x, block[0]), updiv(self.n_y, block[1]))
-
-    # patch parent method: update kernel args
-    def _compile_kernels(self):
-        n_y = self.n_y
-        self.n_y = self.n_angles
-        Backprojector._compile_kernels(self)
-        self.n_y = n_y

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/fbp_base.py

@@ -1,391 +0,0 @@
-import numpy as np
-from ..utils import updiv, nextpow2, convert_index, deprecation_warning
-from ..processing.processing_base import ProcessingBase
-from .filtering import SinoFilter
-from .sinogram import SinoMult
-from .sinogram import get_extended_sinogram_width
-
-
-class BackprojectorBase:
-    """
-    Base class for backprojectors.
-    """
-
-    backend = "numpy"
-    default_padding_mode = "zeros"
-    kernel_name = "backproj"
-    default_extra_options = {
-        "padding_mode": None,
-        "axis_correction": None,
-        "centered_axis": False,
-        "clip_outer_circle": False,
-        "scale_factor": None,
-        "filter_cutoff": 1.0,
-    }
-
-    kernel_filename = None
-    backend_processing_class = ProcessingBase
-    SinoFilterClass = SinoFilter
-    SinoMultClass = SinoMult
-    _sino_filter_other_options = {}
-
-    def __init__(
-        self,
-        sino_shape,
-        slice_shape=None,
-        angles=None,
-        rot_center=None,
-        padding_mode=None,
-        halftomo=False,
-        filter_name=None,
-        slice_roi=None,
-        scale_factor=None,
-        extra_options=None,
-        backend_options=None,
-    ):
-        """
-        Initialize a Backprojector.
-
-        Parameters
-        -----------
-        sino_shape: tuple
-            Shape of the sinogram, in the form `(n_angles, detector_width)`
-            (for backprojecting one sinogram) or `(n_sinos, n_angles, detector_width)`.
-        slice_shape: int or tuple, optional
-            Shape of the slice. By default, the slice shape is (n_x, n_x) where
-            `n_x = detector_width`
-        angles: array-like, optional
-            Rotation anles in radians.
-            By default, angles are equispaced between [0, pi[.
-        rot_center: float, optional
-            Rotation axis position. Default is `(detector_width - 1)/2.0`
-        padding_mode: str, optional
-            Padding mode when filtering the sinogram. Can be "zeros" (default) or "edges".
-        filter_name: str, optional
-            Name of the filter for filtered-backprojection.
-        slice_roi: tuple, optional.
-            Whether to backproject in a restricted area.
-            If set, it must be in the form (start_x, end_x, start_y, end_y).
-            `end_x` and `end_y` are non inclusive ! For example if the detector has
-            2048 pixels horizontally, then you can choose `start_x=0` and `end_x=2048`.
-            If one of the value is set to None, it is replaced with a default value
-            (0 for start, n_x and n_y for end)
-        scale_factor: float, optional
-            Scaling factor for backprojection.
-            For example, to get the linear absorption coefficient in 1/cm,
-            this factor has to be set as the pixel size in cm.
-            DEPRECATED - please use this parameter in "extra_options"
-        extra_options: dict, optional
-            Advanced extra options.
-             See the "Extra options" section for more information.
-        backend_options: dict, optional
-            OpenCL/Cuda options passed to the OpenCLProcessing or CudaProcessing class.
-
-        Other parameters
-        -----------------
-        extra_options: dict, optional
-            Dictionary with a set of advanced options. The default are the following:
-                - "padding_mode": "zeros"
-                   Padding mode when filtering the sinogram. Can be "zeros" or "edges".
-                   DEPRECATED - please use "padding_mode" directly in parameters.
-                - "axis_correction": None
-                    Whether to set a correction for the rotation axis.
-                    If set, this should be an array with as many elements as the number
-                    of angles. This is useful when there is an horizontal displacement
-                    of the rotation axis.
-                - centered_axis: bool
-                    Whether to "center" the slice on the rotation axis position.
-                    If set to True, then the reconstructed region is centered on the rotation axis.
-                - scale_factor: float
-                    Scaling factor for backprojection.
-                    For example, to get the linear absorption coefficient in 1/cm,
-                    this factor has to be set as the pixel size in cm.
-                - clip_outer_circle: False
-                    Whether to set to zero the pixels outside the reconstruction mask
-                - filter_cutoff: float
-                    Cut-off frequency usef for Fourier filter. Default is 1.0
-        """
-        self._processing = self.backend_processing_class(**(backend_options or {}))
-        self._configure_extra_options(scale_factor, padding_mode, extra_options=extra_options)
-        self._check_textures_availability()
-        self._init_geometry(sino_shape, slice_shape, angles, rot_center, halftomo, slice_roi)
-        self._init_filter(filter_name)
-        self._allocate_memory()
-        self._compute_angles()
-        self._compile_kernels()
-
-    def _configure_extra_options(self, scale_factor, padding_mode, extra_options=None):
-        extra_options = extra_options or {}
-        # compat.
-        scale_factor = None
-        if scale_factor is not None:
-            deprecation_warning(
-                "Please use the parameter 'scale_factor' in the 'extra_options' dict",
-                do_print=True,
-                func_name="fbp_scale_factor",
-            )
-        scale_factor = extra_options.get("scale_factor", None) or scale_factor or 1.0
-        #
-        if "padding_mode" in extra_options:
-            deprecation_warning(
-                "Please use 'padding_mode' directly in Backprojector arguments, not in 'extra_options'",
-                do_print=True,
-                func_name="fbp_padding_mode",
-            )
-        #
-        self._backproj_scale_factor = scale_factor
-        self._axis_array = None
-        self.extra_options = self.default_extra_options.copy()
-        self.extra_options.update(extra_options)
-        self.padding_mode = padding_mode or self.extra_options["padding_mode"] or self.default_padding_mode
-        self._axis_array = self.extra_options["axis_correction"]
-
-    def _init_geometry(self, sino_shape, slice_shape, angles, rot_center, halftomo, slice_roi):
-        if slice_shape is not None and slice_roi is not None:
-            raise ValueError("slice_shape and slice_roi cannot be used together")
-        self.sino_shape = sino_shape
-        if len(sino_shape) == 2:
-            n_angles, dwidth = sino_shape
-        else:
-            raise ValueError("Expected 2D sinogram")
-        self.dwidth = dwidth
-        self.halftomo = halftomo
-        if rot_center is None:
-            if halftomo:
-                raise ValueError("Need to know 'rot_center' when using halftomo")
-            rot_center = (self.dwidth - 1) / 2.0
-        self.rot_center = rot_center
-        self._set_slice_shape(slice_shape)
-        self.axis_pos = self.rot_center
-        self._set_angles(angles, n_angles)
-        self._set_slice_roi(slice_roi)
-        #
-        # offset = start - move
-        # move = 0 if not(centered_axis) else start + (n-1)/2. - c
-        if self.extra_options["centered_axis"]:
-            self.offsets = {
-                "x": self.rot_center - (self.n_x - 1) / 2.0,
-                "y": self.rot_center - (self.n_y - 1) / 2.0,
-            }
-        #
-        self._set_axis_corr()
-
-    def _set_slice_shape(self, slice_shape):
-        if not (self.halftomo):
-            n_x = n_y = self.dwidth
-        else:
-            n_x = n_y = get_extended_sinogram_width(self.dwidth, self.rot_center)
-        if slice_shape is not None:
-            if np.isscalar(slice_shape):
-                slice_shape = (slice_shape, slice_shape)
-            n_y, n_x = slice_shape
-        self.n_x = n_x
-        self.n_y = n_y
-        self.slice_shape = (n_y, n_x)
-
-    def _set_angles(self, angles, n_angles):
-        self.n_angles = n_angles
-        if angles is None:
-            angles = n_angles
-        if np.isscalar(angles):
-            end_angle = np.pi if not (self.halftomo) else 2 * np.pi
-            take_end_angle = self.halftomo
-            angles = np.linspace(0, end_angle, angles, take_end_angle)
-        else:
-            assert len(angles) == self.n_angles, "expected %d angles but got %d" % (len(angles), self.n_angles)
-        self.angles = angles
-
-    def _set_slice_roi(self, slice_roi):
-        self.offsets = {"x": 0, "y": 0}
-        self.slice_roi = slice_roi
-        if slice_roi is None:
-            return
-        start_x, end_x, start_y, end_y = slice_roi
-        # convert negative indices
-        start_x = convert_index(start_x, self.n_x, 0)
-        start_y = convert_index(start_y, self.n_y, 0)
-        end_x = convert_index(end_x, self.n_x, self.n_x)
-        end_y = convert_index(end_y, self.n_y, self.n_y)
-        self.slice_shape = (end_y - start_y, end_x - start_x)
-        self.n_x = self.slice_shape[-1]
-        self.n_y = self.slice_shape[-2]
-        self.offsets = {"x": start_x, "y": start_y}
-
-    def _allocate_memory(self):
-        # 1D textures are not supported in pyopencl
-        self.h_msin = np.zeros((1, self.n_angles), "f")
-        self.h_cos = np.zeros((1, self.n_angles), "f")
-        # self._d_sino = self._processing.allocate_array("d_sino", self.sino_shape, "f")
-        self._processing.init_arrays_to_none(["_d_slice", "d_sino"])
-
-    def _compute_angles(self):
-        self.h_cos[0] = np.cos(self.angles).astype("f")
-        self.h_msin[0] = (-np.sin(self.angles)).astype("f")
-        self._d_msin = self._processing.set_array("d_msin", self.h_msin[0])
-        self._d_cos = self._processing.set_array("d_cos", self.h_cos[0])
-        if self._axis_correction is not None:
-            self._d_axcorr = self._processing._set_array("d_axcorr", self._axis_correction)
-
-    def _set_axis_corr(self):
-        axcorr = self.extra_options["axis_correction"]
-        self._axis_correction = axcorr
-        if axcorr is None:
-            return
-        if len(axcorr) != self.n_angles:
-            raise ValueError("Expected %d angles but got %d" % (self.n_angles, len(axcorr)))
-        self._axis_correction = np.zeros((1, self.n_angles), dtype=np.float32)
-        self._axis_correction[0, :] = axcorr[:]  # pylint: disable=E1136
-
-    def _init_filter(self, filter_name):
-        self.filter_name = filter_name
-        if filter_name in ["None", "none"]:
-            self.sino_filter = None
-            return
-        sinofilter_other_kwargs = {}
-        if self.backend != "numpy":
-            sinofilter_other_kwargs["%s_options" % self.backend] = {"ctx": self._processing.ctx}
-        self.sino_filter = self.SinoFilterClass(
-            self.sino_shape,
-            filter_name=self.filter_name,
-            padding_mode=self.padding_mode,
-            extra_options={"cutoff": self.extra_options.get("filter_cutoff", 1.0)},
-            **sinofilter_other_kwargs,
-        )
-        if self.halftomo:
-            # When doing half-tomography, each projections is seen "twice".
-            # SinoFilter normalizes with pi/n_angles, but in half-tomography here n_angles is somehow halved.
-            # TODO it should even be "n_turns", where n_turns can be computed from the angles
-            self.sino_filter.set_filter(self.sino_filter.filter_f * (self.n_angles / np.pi * 2))
-
-    def reset_rot_center(self, rot_center):
-        """
-        Define a new center of rotation for the current backprojector.
-        """
-        self.rot_center = rot_center
-        self.axis_pos = rot_center
-        # See kernels signature of backproj.cu and backproj.cl.
-        # The ifdef makes things a bit more complicated
-        proj_arg_idx = 4
-        if self.backend == "cuda" and self._use_textures:
-            proj_arg_idx = 3
-        self.kern_proj_args[proj_arg_idx] = rot_center
-        if self.extra_options["centered_axis"]:
-            self.offsets = {
-                "x": self.rot_center - (self.n_x - 1) / 2.0,
-                "y": self.rot_center - (self.n_y - 1) / 2.0,
-            }
-            self.kern_proj_args[proj_arg_idx + 3] = self.offsets["x"]
-            self.kern_proj_args[proj_arg_idx + 4] = self.offsets["y"]
-
-    # Try to factorize some code between Cuda and OpenCL
-    # Not ideal, as cuda uses "grid" = n_blocks_launched,
-    # while OpenCL uses "global_size" = n_threads_launched
-    def _get_kernel_options(self):
-        sourcemodule_options = []
-        # We use blocks of 16*16 (see why in kernel doc), and one thread
-        # handles 2 pixels per dimension.
-        block = (16, 16, 1)
-        # The Cuda kernel is optimized for 16x16 threads blocks
-        # If one of the dimensions is smaller than 16, it has to be addapted
-        if self.n_x < 16 or self.n_y < 16:
-            tpb_x = min(int(nextpow2(self.n_x)), 16)
-            tpb_y = min(int(nextpow2(self.n_y)), 16)
-            block = (tpb_x, tpb_y, 1)
-            sourcemodule_options.append("-DSHARED_SIZE=%d" % (tpb_x * tpb_y))
-        grid = (updiv(updiv(self.n_x, block[0]), 2), updiv(updiv(self.n_y, block[1]), 2))
-        if self.extra_options["clip_outer_circle"]:
-            sourcemodule_options.append("-DCLIP_OUTER_CIRCLE")
-        shared_size = int(np.prod(block)) * 2
-        if self._axis_correction is not None:
-            sourcemodule_options.append("-DDO_AXIS_CORRECTION")
-            shared_size += int(np.prod(block))
-        shared_size *= 4  # sizeof(float32)
-        self._kernel_options = {
-            "kernel_name": self.kernel_name,
-            "sourcemodule_options": sourcemodule_options,
-            "grid": grid,
-            "block": block,
-            "shared_size": shared_size,
-        }
-
-    def _prepare_kernel_args(self):
-        self._get_kernel_options()
-        self.kern_proj_args = [
-            None,  # output d_slice holder
-            None,  # placeholder for sino (OpenCL or Cuda+no-texture)
-            np.int32(self.n_angles),
-            np.int32(self.dwidth),
-            np.float32(self.axis_pos),
-            np.int32(self.n_x),
-            np.int32(self.n_y),
-            np.float32(self.offsets["x"]),
-            np.float32(self.offsets["y"]),
-            self._d_cos,
-            self._d_msin,
-            np.float32(self._backproj_scale_factor),
-        ]
-        if self._axis_correction is not None:
-            self.kern_proj_args.insert(-1, self._d_axcorr)
-        self.kern_proj_kwargs = {
-            "grid": self._kernel_options["grid"],
-            "block": self._kernel_options["block"],
-        }
-
-    def _set_output(self, output, check=False):
-        self._output_is_ndarray = isinstance(output, np.ndarray)
-        if output is None or self._output_is_ndarray:
-            self._processing.allocate_array("_d_slice", self.slice_shape, dtype=np.float32)
-            return self._processing._d_slice  # pylint: disable=E1101
-        if check:
-            assert output.dtype == np.float32
-            assert output.shape == self.slice_shape, "Expected output shape %s but got %s" % (
-                self.slice_shape,
-                output.shape,
-            )
-        return output
-
-    def _set_kernel_slice_arg(self, d_slice):
-        self.kern_proj_args[0] = d_slice
-
-    def backproj(self, sino, output=None, do_checks=True):
-        if self.halftomo and self.rot_center < self.dwidth:
-            self.sino_mult.prepare_sino(sino)
-        self._transfer_to_texture(sino)
-        d_slice = self._set_output(output, check=do_checks)
-        self._set_kernel_slice_arg(d_slice)
-        self.gpu_projector(*self.kern_proj_args, **self.kern_proj_kwargs)
-        if output is not None and not (self._output_is_ndarray):
-            return output
-        else:
-            return self._processing._d_slice.get(ary=output)
-
-    def filtered_backprojection(self, sino, output=None):
-        #
-        if isinstance(sino, self._processing.array_class):
-            d_sino = sino
-        else:
-            d_sino = self._processing.to_device("d_sino", sino)
-        #
-        if self.sino_filter is not None:
-            filt_kwargs = {}
-            # if a new device array was allocated for sinogram, then the filtering can overwrite it,
-            # since it won't affect user argument
-            if id(d_sino) != id(sino):
-                filt_kwargs = {"output": d_sino}
-            #
-            sino_to_backproject = self.sino_filter(d_sino, **filt_kwargs)
-        else:
-            sino_to_backproject = d_sino
-        return self.backproj(sino_to_backproject, output=output)
-
-    fbp = filtered_backprojection  # shorthand
-
-    def __repr__(self):
-        res = "%s(sino_shape=%s, slice_shape=%s, rot_center=%.2f, halftomo=%s)" % (
-            self.__class__.__name__,
-            str(self.sino_shape),
-            str(self.slice_shape),
-            self.rot_center,
-            self.halftomo,
-        )
-        return res

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/reconstruction/fbp_opencl.py

@@ -1,78 +0,0 @@
-import pyopencl as cl
-from ..utils import get_opencl_srcfile
-from ..opencl.processing import OpenCLProcessing
-from ..opencl.kernel import OpenCLKernel
-from ..opencl.utils import allocate_texture, check_textures_availability, copy_to_texture
-from .filtering_opencl import OpenCLSinoFilter
-from .sinogram_opencl import OpenCLSinoMult
-from .fbp_base import BackprojectorBase
-
-
-class OpenCLBackprojector(BackprojectorBase):
-    default_extra_options = {**BackprojectorBase.default_extra_options, "use_textures": True}
-    backend = "opencl"
-    kernel_filename = "backproj.cl"
-    backend_processing_class = OpenCLProcessing
-    SinoFilterClass = OpenCLSinoFilter
-    SinoMultClass = OpenCLSinoMult
-
-    def _check_textures_availability(self):
-        self._use_textures = self.extra_options.get("use_textures", True) and check_textures_availability(
-            self._processing.ctx
-        )
-
-    def _get_kernel_options(self):
-        super()._get_kernel_options()
-        self._kernel_options.update(
-            {
-                "file_name": get_opencl_srcfile(self.kernel_filename),
-            }
-        )
-
-    def _prepare_kernel_args(self):
-        super()._prepare_kernel_args()
-        block = self.kern_proj_kwargs.pop("block")
-        local_size = block
-        grid = self.kern_proj_kwargs.pop("grid")
-        global_size = (grid[0] * block[0], grid[1] * block[1])
-        # global_size = (updiv(self.n_x, 2), updiv(self.n_y, 2))
-        self.kern_proj_args.insert(0, self._processing.queue)  # OpenCLProcessing.__call__ expects first arg to be queue
-        self.kern_proj_kwargs.update(
-            {
-                "global_size": global_size,
-                "local_size": local_size,
-            }
-        )
-
-    def _prepare_textures(self):
-        if self._use_textures:
-            d_sino_ref = self.d_sino_tex = allocate_texture(self._processing.ctx, self.sino_shape)
-            self._kernel_options["sourcemodule_options"].append("-DUSE_TEXTURES")
-        else:
-            self._d_sino = self._processing.allocate_array("_d_sino", self.sino_shape)
-            d_sino_ref = self._d_sino.data
-        self.kern_proj_args[2] = d_sino_ref
-
-    def _compile_kernels(self):
-        self._prepare_kernel_args()
-        self._prepare_textures()  # has to be done before compilation for OpenCL (to pass -DUSE_TEXTURES)
-        self.kern_proj_args.append(cl.LocalMemory(self._kernel_options["shared_size"]))
-        self.gpu_projector = OpenCLKernel(
-            self._kernel_options["kernel_name"],
-            self._processing.ctx,
-            filename=self._kernel_options["file_name"],
-            options=self._kernel_options["sourcemodule_options"],
-        )
-        if self.halftomo and self.rot_center < self.dwidth:
-            self.sino_mult = OpenCLSinoMult(self.sino_shape, self.rot_center, ctx=self._processing.ctx)
-
-    def _transfer_to_texture(self, sino, do_checks=True):
-        if self._use_textures:
-            return copy_to_texture(self._processing.queue, self.d_sino_tex, sino)
-        else:
-            if id(self._d_sino) == id(sino):
-                return
-            return cl.enqueue_copy(self._processing.queue, self._d_sino.data, sino.data)
-
-    def _set_kernel_slice_arg(self, d_slice):
-        self.kern_proj_args[1] = d_slice