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

build/lib/build/lib/nabu/reconstruction/filtering.py

@@ -1,220 +0,0 @@
-from math import pi
-import numpy as np
-from scipy.fft import rfft, irfft
-from silx.image.tomography import compute_fourier_filter, get_next_power
-from ..processing.padding_base import PaddingBase
-from ..utils import check_supported, get_num_threads
-
-# # COMPAT.
-# from .filtering_cuda import CudaSinoFilter
-
-# SinoFilter = deprecated_class(
-#     "From version 2023.1, 'filtering_cuda.CudaSinoFilter' should be used instead of 'filtering.SinoFilter'. In the future, 'filtering.SinoFilter' will be a numpy-only class.",
-#     do_print=True,
-# )(CudaSinoFilter)
-# #
-
-
-class SinoFilter:
-    available_filters = [
-        "ramlak",
-        "shepp-logan",
-        "cosine",
-        "hamming",
-        "hann",
-        "tukey",
-        "lanczos",
-        "hilbert",
-    ]
-
-    """
-    A class for sinogram filtering.
-    It does the following:
-      - pad input array
-      - Fourier transform each row
-      - multiply with a 1D or 2D filter
-      - inverse Fourier transform
-    """
-
-    available_padding_modes = PaddingBase.supported_modes
-    default_extra_options = {"cutoff": 1.0, "fft_threads": 0}  # use all threads by default
-
-    def __init__(
-        self,
-        sino_shape,
-        filter_name=None,
-        padding_mode="zeros",
-        extra_options=None,
-    ):
-        self._init_extra_options(extra_options)
-        self._set_padding_mode(padding_mode)
-        self._calculate_shapes(sino_shape)
-        self._init_fft()
-        self._allocate_memory()
-        self._compute_filter(filter_name)
-
-    def _init_extra_options(self, extra_options):
-        self.extra_options = self.default_extra_options.copy()
-        self.extra_options.update(extra_options or {})
-
-    def _set_padding_mode(self, padding_mode):
-        # Compat.
-        if padding_mode == "edges":
-            padding_mode = "edge"
-        if padding_mode == "zeros":
-            padding_mode = "constant"
-        #
-        check_supported(padding_mode, self.available_padding_modes, "padding mode")
-        self.padding_mode = padding_mode
-
-    def _calculate_shapes(self, sino_shape):
-        self.ndim = len(sino_shape)
-        if self.ndim == 2:
-            n_angles, dwidth = sino_shape
-            n_sinos = 1
-        elif self.ndim == 3:
-            n_sinos, n_angles, dwidth = sino_shape
-        else:
-            raise ValueError("Invalid sinogram number of dimensions")
-        self.sino_shape = sino_shape
-        self.n_angles = n_angles
-        self.dwidth = dwidth
-        # Make sure to use int() here, otherwise pycuda/pyopencl will crash in some cases
-        self.dwidth_padded = int(get_next_power(2 * self.dwidth))
-        self.sino_padded_shape = (n_angles, self.dwidth_padded)
-        if self.ndim == 3:
-            self.sino_padded_shape = (n_sinos,) + self.sino_padded_shape
-        sino_f_shape = list(self.sino_padded_shape)
-        sino_f_shape[-1] = sino_f_shape[-1] // 2 + 1
-        self.sino_f_shape = tuple(sino_f_shape)
-        self.pad_left = (self.dwidth_padded - self.dwidth) // 2
-        self.pad_right = self.dwidth_padded - self.dwidth - self.pad_left
-
-    def _init_fft(self):
-        pass
-
-    def _allocate_memory(self):
-        pass
-
-    def set_filter(self, h_filt, normalize=True):
-        """
-        Set a filter for sinogram filtering.
-
-        Parameters
-        ----------
-        h_filt: numpy.ndarray
-            Array containing the filter. Each line of the sinogram will be filtered with
-            this filter. It has to be the Real-to-Complex Fourier Transform
-            of some real filter, padded to 2*sinogram_width.
-        normalize: bool or float, optional
-            Whether to normalize (multiply) the filter with pi/num_angles.
-        """
-        if h_filt.size != self.sino_f_shape[-1]:
-            raise ValueError(
-                """
-                Invalid filter size: expected %d, got %d.
-                Please check that the filter is the Fourier R2C transform of
-                some real 1D filter.
-                """
-                % (self.sino_f_shape[-1], h_filt.size)
-            )
-        if not (np.iscomplexobj(h_filt)):
-            print("Warning: expected a complex Fourier filter")
-        self.filter_f = h_filt.copy()
-        if normalize:
-            self.filter_f *= pi / self.n_angles
-        self.filter_f = self.filter_f.astype(np.complex64)
-
-    def _compute_filter(self, filter_name):
-        self.filter_name = filter_name or "ram-lak"
-        # TODO add this one into silx
-        if self.filter_name == "hilbert":
-            freqs = np.fft.fftfreq(self.dwidth_padded)
-            filter_f = 1.0 / (2 * pi * 1j) * np.sign(freqs)
-        #
-        else:
-            filter_f = compute_fourier_filter(
-                self.dwidth_padded,
-                self.filter_name,
-                cutoff=self.extra_options["cutoff"],
-            )
-        filter_f = filter_f[: self.dwidth_padded // 2 + 1]  # R2C
-        self.set_filter(filter_f, normalize=True)
-
-    def _check_array(self, arr):
-        if arr.dtype != np.float32:
-            raise ValueError("Expected data type = numpy.float32")
-        if arr.shape != self.sino_shape:
-            raise ValueError("Expected sinogram shape %s, got %s" % (self.sino_shape, arr.shape))
-
-    def filter_sino(self, sino, output=None, no_output=False):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
-            Input sinogram (2D or 3D)
-        output: numpy.ndarray or pycuda.gpuarray.GPUArray, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
-        self._check_array(sino)
-        sino_padded = np.pad(
-            sino, ((0, 0), (0, self.dwidth_padded - self.dwidth)), mode=self.padding_mode
-        )  # pad with a FFT-friendly layout
-        sino_padded_f = rfft(sino_padded, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
-        sino_padded_f *= self.filter_f
-        sino_filtered = irfft(sino_padded_f, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
-        if output is None:
-            res = np.zeros(self.sino_shape, dtype=np.float32)
-        else:
-            res = output
-        if self.ndim == 2:
-            res[:] = sino_filtered[:, : self.dwidth]  # pylint: disable=E1126 # ?!
-        else:
-            res[:] = sino_filtered[:, :, : self.dwidth]  # pylint: disable=E1126 # ?!
-        return res
-
-    __call__ = filter_sino
-
-
-def filter_sinogram(
-    sinogram,
-    padded_width,
-    filter_name="ramlak",
-    padding_mode="constant",
-    normalize=True,
-    filter_cutoff=1.0,
-    **padding_kwargs,
-):
-    """
-    Simple function to filter sinogram.
-
-    Parameters
-    ----------
-    sinogram: numpy.ndarray
-        Sinogram, two dimensional array with shape (n_angles, sino_width)
-    padded_width: int
-        Width to use for padding. Must be greater than sinogram width (i.e than sinogram.shape[-1])
-    filter_name: str, optional
-        Which filter to use. Default is ramlak (roughly equivalent to abs(nu) in frequency domain)
-    padding_mode: str, optional
-        Which padding mode to use. Default is zero-padding.
-    normalize: bool, optional
-        Whether to multiply the filtered sinogram with pi/n_angles
-    filter_cutoff: float, optional
-        frequency cutoff for filter
-    """
-    n_angles, width = sinogram.shape
-    sinogram_padded = np.pad(sinogram, ((0, 0), (0, padded_width - width)), mode=padding_mode, **padding_kwargs)
-    fourier_filter = compute_fourier_filter(padded_width, filter_name, cutoff=filter_cutoff)
-    if normalize:
-        fourier_filter *= np.pi / n_angles
-    fourier_filter = fourier_filter[: padded_width // 2 + 1]  # R2C
-    sino_f = rfft(sinogram_padded, axis=1)
-    sino_f *= fourier_filter
-    sino_filtered = irfft(sino_f, axis=1)[:, :width]  # pylint: disable=E1126 # ?!
-    return sino_filtered

build/lib/build/lib/nabu/reconstruction/filtering_cuda.py

@@ -1,103 +0,0 @@
-import numpy as np
-from ..cuda.processing import CudaProcessing
-from ..utils import get_cuda_srcfile
-from ..processing.padding_cuda import CudaPadding
-from ..processing.fft_cuda import get_fft_class
-from .filtering import SinoFilter
-
-
-class CudaSinoFilter(SinoFilter):
-    default_extra_options = {**SinoFilter.default_extra_options, **{"fft_backend": "skcuda"}}
-
-    def __init__(
-        self,
-        sino_shape,
-        filter_name=None,
-        padding_mode="zeros",
-        extra_options=None,
-        cuda_options=None,
-    ):
-        self._cuda_options = cuda_options or {}
-        self.cuda = CudaProcessing(**self._cuda_options)
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
-        self._init_kernels()
-
-    def _init_fft(self):
-        fft_cls = get_fft_class(self.extra_options["fft_backend"])
-        self.fft = fft_cls(
-            self.sino_padded_shape,
-            dtype=np.float32,
-            axes=(-1,),
-        )
-
-    def _allocate_memory(self):
-        self.d_filter_f = self.cuda.allocate_array("d_filter_f", (self.sino_f_shape[-1],), dtype=np.complex64)
-        self.d_sino_padded = self.cuda.allocate_array("d_sino_padded", self.fft.shape)
-        self.d_sino_f = self.cuda.allocate_array("d_sino_f", self.fft.shape_out, dtype=np.complex64)
-
-    def set_filter(self, h_filt, normalize=True):
-        super().set_filter(h_filt, normalize=normalize)
-        self.d_filter_f[:] = self.filter_f[:]
-
-    def _init_kernels(self):
-        # pointwise complex multiplication
-        fname = get_cuda_srcfile("ElementOp.cu")
-        if self.ndim == 2:
-            kernel_name = "inplace_complex_mul_2Dby1D"
-            kernel_sig = "PPii"
-        else:
-            kernel_name = "inplace_complex_mul_3Dby1D"
-            kernel_sig = "PPiii"
-        self.mult_kernel = self.cuda.kernel(kernel_name, filename=fname, signature=kernel_sig)
-        self.kern_args = (self.d_sino_f, self.d_filter_f)
-        self.kern_args += self.d_sino_f.shape[::-1]
-        # padding
-        self.padding_kernel = CudaPadding(
-            self.sino_shape,
-            ((0, 0), (self.pad_left, self.pad_right)),
-            mode=self.padding_mode,
-            cuda_options=self._cuda_options,
-        )
-
-    def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
-            Input sinogram (2D or 3D)
-        output: pycuda.gpuarray.GPUArray, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
-        self._check_array(sino)
-        if not (isinstance(sino, self.cuda.array_class)):
-            sino = self.cuda.set_array("sino", sino)
-
-        # Padding
-        self.padding_kernel(sino, output=self.d_sino_padded)
-
-        # FFT
-        self.fft.fft(self.d_sino_padded, output=self.d_sino_f)
-
-        # multiply padded sinogram with filter in the Fourier domain
-        self.mult_kernel(*self.kern_args)  # TODO tune block size ?
-
-        # iFFT
-        self.fft.ifft(self.d_sino_f, output=self.d_sino_padded)
-
-        # return
-        if output is None:
-            res = self.cuda.allocate_array("output", self.sino_shape)
-        else:
-            res = output
-        if self.ndim == 2:
-            res[:] = self.d_sino_padded[:, self.pad_left : self.pad_left + self.dwidth]
-        else:
-            res[:] = self.d_sino_padded[:, :, self.pad_left : self.pad_left + self.dwidth]
-        return res
-
-    __call__ = filter_sino

build/lib/build/lib/nabu/reconstruction/filtering_opencl.py

@@ -1,111 +0,0 @@
-import numpy as np
-from ..utils import get_opencl_srcfile
-from ..opencl.processing import OpenCLProcessing
-from ..processing.padding_opencl import OpenCLPadding
-from ..opencl.memcpy import OpenCLMemcpy2D
-from .filtering import SinoFilter
-
-try:
-    from pyvkfft.opencl import VkFFTApp as clfft  # pylint: disable=E0401
-
-    __has_vkfft__ = True
-except:
-    __has_vkfft__ = False
-
-
-class OpenCLSinoFilter(SinoFilter):
-    def __init__(
-        self,
-        sino_shape,
-        filter_name=None,
-        padding_mode="zeros",
-        extra_options=None,
-        opencl_options=None,
-    ):
-        self._opencl_options = opencl_options or {}
-        self.opencl = OpenCLProcessing(**self._opencl_options)
-        self.queue = self.opencl.queue
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
-        self._init_kernels()
-
-    def _init_fft(self):
-        if not (__has_vkfft__):
-            raise ImportError("Please install pyvkfft to use this class")
-        self.fft = clfft(self.sino_padded_shape, np.float32, self.queue, r2c=True, ndim=1, inplace=False)
-
-    def _allocate_memory(self):
-        self.d_sino_padded = self.opencl.allocate_array("d_sino_padded", self.sino_padded_shape, dtype=np.float32)
-        self.d_sino_f = self.opencl.allocate_array("d_sino_f", self.sino_f_shape, np.complex64)
-        self.d_filter_f = self.opencl.allocate_array("d_filter_f", (self.sino_f_shape[-1],), dtype=np.complex64)
-
-    def set_filter(self, h_filt, normalize=True):
-        super().set_filter(h_filt, normalize=normalize)
-        self.d_filter_f[:] = self.filter_f[:]
-
-    def _init_kernels(self):
-        # pointwise complex multiplication
-        fname = get_opencl_srcfile("ElementOp.cl")
-        if self.ndim == 2:
-            kernel_name = "inplace_complex_mul_2Dby1D"
-        else:
-            kernel_name = "inplace_complex_mul_3Dby1D"
-        self.mult_kernel = self.opencl.kernel(kernel_name, filename=fname)
-        # padding
-        self.padding_kernel = OpenCLPadding(
-            self.sino_shape,
-            ((0, 0), (self.pad_left, self.pad_right)),
-            mode=self.padding_mode,
-            opencl_options={"queue": self.queue},
-        )
-        # memcpy2D
-        self.memcpy2D = OpenCLMemcpy2D(queue=self.queue)
-
-    def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pyopencl.array
-            Input sinogram (2D or 3D)
-        output: pyopencl.array, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
-        self._check_array(sino)
-        sino = self.opencl.set_array("sino", sino)
-
-        # Padding
-        self.padding_kernel.pad(sino, output=self.d_sino_padded)
-
-        # FFT
-        self.fft.fft(self.d_sino_padded, self.d_sino_f)
-
-        # multiply padded sinogram with filter in the Fourier domain
-        self.mult_kernel(
-            self.queue,
-            self.d_sino_f,
-            self.d_filter_f,
-            *(np.int32(self.d_sino_f.shape[::-1])),  # pylint: disable=E1133
-            # local_size=None,
-            global_size=self.d_sino_f.shape[::-1],
-        )  # TODO tune block size ?
-
-        # iFFT
-        self.fft.ifft(self.d_sino_f, self.d_sino_padded)
-
-        # return
-        if output is None:
-            res = self.opencl.allocate_array("output", self.sino_shape)
-        else:
-            res = output
-        if self.ndim == 2:
-            # res[:] = self.d_sino_padded[:, self.pad_left : self.pad_left + self.dwidth]
-            self.memcpy2D(res, self.d_sino_padded, res.shape[::-1], src_offset_xy=(self.pad_left, 0))
-        else:
-            res[:] = self.d_sino_padded[:, :, self.pad_left : self.pad_left + self.dwidth]
-        return res
-
-    __call__ = filter_sino

build/lib/build/lib/nabu/reconstruction/projection.py

@@ -1,240 +0,0 @@
-import numpy as np
-import pycuda.driver as cuda
-import pycuda.gpuarray as garray
-from ..utils import updiv, get_cuda_srcfile
-from ..cuda.utils import copy_array
-from ..cuda.kernel import CudaKernel
-from ..cuda.processing import CudaProcessing
-
-_sizeof_float32 = np.dtype(np.float32).itemsize
-
-
-class Projector:
-    """
-    A class for performing a tomographic projection (Radon Transform) using Cuda.
-    """
-
-    _projector_name = "joseph_projector"
-    _projector_signature = "PiiPfPPPPiiifii"
-
-    def __init__(
-        self,
-        slice_shape,
-        angles,
-        rot_center=None,
-        detector_width=None,
-        normalize=False,
-        extra_options=None,
-        cuda_options=None,
-    ):
-        """
-        Initialize a Cuda tomography forward projector.
-
-        Parameters
-        -----------
-
-        slice_shape: tuple
-            Shape of the slice: (num_rows, num_columns).
-        angles: int or sequence
-            Either an integer number of angles, or a list of custom angles values in radian.
-        param rot_center: float, optional
-            Rotation axis position. Default is `(shape[1]-1)/2.0`.
-        detector_width: int, optional
-            Detector width in pixels.
-            If `detector_width > slice_shape[1]`, the  projection data will be surrounded with zeros.
-            Using `detector_width < slice_shape[1]` might result in a local tomography setup.
-        normalize: bool, optional
-            Whether to normalize projection.
-            If set to True, sinograms are multiplied by the factor pi/(2*nprojs).
-        extra_options: dict, optional
-            Current allowed options:
-                offset_x, axis_corrections
-        cuda_options: dict, optional
-            Cuda options passed to the CudaProcessing class.
-        """
-        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
-        self._configure_extra_options(extra_options)
-        self._init_geometry(slice_shape, rot_center, angles, detector_width)
-        self.normalize = normalize
-        self._allocate_memory()
-        self._compute_angles()
-        self._proj_precomputations()
-        self._compile_kernels()
-
-    def _configure_extra_options(self, extra_options):
-        self.extra_options = {
-            "offset_x": None,
-            "axis_corrections": None,  # TODO
-        }
-        extra_opts = extra_options or {}
-        self.extra_options.update(extra_opts)
-
-    def _init_geometry(self, slice_shape, rot_center, angles, detector_width):
-        if np.isscalar(slice_shape):
-            slice_shape = (slice_shape, slice_shape)
-        self.shape = slice_shape
-        if np.isscalar(angles):
-            angles = np.linspace(0, np.pi, angles, endpoint=False, dtype="f")
-        self.angles = angles
-        self.nprojs = len(angles)
-        self.dwidth = detector_width or self.shape[1]
-        self.sino_shape = (self.nprojs, self.dwidth)
-
-        # In PYHST (c_hst_project_1over.cu), axis_pos is overwritten to (dimslice-1)/2.
-        # So tuning axis position is done in another way. In CCspace.c:
-        # offset_x = start_x - move_x
-        # start_x = start_voxel_1 (zero-based, so 0 by default)
-        # MOVE_X = start_x + (num_x - 1)/2 -  ROTATION_AXIS_POSITION;
-        self.axis_pos = self.rot_center = rot_center or (self.shape[1] - 1) / 2.0
-        self.offset_x = self.extra_options["offset_x"] or np.float32(self.axis_pos - (self.shape[1] - 1) / 2.0)
-        self.axis_pos0 = np.float32((self.shape[1] - 1) / 2.0)
-
-    def _allocate_memory(self):
-        self.dimgrid_x = updiv(self.dwidth, 16)
-        self.dimgrid_y = updiv(self.nprojs, 16)
-        self._dimrecx = self.dimgrid_x * 16
-        self._dimrecy = self.dimgrid_y * 16
-        self.d_sino = garray.zeros((self._dimrecy, self._dimrecx), np.float32)
-        self.d_angles = garray.zeros((self._dimrecy,), np.float32)
-        self._d_beginPos = garray.zeros((2, self._dimrecy), np.int32)
-        self._d_strideJoseph = garray.zeros((2, self._dimrecy), np.int32)
-        self._d_strideLine = garray.zeros((2, self._dimrecy), np.int32)
-        self.d_axis_corrections = garray.zeros((self.nprojs,), np.float32)
-        if self.extra_options.get("axis_corrections", None) is not None:
-            self.d_axis_corrections.set(self.extra_options["axis_corrections"])
-
-        # Textures
-        self.d_image_cua = cuda.np_to_array(np.zeros((self.shape[0] + 2, self.shape[1] + 2), "f"), "C")
-
-    def _compile_kernels(self):
-        self.gpu_projector = CudaKernel(
-            self._projector_name,
-            filename=get_cuda_srcfile("proj.cu"),
-        )
-        self.texref_slice = self.gpu_projector.module.get_texref("texSlice")
-        self.texref_slice.set_array(self.d_image_cua)
-        self.texref_slice.set_filter_mode(cuda.filter_mode.LINEAR)
-        self.gpu_projector.prepare(self._projector_signature, [self.texref_slice])
-
-        self.kernel_args = (
-            self.d_sino.gpudata,
-            np.int32(self.shape[1]),
-            np.int32(self.dwidth),
-            self.d_angles.gpudata,
-            np.float32(self.axis_pos0),
-            self.d_axis_corrections.gpudata,
-            self._d_beginPos.gpudata,
-            self._d_strideJoseph.gpudata,
-            self._d_strideLine.gpudata,
-            np.int32(self.nprojs),
-            np.int32(self._dimrecx),
-            np.int32(self._dimrecy),
-            self.offset_x,
-            np.int32(1),  # josephnoclip, 1 by default
-            np.int32(self.normalize),
-        )
-        self._proj_kernel_blk = (16, 16, 1)
-        self._proj_kernel_grd = (self.dimgrid_x, self.dimgrid_y, 1)
-
-    def _compute_angles(self):
-        angles2 = np.zeros(self._dimrecy, dtype=np.float32)  # dimrecy != num_projs
-        angles2[: self.nprojs] = np.copy(self.angles)
-        angles2[self.nprojs :] = angles2[self.nprojs - 1]
-        self.angles2 = angles2
-        self.d_angles[:] = angles2[:]
-
-    def _proj_precomputations(self):
-        beginPos = np.zeros((2, self._dimrecy), dtype=np.int32)
-        strideJoseph = np.zeros((2, self._dimrecy), dtype=np.int32)
-        strideLine = np.zeros((2, self._dimrecy), dtype=np.int32)
-        cos_angles = np.cos(self.angles2)
-        sin_angles = np.sin(self.angles2)
-        dimslice = self.shape[1]
-
-        M1 = np.abs(cos_angles) > 0.70710678
-        M1b = np.logical_not(M1)
-        M2 = cos_angles > 0
-        M2b = np.logical_not(M2)
-        M3 = sin_angles > 0
-        M3b = np.logical_not(M3)
-        case1 = M1 * M2
-        case2 = M1 * M2b
-        case3 = M1b * M3
-        case4 = M1b * M3b
-
-        beginPos[:, case1] = 0
-        strideJoseph[0][case1] = 1
-        strideJoseph[1][case1] = 0
-        strideLine[0][case1] = 0
-        strideLine[1][case1] = 1
-
-        beginPos[:, case2] = dimslice - 1
-        strideJoseph[0][case2] = -1
-        strideJoseph[1][case2] = 0
-        strideLine[0][case2] = 0
-        strideLine[1][case2] = -1
-
-        beginPos[0][case3] = dimslice - 1
-        beginPos[1][case3] = 0
-        strideJoseph[0][case3] = 0
-        strideJoseph[1][case3] = 1
-        strideLine[0][case3] = -1
-        strideLine[1][case3] = 0
-
-        beginPos[0][case4] = 0
-        beginPos[1][case4] = dimslice - 1
-        strideJoseph[0][case4] = 0
-        strideJoseph[1][case4] = -1
-        strideLine[0][case4] = 1
-        strideLine[1][case4] = 0
-
-        self._d_beginPos.set(beginPos)
-        self._d_strideJoseph.set(strideJoseph)
-        self._d_strideLine.set(strideLine)
-
-    def _check_input_array(self, image):
-        if image.shape != self.shape:
-            raise ValueError("Expected slice shape = %s, got %s" % (str(self.shape), str(image.shape)))
-        if image.dtype != np.dtype("f"):
-            raise ValueError("Expected float32 data type, got %s" % str(image.dtype))
-        if not isinstance(image, (np.ndarray, garray.GPUArray)):
-            raise ValueError("Expected either numpy.ndarray or pyopencl.array.Array")
-        if isinstance(image, np.ndarray):
-            if not image.flags["C_CONTIGUOUS"]:
-                raise ValueError("Please use C-contiguous arrays")
-
-    def set_image(self, image, check=True):
-        if check:
-            self._check_input_array(image)
-        copy_array(
-            self.d_image_cua,
-            image,
-            dst_x_in_bytes=_sizeof_float32,
-            dst_y=1,
-            check=False,  # cannot check when using offsets
-        )
-
-    def projection(self, image, output=None, do_checks=True):
-        """
-        Perform the projection of an image.
-
-        Parameters
-        -----------
-        image: array
-            Image to forward project
-        output: array, optional
-            Output image
-        """
-
-        self.set_image(image, check=do_checks)
-        self.gpu_projector(*self.kernel_args, grid=self._proj_kernel_grd, block=self._proj_kernel_blk)
-
-        if output is None:
-            res = self.d_sino.get()
-            res = res[: self.nprojs, : self.dwidth]  # copy ?
-        else:
-            output[:, :] = self.d_sino[: self.nprojs, : self.dwidth]
-            res = output
-        return res
-
-    __call__ = projection