nabu 2024.1.10__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/reconstruction/hbp.py

@@ -0,0 +1,424 @@
+import math
+import numpy as np
+
+from ..utils import get_cuda_srcfile
+from ..cuda.processing import __has_pycuda__
+
+if __has_pycuda__:
+    from ..cuda.kernel import CudaKernel
+    from .sinogram_cuda import CudaSinoMult
+
+from .fbp import CudaBackprojector
+
+
+try:
+    import pycuda.driver as cuda
+    from pycuda import gpuarray as garray
+
+    __have_hbp__ = True
+except:
+    __have_hbp__ = False
+
+
+def buildConebeamGeometry(
+    anglesRad, rotAxisProjectionFromLeftPixelUnits, sourceSampleDistanceVoxelUnits, opticalAxisFromLeftPixelUnits=None
+):
+    """Generate fanbeam/conebeam projection matrices (as required by the backprojector) based on geometry parameters"""
+    if opticalAxisFromLeftPixelUnits is None:
+        if hasattr(rotAxisProjectionFromLeftPixelUnits, "__iter__"):
+            opticalAxisFromLeftPixelUnits = rotAxisProjectionFromLeftPixelUnits[0]
+        else:
+            opticalAxisFromLeftPixelUnits = rotAxisProjectionFromLeftPixelUnits
+
+    t = opticalAxisFromLeftPixelUnits
+    d = sourceSampleDistanceVoxelUnits
+
+    if hasattr(rotAxisProjectionFromLeftPixelUnits, "__iter__"):
+        P_list = [
+            np.array([[0, -t / d, 1, a], [1, 0, 0, 0], [0, -1 / d, 0, 1]], dtype=np.float64)  # pylint: disable=E1130
+            for a in rotAxisProjectionFromLeftPixelUnits
+        ]
+    else:
+        a = rotAxisProjectionFromLeftPixelUnits
+        P_list = [
+            np.array([[0, -t / d, 1, a], [1, 0, 0, 0], [0, -1 / d, 0, 1]], dtype=np.float64)  # pylint: disable=E1130
+        ] * len(anglesRad)
+
+    R = lambda w: np.array(
+        [[1, 0, 0, 0], [0, np.cos(w), np.sin(w), 0], [0, -np.sin(w), np.cos(w), 0], [0, 0, 0, 1]], dtype=np.float64
+    )
+    return np.array([P @ R(-w) for P, w in zip(P_list, anglesRad)])
+
+
+class HierarchicalBackprojector(CudaBackprojector):
+    kernel_filename = "hierarchical_backproj.cu"
+
+    def _init_geometry(self, sino_shape, slice_shape, angles, rot_center, halftomo, slice_roi):
+        super()._init_geometry(sino_shape, slice_shape, angles, rot_center, halftomo, slice_roi)
+        # pylint: disable=E1130 # -angles because different convention for the rotation direction
+        self.angles = -self.angles
+
+        # to do the reconstruction in reduction_steps steps
+        self.reduction_steps = self.extra_options.get("hbp_reduction_steps", 2)
+        reduction_factor = int(math.ceil((sino_shape[-2]) ** (1 / self.reduction_steps)))
+
+        # TODO customize
+        axis_source_meters = 1.0e9
+        voxel_size_microns = 1.0
+        #
+
+        axis_cor = self.extra_options.get("axis_correction", None)
+        if axis_cor is None:
+            axis_cor = 0
+        bpgeometry = buildConebeamGeometry(
+            self.angles, self.rot_center + axis_cor, 1.0e6 * axis_source_meters / voxel_size_microns
+        )
+        self.setup_hbp(bpgeometry, reductionFactor=reduction_factor, legs=self.extra_options.get("hbp_legs", 4))
+
+    def setup_hbp(
+        self,
+        bpgeometry,
+        reductionFactor=20,
+        grid_wh_factors=(1, 1),
+        fac=1,
+        legs=4,
+    ):
+
+        # This implementation seems not to use textures
+        self._use_textures = False
+
+        # for the non texture implementation, this big number will discard texture limitations
+        large_factor_for_non_texture_memory_access = 2**10
+        # TODO: read limits from device info.
+        self.GPU_MAX_GRIDSIZE = 2**15 * large_factor_for_non_texture_memory_access
+        self.GPU_MAX_GRIDS = 2**11 * large_factor_for_non_texture_memory_access
+
+        if self.sino_shape[0] != len(bpgeometry):
+            raise ValueError("self.sino_shape[0] != len(bpgeometry)")
+        if self.sino_shape[0] != len(self.angles):
+            raise ValueError("self.sino_shape[0] != len(self.angles)")
+
+        if self.sino_shape[1] > self.GPU_MAX_GRIDSIZE:
+            raise ValueError(f"self.sino_shape[1] > {self.GPU_MAX_GRIDSIZE} not supported by GPU")
+        if self.sino_shape[0] > self.GPU_MAX_GRIDSIZE:
+            raise ValueError(f"self.sino_shape[0] > {self.GPU_MAX_GRIDSIZE} currently not supported")
+
+        self.reductionFactor = reductionFactor
+        self.legs = legs
+
+        self.bpsetupsH = bpgeometry.astype(np.float32)
+        # self.bpsetupsD = cuda.mem_alloc(self.bpsetupsH.nbytes)
+        # cuda.memcpy_htod(self.bpsetupsD, self.bpsetupsH)
+        self.bpsetupsD = self._processing.to_device("bpsetupsD", self.bpsetupsH)
+
+        # if allocate_cuda_sinogram:
+        #     self.sinogramD = cuda.mem_alloc(self.sino_shape[0] * self.sino_shape[1] * self.float_size)
+        # else:
+        #     self.sinogramD = None
+        self.sinogramD = None
+
+        self.whf = grid_wh_factors
+        if self.sino_shape[1] * 2 * self.whf[0] * fac > self.GPU_MAX_GRIDSIZE:
+            print(f"WARNING: gridsampling limited to {self.GPU_MAX_GRIDSIZE}")
+            self.whf[0] = self.GPU_MAX_GRIDSIZE / (self.sino_shape[1] * 2 * fac)
+
+        ###############################################
+        ########## create intermediate grids ##########
+        ###############################################
+
+        self.reductionFactors = []
+        self.grids = []  # shapes
+        self.gridTransforms = []  # grid-to-world
+        self.gridInvTransforms = []  # world-to-grid
+        self.gridTransformsH = []  # host buffer
+        self.gridTransformsD = []  # device buffer
+
+        ### first level grid: will receive backprojections #
+        ####################################################
+
+        N = self.slice_shape[1] * fac
+
+        angularRange = abs(self.angles.ptp()) / self.sino_shape[0] * reductionFactor
+
+        ngrids = int(math.ceil(self.sino_shape[0] / reductionFactor))
+
+        grid_width = int(
+            np.rint(2 * N * self.whf[0])
+        )  # double sampling to account/compensate for diamond shaped grid of ray-intersections
+        grid_height = int(
+            math.ceil(angularRange * N * self.whf[1])
+        )  # small-angle approximation, generates as much "lines" as needed to account for all intersection levels
+
+        m = (len(self.angles) // reductionFactor) * reductionFactor
+        # TODO: improve angle calculation for more general cases
+        tmpangles = np.angle(
+            np.average(np.exp(1.0j * self.angles[:m].reshape(m // reductionFactor, reductionFactor)), axis=1)
+        )
+
+        tmpangles = np.concatenate((tmpangles, (np.angle(np.average(np.exp(1.0j * self.angles[m:]))),)))[:ngrids]
+        gridAinvT = self._getAinvT(N, grid_height, grid_width)
+        setupRs = self._getRotationMatrices(tmpangles)
+
+        pad = int(math.ceil(ngrids / legs) * legs - ngrids)  # add nan-padding for inline-signaling of unused grids
+        self.gridTransforms += [
+            np.array(
+                [(R @ gridAinvT) for R in setupRs] + [np.ones((3, 3), np.float32) * math.nan] * pad, dtype=np.float32
+            )
+        ]
+        self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
+        self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+        self.reductionFactors += [reductionFactor]
+
+        ### intermediate level grids: accumulation grids ###
+        ####################################################
+
+        # Actual iteration count typically within 1-5. Cf. break condition
+        for i in range(100):
+            # for a reasonable (with regard to memory requirement) grid-aspect ratio in the intermediate levels,
+            # the covered angular range per grid should not exceed 28.6°, i.e.,
+            # fewer than 7 (6.3) or 13 (12.6)  grids for a 180° / 360° scan is not reasonable
+            if int(math.ceil(ngrids / reductionFactor)) < 20:
+                break
+            angularRange *= reductionFactor
+            ngrids = int(math.ceil(ngrids / reductionFactor))
+
+            grid_height = int(
+                math.ceil(angularRange * N * self.whf[1])
+            )  # implicit small angle approximation, whose validity is
+            # asserted by the preceding "break"
+            gridAinvT = self._getAinvT(N, grid_height, grid_width)
+
+            prevAngles = tmpangles
+            m = (len(prevAngles) // reductionFactor) * reductionFactor
+            # TODO: improve angle calculation for more general cases
+            tmpangles = np.angle(
+                np.average(np.exp(1.0j * prevAngles[:m].reshape(m // reductionFactor, reductionFactor)), axis=1)
+            )
+            tmpangles = np.concatenate((tmpangles, (np.angle(np.average(np.exp(1.0j * prevAngles[m:]))),)))[:ngrids]
+            setupRsRed = self._getRotationMatrices(tmpangles)
+
+            pad = int(math.ceil(ngrids / legs) * legs - ngrids)
+            self.gridTransforms += [
+                np.array(
+                    [(R @ gridAinvT) for R in setupRsRed] + [np.ones((3, 3), np.float32) * math.nan] * pad,
+                    dtype=np.float32,
+                )
+            ]
+            self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
+            self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+            self.reductionFactors += [reductionFactor]
+
+        ##### final accumulation grid #################
+        ###############################################
+
+        reductionFactor = ngrids
+        ngrids = 1
+        grid_size = self.slice_shape[1]
+        grid_width = grid_size
+        grid_height = grid_size
+
+        # gridAinvT    = self._getAinvT(N, grid_height, grid_width)
+        gridAinvT = self._getAinvT(N, grid_height, grid_width, 1 / fac)
+
+        self.gridTransforms += [
+            np.array([gridAinvT] * legs, dtype=np.float32)
+        ]  # inflate transform list for convenience in reconstruction loop
+        self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
+        self.grids += [(grid_height, grid_width, ngrids)]
+        self.reductionFactors += [reductionFactor]
+
+        #### accumulation grids #####
+        self.gridTransformsD = []
+        self.gridInvTransformsD = []
+        self.gridsD = []
+
+        max_grid_size = get_max_grid_size(self.grids)
+
+        for i in range(len(self.grids)):
+            gridTransformH = np.array(self.gridTransforms[i][:, :2, :3], dtype=np.float32, order="C").copy()
+            gridInvTransformH = np.array(self.gridInvTransforms[i][:, :2, :3], dtype=np.float32, order="C").copy()
+            self.gridTransformsD.append(self._processing.to_device("gridTransformsD%d " % i, gridTransformH.ravel()))
+            self.gridInvTransformsD.append(
+                self._processing.to_device("gridInvTransformsD%d" % i, gridInvTransformH.ravel())
+            )
+
+            if legs == 1 or i + 1 != (len(self.grids)):
+                if i < 2:
+                    self.gridsD.append(self._processing.allocate_array("gridsD%d" % i, max_grid_size))
+                else:
+                    self.gridsD.append(self.gridsD[i % 2])
+            else:
+                self.gridsD.append(self._processing.allocate_array("gridsD%d" % i, get_max_grid_size(self.grids[-1:])))
+
+        self.imageBufferShape = (grid_size, grid_size)
+        self.imageBufferD = self._processing.allocate_array(
+            "imageBufferD", self.imageBufferShape[0] * self.imageBufferShape[1]
+        )
+        self.imageBufferH = np.zeros(self.imageBufferShape, dtype=np.float32)
+
+    def _getAinvT(self, finalGridWidthAndHeight, currentGridHeight, currentGridWidth, scale=1):
+        N = finalGridWidthAndHeight
+        grid_height = currentGridHeight
+        grid_width = currentGridWidth
+
+        # shifts a texture coordinate from corner origin to center origin
+        T = np.array(((1, 0, -0.5 * (grid_height - 1)), (0, 1, -0.5 * (grid_width - 1)), (0, 0, 1)), dtype=np.float32)
+        # scales texture coordinates (of subsampled grid) into the unit/cooridnate system of a fully sampled grid
+        Ainv = np.array(
+            (((N - 1) / (grid_height - 1) * scale, 0, 0), (0, (N - 1) / (grid_width - 1) * scale, 0), (0, 0, 1)),
+            dtype=np.float32,
+        )
+        return Ainv @ T
+
+    def _getRotationMatrices(self, angles):
+        return [
+            np.array(((np.cos(a), np.sin(a), 0), (-np.sin(a), np.cos(a), 0), (0, 0, 1)), dtype=np.float32)
+            for a in angles
+        ]
+
+    def _compile_kernels(self):
+        # pylint: disable=E0606
+        self.backprojector = CudaKernel(
+            "backprojector",
+            filename=get_cuda_srcfile(self.kernel_filename),
+            signature="PPiiiiPiifPi",
+        )
+        self.aggregator = CudaKernel(
+            "aggregator", filename=get_cuda_srcfile(self.kernel_filename), signature="iPPiiiiPiiiP"
+        )
+        self.clip_outer_circle_kernel = CudaKernel(
+            "clip_outer_circle", filename=get_cuda_srcfile(self.kernel_filename), signature="Pii"
+        )
+        # Duplicate of fbp.py ...
+        if self.halftomo and self.rot_center < self.dwidth:
+            self.sino_mult = CudaSinoMult(self.sino_shape, self.rot_center, ctx=self._processing.ctx)
+        #
+
+    def _set_sino(self, sino, do_checks=True):
+        if do_checks and not (sino.flags.c_contiguous):
+            raise ValueError("Expected C-Contiguous array")
+        else:
+            self._d_sino = self._processing.allocate_array("_d_sino", self.sino_shape)
+            if id(self._d_sino) == id(sino):
+                return
+            self._d_sino[:] = sino[:]
+
+    def backproj(self, sino, output=None, do_checks=True, reference=False):
+        if self.halftomo and self.rot_center < self.dwidth:
+            self.sino_mult.prepare_sino(sino)
+        self._set_sino(sino)
+        lws = (64, 4, 4)
+
+        if reference:
+            gws = getGridSize(self.grids[-1], lws)
+            (grid_height, grid_width, ngrids) = self.grids[-1]
+
+            self.backprojector(
+                self.bpsetupsD,
+                self.gridTransformsD[-1].gpudata,
+                np.int32(self.sino_shape[0]),
+                np.int32(grid_width),
+                np.int32(grid_height),
+                np.int32(ngrids),
+                self.gridsD[-1],
+                np.int32(self.sino_shape[1]),
+                np.int32(self.sino_shape[0]),
+                np.float32(self._backproj_scale_factor),
+                self._d_sino,
+                np.int32(0),  # offset
+                block=lws,
+                grid=gws,
+            )
+
+        else:
+            for leg in list(range(0, self.legs)):
+                gridOffset = leg * self.grids[0][2]
+                projOffset = gridOffset * self.reductionFactors[0]
+                gws = getGridSize(self.grids[0], lws)
+                (grid_height, grid_width, ngrids) = self.grids[0]
+
+                self.backprojector(
+                    self.bpsetupsD,
+                    self.gridTransformsD[0][6 * gridOffset :],
+                    np.int32(self.reductionFactors[0]),
+                    np.int32(grid_width),
+                    np.int32(grid_height),
+                    np.int32(ngrids),
+                    self.gridsD[0],
+                    np.int32(self.sino_shape[1]),
+                    np.int32(self.sino_shape[0]),
+                    np.float32(self._backproj_scale_factor),
+                    self._d_sino,
+                    np.int32(projOffset),
+                    block=lws,
+                    grid=gws,
+                )
+
+                for i in range(1, len(self.grids)):
+                    if self.grids[i][2] >= 8:
+                        lws = (16, 16, 4)
+                    else:
+                        lws = (32, 32, 1)
+
+                    gws = getGridSize(self.grids[i], lws)
+
+                    (new_grid_height, new_grid_width, new_ngrids) = self.grids[i]
+                    (prev_grid_height, prev_grid_width, prev_ngrids) = self.grids[i - 1]
+
+                    gridOffset = leg * self.grids[i][2]
+                    prevGridOffset = leg * self.grids[i - 1][2]
+
+                    self.aggregator(
+                        np.int32((i + 1 == len(self.grids)) and (leg > 0)),
+                        self.gridTransformsD[i][6 * gridOffset :],
+                        self.gridInvTransformsD[i - 1][6 * prevGridOffset :],
+                        np.int32(self.reductionFactors[i]),
+                        np.int32(new_grid_width),
+                        np.int32(new_grid_height),
+                        np.int32(new_ngrids),
+                        self.gridsD[i],
+                        np.int32(prev_grid_width),
+                        np.int32(prev_grid_height),
+                        np.int32(prev_ngrids),
+                        self.gridsD[i - 1],
+                        block=lws,
+                        grid=gws,
+                    )
+
+        if self.extra_options.get("clip_outer_circle", False):
+            lws = (16, 16, 1)
+            ny, nx = self.slice_shape
+            gws = getGridSize((nx, ny, 1), lws)
+            self.clip_outer_circle_kernel(self.gridsD[-1], np.int32(ny), np.int32(nx), block=lws, grid=gws)
+
+        # FIXME pycuda fails to do a discontiguous memcpy for more than 2^31 bytes
+        if self.gridsD[-1].nbytes > 2**31:
+            r1d = self.gridsD[-1].get()
+            r2d = np.ascontiguousarray(r1d.reshape(self.slice_shape))
+            if output is not None:
+                output[:] = r2d[:]
+                return output
+            else:
+                return r2d
+        # --------
+
+        else:
+            return self.gridsD[-1].reshape(self.slice_shape).get(ary=output)
+
+
+def get_max_grid_size(grids):
+    size_max = 0
+    for dims in grids:
+        size = 1
+        for d in dims:
+            size = size * d
+        if size > size_max:
+            size_max = size
+    return size_max
+
+
+def getGridSize(minimum, local):
+    m, l = np.array(minimum), np.array(local)
+    new = (m // l) * l
+    new[new < m] += l[new < m]
+    return tuple(map(int, new // l))

nabu/reconstruction/mlem.py

@@ -0,0 +1,99 @@
+import numpy as np
+
+
+try:
+    import corrct as cct
+
+    __have_corrct__ = True
+except ImportError:
+    __have_corrct__ = False
+
+
+class MLEMReconstructor:
+    """
+    A reconstructor for MLEM reconstruction using the CorrCT toolbox.
+    """
+
+    default_extra_options = {
+        "compute_shifts": False,
+        "tomo_consistency": False,
+        "v_min_for_v_shifts": 0,
+        "v_max_for_v_shifts": None,
+        "v_min_for_u_shifts": 0,
+        "v_max_for_u_shifts": None,
+    }
+
+    def __init__(
+        self,
+        sinos_shape,
+        angles_rad,
+        shifts_uv=None,
+        cor=None,
+        n_iterations=50,
+        extra_options=None,
+    ):
+        """ """
+        if not (__have_corrct__):
+            raise ImportError("Need corrct package")
+        self.angles_rad = angles_rad
+        self.n_iterations = n_iterations
+
+        self._configure_extra_options(extra_options)
+        self._set_sino_shape(sinos_shape)
+        self._set_shifts(shifts_uv, cor)
+
+    def _configure_extra_options(self, extra_options):
+        self.extra_options = self.default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def _set_sino_shape(self, sinos_shape):
+        if len(sinos_shape) != 3:
+            raise ValueError("Expected a 3D shape")
+        self.sinos_shape = sinos_shape
+        self.n_sinos, self.n_angles, self.prj_width = sinos_shape
+        if self.n_angles != len(self.angles_rad):
+            raise ValueError(
+                f"Number of angles ({len(self.angles_rad)}) does not match size of sinograms ({self.n_angles})."
+            )
+
+    def _set_shifts(self, shifts_uv, cor):
+        if shifts_uv is None:
+            self.shifts_uv = np.zeros([self.n_angles, 2])
+        else:
+            if shifts_uv.shape[0] != self.n_angles:
+                raise ValueError(
+                    f"Number of shifts given ({shifts_uv.shape[0]}) does not mathc the number of projections ({self.n_angles})."
+                )
+            self.shifts_uv = shifts_uv.copy()
+        self.cor = cor
+
+    def reconstruct(self, data_vwu):
+        """
+        data_align_vwu: numpy.ndarray or pycuda.gpuarray
+            Raw data, with shape (n_sinograms, n_angles, width)
+        output: optional
+            Output array. If not provided, a new numpy array is returned
+        """
+        if not isinstance(data_vwu, np.ndarray):
+            data_vwu = data_vwu.get()
+        data_vwu /= data_vwu.mean()
+
+        # MLEM recons
+        self.vol_geom_align = cct.models.VolumeGeometry.get_default_from_data(data_vwu)
+        self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
+        # Vertical shifts were handled in pipeline. Set them to ZERO
+        self.shifts_uv[:, 1] = 0.0
+        self.prj_geom_align.set_detector_shifts_vu(self.shifts_uv.T[::-1])
+
+        variances_align = cct.processing.compute_variance_poisson(data_vwu)
+        self.weights_align = cct.processing.compute_variance_weight(variances_align, normalized=True)  # , use_std=True
+        self.data_term_align = cct.data_terms.DataFidelity_wl2(self.weights_align)
+        solver = cct.solvers.MLEM(verbose=True, data_term=self.data_term_align)
+        self.solver_opts = dict(lower_limit=0)  # , x_mask=cct.processing.circular_mask(vol_geom_align.shape_xyz[:-2])
+
+        with cct.projectors.ProjectorUncorrected(
+            self.vol_geom_align, self.angles_rad, rot_axis_shift_pix=self.cor, prj_geom=self.prj_geom_align
+        ) as A:
+            rec, _ = solver(A, data_vwu, iterations=self.n_iterations, **self.solver_opts)
+
+        return rec

nabu/reconstruction/reconstructor.py

@@ -153,6 +153,8 @@ class Reconstructor:
         if self.axis == "x":
             self.backprojector_roi = (self._idx_start, self._idx_end, start_u, end_u)
             start_z, end_z = start_v, end_v
+        else:
+            raise ValueError("Invalid axis")
         self._z_indices = np.arange(start_z, end_z)
         self.output_shape = (
             self._z_indices.size,

nabu/reconstruction/rings_cuda.py

@@ -4,7 +4,6 @@ from ..cuda.processing import CudaProcessing, __has_pycuda__
 from ..processing.padding_cuda import CudaPadding
 from ..processing.fft_cuda import get_fft_class, get_available_fft_implems
 from ..processing.transpose import CudaTranspose
-from ..thirdparty.tomocupy_remove_stripe import remove_all_stripe_pycuda, __have_tomocupy_deringer__
 from .rings import MunchDeringer, SinoMeanDeringer, VoDeringer
 
 if __has_pycuda__:
@@ -18,6 +17,8 @@ try:
 except ImportError:
     __have_pycudwt__ = False
 
+# pylint: disable=E0606
+
 
 class CudaMunchDeringer(MunchDeringer):
     def __init__(
@@ -28,7 +29,7 @@ class CudaMunchDeringer(MunchDeringer):
         wname="db15",
         padding=None,
         padding_mode="edge",
-        fft_backend="skcuda",
+        fft_backend="vkfft",
         cuda_options=None,
     ):
         """
@@ -63,8 +64,8 @@ class CudaMunchDeringer(MunchDeringer):
         self._setup_fw_kernel()
 
     def _check_can_use_wavelets(self):
-        if not (__have_pycudwt__):
-            raise ValueError("Needs pycudwt to use this class")
+        if not (__have_pycudwt__ and __has_pycuda__):
+            raise ValueError("Needs pycuda and pycudwt to use this class")
 
     def _init_padding(self):
         if self.padding is None:
@@ -220,20 +221,22 @@ class CudaVoDeringer(VoDeringer):
     """
 
     def _check_requirement(self):
+        # Do it here, otherwise cupy shows warnings at import even if not used
+        from ..thirdparty.tomocupy_remove_stripe import remove_all_stripe_pycuda, __have_tomocupy_deringer__
+
         if not (__have_tomocupy_deringer__):
             raise ImportError("need cupy")
+        self._remove_all_stripe_pycuda = remove_all_stripe_pycuda
 
     def remove_rings_radios(self, radios):
-        return remove_all_stripe_pycuda(radios, **self._remove_all_stripe_kwargs)
+        return self._remove_all_stripe_pycuda(radios, layout="radios", **self._remove_all_stripe_kwargs)
 
     def remove_rings_sinograms(self, sinos):
-        radios = sinos.transpose(axes=(1, 0, 2))  # view, no copy
-        self.remove_rings_radios(radios)
-        return sinos
+        return self._remove_all_stripe_pycuda(sinos, layout="sinos", **self._remove_all_stripe_kwargs)
 
     def remove_rings_sinogram(self, sino):
-        radios = sino.reshape(sino.shape[0], 1, sino.shape[1])  # no copy
-        self.remove_rings_radios(radios)
+        sinos = sino.reshape((1, sino.shape[0], -1))  # no copy
+        self.remove_rings_sinograms(sinos)
         return sino
 
     remove_rings = remove_rings_sinograms
@@ -261,10 +264,9 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             filename=get_cuda_srcfile("normalization.cu"),
             signature="PPiii",
         )
-        self._mean_kernel_block = (32, 1, 1)
-        self._mean_kernel_grid = [updiv(self.sinos_shape[-1], self._mean_kernel_block[0]), 1, 1]
-        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(1)]
-
+        self._mean_kernel_block = (32, 1, 32)
+        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._mean_kernel_block)]
+        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
         self._mean_kernel_kwargs = {
             "grid": self._mean_kernel_grid,
             "block": self._mean_kernel_block,
@@ -276,11 +278,9 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             signature="PPiii",
             options=["-DGENERIC_OP=%d" % (3 if self.mode == "divide" else 1)],
         )
-        self._op_kernel_block = (16, 16, 1)
-        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[1:][::-1], self._op_kernel_block[:-1])] + [
-            1
-        ]
-        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(1)]
+        self._op_kernel_block = (16, 16, 4)
+        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._op_kernel_block)]
+        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
         self._op_kernel_kwargs = {
             "grid": self._op_kernel_grid,
             "block": self._op_kernel_block,

nabu/reconstruction/sinogram_cuda.py

@@ -188,6 +188,7 @@ class CudaSinoNormalization(SinoNormalization):
             self._d_normalization_array = self.cuda_processing.to_device(
                 "_d_normalization_array", normalization_array.astype("f")
             )
+            # pylint: disable=E0606
             if self.normalization_kind == "subtraction":
                 generic_op_val = 1
             elif self.normalization_kind == "division":

nabu/reconstruction/sinogram_opencl.py

@@ -30,11 +30,13 @@ class OpenCLSinoMult(SinoMult):
 
     def prepare_sino(self, sino):
         sino = self.opencl_processing.set_array("d_sino", sino)
-        self.halftomo_kernel(
+        ev = self.halftomo_kernel(
             self.opencl_processing.queue,
             sino,
             *self._halftomo_kernel_other_args,
             global_size=self._global_size,
             local_size=self._local_size,
         )
+        if self.opencl_processing.device_type == "cpu":
+            ev.wait()
         return sino