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

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

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

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

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

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