nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/reconstruction/fbp_base.py

@@ -1,6 +1,6 @@
 import numpy as np
 from ..utils import updiv, nextpow2, convert_index, deprecation_warning
-from ..misc.processing_base import ProcessingBase
+from ..processing.processing_base import ProcessingBase
 from .filtering import SinoFilter
 from .sinogram import SinoMult
 from .sinogram import get_extended_sinogram_width
@@ -107,6 +107,7 @@ class BackprojectorBase:
         """
         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()
@@ -163,8 +164,8 @@ class BackprojectorBase:
         # move = 0 if not(centered_axis) else start + (n-1)/2. - c
         if self.extra_options["centered_axis"]:
             self.offsets = {
-                "x": round(self.rot_center - (self.n_x - 1) / 2.0),
-                "y": round(self.rot_center - (self.n_y - 1) / 2.0),
+                "x": self.rot_center - (self.n_x - 1) / 2.0,
+                "y": self.rot_center - (self.n_y - 1) / 2.0,
             }
         #
         self._set_axis_corr()
@@ -214,8 +215,8 @@ class BackprojectorBase:
         # 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"])
+        # 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")
@@ -262,14 +263,19 @@ class BackprojectorBase:
         """
         self.rot_center = rot_center
         self.axis_pos = rot_center
-        self.kern_proj_args[3] = 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": round(self.rot_center - (self.n_x - 1) / 2.0),
-                "y": round(self.rot_center - (self.n_y - 1) / 2.0),
+                "x": self.rot_center - (self.n_x - 1) / 2.0,
+                "y": self.rot_center - (self.n_y - 1) / 2.0,
             }
-            self.kern_proj_args[6] = self.offsets["x"]
-            self.kern_proj_args[7] = self.offsets["y"]
+            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,
@@ -306,13 +312,14 @@ class BackprojectorBase:
         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.int32(self.offsets["x"]),
-            np.int32(self.offsets["y"]),
+            np.float32(self.offsets["x"]),
+            np.float32(self.offsets["y"]),
             self._d_cos,
             self._d_msin,
             np.float32(self._backproj_scale_factor),
@@ -353,16 +360,28 @@ class BackprojectorBase:
             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:
-            self.sino_filter(sino, output=self._d_sino)
+            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:
-            self._d_sino[:] = sino[:]  # we might avoid a memcopy here
-        return self.backproj(self._d_sino, output=output)
+            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=%f, halftomo=%s)" % (
+        res = "%s(sino_shape=%s, slice_shape=%s, rot_center=%.2f, halftomo=%s)" % (
             self.__class__.__name__,
             str(self.sino_shape),
             str(self.slice_shape),

nabu/reconstruction/fbp_opencl.py

@@ -16,13 +16,10 @@ class OpenCLBackprojector(BackprojectorBase):
     SinoFilterClass = OpenCLSinoFilter
     SinoMultClass = OpenCLSinoMult
 
-    def reset_rot_center(self, rot_center):
-        """
-        Define a new center of rotation for the current backprojector.
-        """
-        bp = self.backprojector
-        bp.axis_pos = rot_center
-        bp.kern_proj_args[2] = rot_center
+    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()
@@ -48,15 +45,13 @@ class OpenCLBackprojector(BackprojectorBase):
         )
 
     def _prepare_textures(self):
-        self._use_textures = self.extra_options.get("use_textures", True) and check_textures_availability(
-            self._processing.ctx
-        )
         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.insert(2, d_sino_ref)
+        self.kern_proj_args[2] = d_sino_ref
 
     def _compile_kernels(self):
         self._prepare_kernel_args()
@@ -77,7 +72,7 @@ class OpenCLBackprojector(BackprojectorBase):
         else:
             if id(self._d_sino) == id(sino):
                 return
-            return cl.enqueue_copy(self._processing.queue, self._d_sino.data, sino)
+            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

nabu/reconstruction/filtering.py

@@ -2,8 +2,8 @@ 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 ..misc.padding_base import PaddingBase
-from ..utils import check_supported, get_num_threads, deprecated_class
+from ..processing.padding_base import PaddingBase
+from ..utils import check_supported, get_num_threads
 
 # # COMPAT.
 # from .filtering_cuda import CudaSinoFilter

nabu/reconstruction/filtering_cuda.py

@@ -1,13 +1,14 @@
-import pycuda.gpuarray as garray
 import numpy as np
-from ..cuda.kernel import CudaKernel
 from ..cuda.processing import CudaProcessing
 from ..utils import get_cuda_srcfile
-from ..cuda.padding import CudaPadding
+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,
@@ -16,26 +17,23 @@ class CudaSinoFilter(SinoFilter):
         extra_options=None,
         cuda_options=None,
     ):
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
         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):
-        # Import has to be done here, otherwise scikit-cuda creates a cuda/cublas context at import
-        from silx.math.fft.cufft import CUFFT
-
-        #
-        self.fft = CUFFT(
+        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 = garray.zeros((self.sino_f_shape[-1],), np.complex64)
-        self.d_sino_padded = self.fft.data_in
-        self.d_sino_f = self.fft.data_out
+        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)
@@ -50,7 +48,7 @@ class CudaSinoFilter(SinoFilter):
         else:
             kernel_name = "inplace_complex_mul_3Dby1D"
             kernel_sig = "PPiii"
-        self.mult_kernel = CudaKernel(kernel_name, filename=fname, signature=kernel_sig)
+        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
@@ -76,7 +74,8 @@ class CudaSinoFilter(SinoFilter):
             in self.d_sino_padded.
         """
         self._check_array(sino)
-        d_sino = sino = self.cuda.set_array("sino", 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)

nabu/reconstruction/filtering_opencl.py

@@ -1,13 +1,12 @@
 import numpy as np
 from ..utils import get_opencl_srcfile
-from ..opencl.kernel import OpenCLKernel
 from ..opencl.processing import OpenCLProcessing
-from ..opencl.padding import OpenCLPadding
+from ..processing.padding_opencl import OpenCLPadding
 from ..opencl.memcpy import OpenCLMemcpy2D
 from .filtering import SinoFilter
 
 try:
-    from pyvkfft.opencl import VkFFTApp as clfft
+    from pyvkfft.opencl import VkFFTApp as clfft  # pylint: disable=E0401
 
     __has_vkfft__ = True
 except:
@@ -50,7 +49,7 @@ class OpenCLSinoFilter(SinoFilter):
             kernel_name = "inplace_complex_mul_2Dby1D"
         else:
             kernel_name = "inplace_complex_mul_3Dby1D"
-        self.mult_kernel = OpenCLKernel(kernel_name, self.opencl.ctx, filename=fname)
+        self.mult_kernel = self.opencl.kernel(kernel_name, filename=fname)
         # padding
         self.padding_kernel = OpenCLPadding(
             self.sino_shape,

nabu/reconstruction/projection.py

@@ -100,6 +100,8 @@ class Projector:
         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")

nabu/reconstruction/rings.py

@@ -1,6 +1,16 @@
 import numpy as np
+from scipy.fft import rfft, irfft
+from silx.image.tomography import get_next_power
 from ..thirdparty.pore3d_deringer_munch import munchetal_filter
-from ..utils import get_2D_3D_shape
+from ..utils import get_2D_3D_shape, get_num_threads, check_supported
+from ..misc.fourier_filters import get_bandpass_filter
+
+try:
+    from algotom.prep.removal import remove_all_stripe
+
+    __has_algotom__ = True
+except ImportError:
+    __has_algotom__ = False
 
 
 class MunchDeringer:
@@ -89,3 +99,150 @@ class MunchDeringer:
         for i in range(n_sinos):
             self._destripe_2D(sinos[i], output[i])
         return output
+
+
+class VoDeringer:
+    """
+    An interface to Nghia Vo's "remove_all_stripe".
+    Needs algotom to run.
+    """
+
+    def __init__(self, sinos_shape, **remove_all_stripe_options):
+        self._check_requirement()
+        self._get_shapes(sinos_shape)
+        self._remove_all_stripe_kwargs = remove_all_stripe_options
+
+    def _check_requirement(self):
+        if not __has_algotom__:
+            raise ImportError("Need algotom")
+
+    def _get_shapes(self, sinos_shape):
+        n_z, n_a, n_x = get_2D_3D_shape(sinos_shape)
+        self.sinos_shape = n_z, n_a, n_x
+        self.n_angles = n_a
+        self.n_z = n_z
+        self.n_x = n_x
+
+    def remove_rings_sinogram(self, sino, output=None):
+        new_sino = remove_all_stripe(sino, **self._remove_all_stripe_kwargs)  # out-of-place
+        if output is not None:
+            output[:] = new_sino[:]
+            return output
+        return new_sino
+
+    def remove_rings_sinograms(self, sinos, output=None):
+        if output is None:
+            output = sinos
+        for i in range(sinos.shape[0]):
+            output[i] = self.remove_rings_sinogram(sinos[i])
+        return output
+
+    def remove_rings_radios(self, radios):
+        sinos = np.moveaxis(radios, 1, 0)  # (n_a, n_z, n_x) --> (n_z, n_a, n_x)
+        return self.remove_rings_sinograms(sinos)
+
+    remove_rings = remove_rings_sinograms
+
+
+class SinoMeanDeringer:
+    supported_modes = ["subtract", "divide"]
+
+    def __init__(self, sinos_shape, mode="subtract", filter_cutoff=None, padding_mode="edge", fft_num_threads=None):
+        """
+        Rings correction with mean subtraction/division.
+        The principle of this method is to subtract (or divide) the sinogram by its mean along a certain axis.
+        In short:
+          sinogram -= filt(sinogram.mean(axis=0))
+        where `filt` is some bandpass filter.
+
+        Parameters
+        ----------
+        sinos_shape: tuple of int
+            Sinograms shape, in the form (n_angles, n_x) or (n_sinos, n_angles, n_x)
+        mode: str, optional
+            Operation to do on the sinogram, either "subtract" or "divide"
+        filter_cutoff: tuple, optional
+            Cut-off of the bandpass filter applied on the sinogram profiles.
+            Empty (default) means no filtering.
+            Possible values forms are:
+              - (sigma_low, sigma_high): two float values defining the standard deviation of
+                gaussian(sigma_low) * (1 - gaussian(sigma_high)).
+                High values of sigma mean stronger effect of associated filters.
+              - ((cutoff_low, transition_low), (cutoff_high, transition_high))
+                where "cutoff" is in normalized Nyquist frequency (0.5 is the maximum frequency),
+                and "transition" is the width of filter decay in fraction of the cutoff frequency
+        padding_mode: str, optional
+            Padding mode when filtering the sinogram profile.
+            Should be "constant" (i.e "zeros") for mathematical correctness,
+            but in practice this yields a Gibbs effect when replicating the sinogram, so "edges" is recommended.
+        fft_num_threads: int, optional
+            How many threads to use for computing the fast Fourier transform when filtering the sinogram profile.
+            Defaut is all the available threads.
+        """
+        self._get_shapes(sinos_shape)
+        check_supported(mode, self.supported_modes, "operation mode")
+        self.mode = mode
+        self._init_filter(filter_cutoff, fft_num_threads, padding_mode)
+
+    def _get_shapes(self, sinos_shape):
+        n_z, n_a, n_x = get_2D_3D_shape(sinos_shape)
+        self.sinos_shape = n_z, n_a, n_x
+        self.n_angles = n_a
+        self.n_z = n_z
+        self.n_x = n_x
+
+    def _init_filter(self, filter_cutoff, fft_num_threads, padding_mode):
+        self.filter_cutoff = filter_cutoff
+        self._filter_f = None
+        if filter_cutoff is None:
+            return
+        self._filter_size = get_next_power(self.n_x * 2)
+        self._filter_f = get_bandpass_filter(
+            (1, self._filter_size),
+            cutoff_lowpass=filter_cutoff[0],
+            cutoff_highpass=filter_cutoff[1],
+            use_rfft=True,
+            data_type=np.float32,
+        ).ravel()
+        self._fft_n_threads = get_num_threads(fft_num_threads)
+        # compat
+        if padding_mode == "edges":
+            padding_mode = "edge"
+        #
+        self.padding_mode = padding_mode
+        size_diff = self._filter_size - self.n_x
+        self._pad_left, self._pad_right = size_diff // 2, size_diff - size_diff // 2
+
+    def _apply_filter(self, sino_profile):
+        if self._filter_f is None:
+            return sino_profile
+
+        sino_profile = np.pad(sino_profile, (self._pad_left, self._pad_right), mode=self.padding_mode)
+
+        sino_f = rfft(sino_profile, workers=self._fft_n_threads)
+        sino_f *= self._filter_f
+
+        return irfft(sino_f, workers=self._fft_n_threads)[self._pad_left : -self._pad_right]  # ascontiguousarray ?
+
+    def remove_rings_sinogram(self, sino, output=None):
+        #
+        if output is not None:
+            raise NotImplementedError
+        #
+        sino_profile = sino.mean(axis=0)
+        sino_profile = self._apply_filter(sino_profile)
+        if self.mode == "subtract":
+            sino -= sino_profile
+        elif self.mode == "divide":
+            sino /= sino_profile
+        return sino
+
+    def remove_rings_sinograms(self, sinos, output=None):
+        #
+        if output is not None:
+            raise NotImplementedError
+        #
+        for i in range(sinos.shape[0]):
+            self.remove_rings_sinogram(sinos[i])
+
+    remove_rings = remove_rings_sinograms