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

nabu/{misc → processing}/tests/test_rotation.py

@@ -1,7 +1,8 @@
 import numpy as np
 import pytest
 from nabu.testutils import generate_tests_scenarios
-from nabu.misc.rotation import Rotation, __have__skimage__
+from nabu.processing.rotation_cuda import Rotation
+from nabu.processing.rotation import __have__skimage__
 from nabu.cuda.utils import __has_pycuda__, get_cuda_context
 
 if __have__skimage__:
@@ -10,7 +11,7 @@ if __have__skimage__:
 
     ny, nx = chelsea().shape[:2]
 if __has_pycuda__:
-    from nabu.misc.rotation_cuda import CudaRotation
+    from nabu.processing.rotation_cuda import CudaRotation
     import pycuda.gpuarray as garray
 
 if __have__skimage__:

nabu/processing/tests/test_transpose.py

@@ -0,0 +1,72 @@
+import numpy as np
+import pytest
+from nabu.cuda.utils import get_cuda_context, __has_pycuda__
+from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
+from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.processing.transpose import CudaTranspose, OpenCLTranspose
+
+configs = {
+    "shape": [(300, 451), (300, 300), (255, 300)],
+    "output_is_none": [True, False],
+    "dtype_in_out": [(np.float32, np.float32)],
+}
+
+if __do_long_tests__:
+    configs["dtype_in_out"].extend(
+        [(np.float32, np.complex64), (np.complex64, np.complex64), (np.uint8, np.uint16), (np.uint8, np.int32)]
+    )
+
+scenarios = generate_tests_scenarios(configs)
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.data = get_data("chelsea.npz")["data"]
+    cls.tol = 1e-7
+    if __has_pycuda__:
+        cls.cu_ctx = get_cuda_context(cleanup_at_exit=False)
+    if __has_pyopencl__:
+        cls.cl_ctx = get_opencl_context(device_type="all")
+    yield
+    if __has_pycuda__:
+        cls.cu_ctx.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestTranspose:
+    def _do_test_transpose(self, config, transpose_cls):
+        shape = config["shape"]
+        dtype = config["dtype_in_out"][0]
+        dtype_out = config["dtype_in_out"][1]
+        data = np.ascontiguousarray(self.data[: shape[0], : shape[1]], dtype=dtype)
+
+        backend = transpose_cls.backend
+        if backend == "opencl" and not (np.iscomplexobj(dtype(1))) and np.iscomplexobj(dtype_out(1)):
+            pytest.skip("pyopencl does not support real to complex scalar cast")
+        ctx = self.cu_ctx if backend == "cuda" else self.cl_ctx
+        backend_options = {"ctx": ctx}
+        transpose = transpose_cls(data.shape, dtype, dst_dtype=dtype_out, **backend_options)
+
+        d_data = transpose.processing.allocate_array("data", shape, dtype)
+        d_data.set(data)
+        if config["output_is_none"]:
+            d_out = None
+        else:
+            d_out = transpose.processing.allocate_array("output", shape[::-1], dtype_out)
+
+        d_res = transpose(d_data, dst=d_out)
+
+        assert (
+            np.max(np.abs(d_res.get() - data.T)) == 0
+        ), "something wrong with transpose(shape=%s, dtype=%s, dtype_out=%s)" % (shape, dtype, dtype_out)
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need pycuda for this test")
+    @pytest.mark.parametrize("config", scenarios)
+    def test_cuda_transpose(self, config):
+        self._do_test_transpose(config, CudaTranspose)
+
+    @pytest.mark.skipif(not (__has_pyopencl__), reason="Need pyopencl for this test")
+    @pytest.mark.parametrize("config", scenarios)
+    def test_opencl_transpose(self, config):
+        self._do_test_transpose(config, OpenCLTranspose)

nabu/{misc → processing}/tests/test_unsharp.py

@@ -1,7 +1,8 @@
+from itertools import product
 import numpy as np
 import pytest
-from nabu.misc.unsharp import UnsharpMask
-from nabu.misc.unsharp_opencl import OpenclUnsharpMask, __have_opencl__ as __has_pyopencl__
+from nabu.processing.unsharp import UnsharpMask
+from nabu.processing.unsharp_opencl import OpenclUnsharpMask, __have_opencl__ as __has_pyopencl__
 from nabu.cuda.utils import __has_pycuda__, get_cuda_context
 from nabu.testutils import get_data
 
@@ -11,13 +12,21 @@ if __has_pyopencl__:
     from silx.opencl.common import ocl
 if __has_pycuda__:
     import pycuda.gpuarray as garray
-    from nabu.misc.unsharp_cuda import CudaUnsharpMask
+    from nabu.processing.unsharp_cuda import CudaUnsharpMask
+
+try:
+    from skimage.filters import unsharp_mask
+
+    __has_skimage__ = True
+except ImportError:
+    __has_skimage__ = False
 
 
 @pytest.fixture(scope="class")
 def bootstrap(request):
     cls = request.cls
     cls.data = get_data("brain_phantom.npz")["data"]
+    cls.imagej_results = get_data("dirac_unsharp_imagej.npz")
     cls.tol = 1e-4
     cls.sigma = 1.6
     cls.coeff = 0.5
@@ -46,8 +55,34 @@ class TestUnsharp:
         )
         assert mae < self.tol, err_msg
 
+    @pytest.mark.skipif(not (__has_skimage__), reason="Need scikit-image for this test")
+    def test_mode_gaussian(self):
+        dirac = np.zeros((43, 43), "f")
+        dirac[dirac.shape[0] // 2, dirac.shape[1] // 2] = 1
+        sigma_list = [0.2, 0.5, 1.0, 2.0, 3.0]
+        coeff_list = [0.5, 1.0, 3.0]
+        for sigma, coeff in product(sigma_list, coeff_list):
+            res = UnsharpMask(dirac.shape, sigma, coeff, method="gaussian").unsharp(dirac)
+            ref = unsharp_mask(dirac, radius=sigma, amount=coeff, preserve_range=True)
+            assert np.max(np.abs(res - ref)) < 1e-6, "Something wrong with mode='gaussian', sigma=%.2f, coeff=%.2f" % (
+                sigma,
+                coeff,
+            )
+
+    def test_mode_imagej(self):
+        dirac = np.zeros(self.imagej_results["images"][0].shape, dtype="f")
+        dirac[dirac.shape[0] // 2, dirac.shape[1] // 2] = 1
+        for sigma, coeff, ref in zip(
+            self.imagej_results["sigma"], self.imagej_results["amount"], self.imagej_results["images"]
+        ):
+            res = UnsharpMask(dirac.shape, sigma, coeff, method="imagej").unsharp(dirac)
+            assert np.max(np.abs(res - ref)) < 1e-3, "Something wrong with mode='imagej', sigma=%.2f, coeff=%.2f" % (
+                sigma,
+                coeff,
+            )
+
     @pytest.mark.skipif(not (__has_pyopencl__), reason="Need pyopencl for this test")
-    def testOpenclUnsharp(self):
+    def test_opencl_unsharp(self):
         cl_queue = CommandQueue(self.cl_ctx)
         d_image = parray.to_device(cl_queue, self.data)
         d_out = parray.zeros_like(d_image)
@@ -61,13 +96,11 @@ class TestUnsharp:
             self.check_result(res, method, error_msg_prefix="OpenclUnsharpMask")
 
     @pytest.mark.skipif(not (__has_pycuda__), reason="Need cuda/pycuda for this test")
-    def testCudaUnsharp(self):
+    def test_cuda_unsharp(self):
         d_image = garray.to_gpu(self.data)
         d_out = garray.zeros_like(d_image)
         for method in CudaUnsharpMask.avail_methods:
-            cuda_unsharp = CudaUnsharpMask(
-                self.data.shape, self.sigma, self.coeff, method=method, cuda_options={"ctx": self.ctx}
-            )
+            cuda_unsharp = CudaUnsharpMask(self.data.shape, self.sigma, self.coeff, method=method, ctx=self.ctx)
             cuda_unsharp.unsharp(d_image, output=d_out)
             res = d_out.get()
             self.check_result(res, method, error_msg_prefix="CudaUnsharpMask")

nabu/processing/transpose.py

@@ -0,0 +1,126 @@
+import numpy as np
+from ..utils import get_opencl_srcfile, get_cuda_srcfile, updiv, BaseClassError, MissingComponentError
+from ..opencl.utils import __has_pyopencl__
+from ..cuda.utils import __has_pycuda__
+
+if __has_pyopencl__:
+    from ..opencl.kernel import OpenCLKernel
+    from ..opencl.processing import OpenCLProcessing
+    from pyopencl.tools import dtype_to_ctype as cl_dtype_to_ctype
+else:
+    OpenCLKernel = OpenCLProcessing = cl_dtype_to_ctype = MissingComponentError("need pyopencl to use this class")
+if __has_pycuda__:
+    from ..cuda.kernel import CudaKernel
+    from ..cuda.processing import CudaProcessing
+    from pycuda.tools import base_dtype_to_ctype as cu_dtype_to_ctype
+else:
+    CudaKernel = CudaProcessing = cu_dtype_to_ctype = MissingComponentError("need pycuda to use this class")
+
+
+# pylint: disable=E1101, E1102
+class TransposeBase:
+    """
+    A class for transposing (out-of-place) a cuda or opencl array
+    """
+
+    KernelCls = BaseClassError
+    ProcessingCls = BaseClassError
+    dtype_to_ctype = BaseClassError
+    backend = "none"
+
+    def __init__(self, shape, dtype, dst_dtype=None, **backend_options):
+        self.processing = self.ProcessingCls(**(backend_options or {}))
+        self.shape = shape
+        self.dtype = dtype
+        self.dst_dtype = dst_dtype or dtype
+        if len(shape) != 2:
+            raise ValueError("Expected 2D array")
+
+        self._kernel_init_args = [
+            "transpose",
+        ]
+        self._kernel_init_kwargs = {
+            "options": [
+                "-DSRC_DTYPE=%s" % self.dtype_to_ctype(self.dtype),
+                "-DDST_DTYPE=%s" % self.dtype_to_ctype(self.dst_dtype),
+            ],
+        }
+        self._configure_kenel_initialization()
+        self._transpose_kernel = self.KernelCls(*self._kernel_init_args, **self._kernel_init_kwargs)
+        self._configure_kernel_call()
+
+    def __call__(self, arr, dst=None):
+        if dst is None:
+            dst = self.processing.allocate_array("dst", self.shape[::-1], dtype=self.dst_dtype)
+        self._transpose_kernel(arr, dst, np.int32(self.shape[1]), np.int32(self.shape[0]), **self._kernel_kwargs)
+        return dst
+
+
+class CudaTranspose(TransposeBase):
+    KernelCls = CudaKernel
+    ProcessingCls = CudaProcessing
+    dtype_to_ctype = cu_dtype_to_ctype
+    backend = "cuda"
+
+    def _configure_kenel_initialization(self):
+        self._kernel_init_kwargs.update(
+            {
+                "filename": get_cuda_srcfile("transpose.cu"),
+                "signature": "PPii",
+            }
+        )
+
+    def _configure_kernel_call(self):
+        block = (32, 32, 1)
+        grid = [updiv(a, b) for a, b in zip(self.shape, block)]
+        self._kernel_kwargs = {"grid": grid, "block": block}
+
+
+class OpenCLTranspose(TransposeBase):
+    KernelCls = OpenCLKernel
+    ProcessingCls = OpenCLProcessing
+    dtype_to_ctype = cl_dtype_to_ctype
+    backend = "opencl"
+
+    def _configure_kenel_initialization(self):
+        self._kernel_init_args.append(self.processing.ctx)
+        self._kernel_init_kwargs.update(
+            {
+                "filename": get_opencl_srcfile("transpose.cl"),
+                "queue": self.processing.queue,
+            }
+        )
+
+    def _configure_kernel_call(self):
+        block = (16, 16, 1)
+        grid = [updiv(a, b) * b for a, b in zip(self.shape, block)]
+        self._kernel_kwargs = {"global_size": grid, "local_size": block}
+
+
+#
+# An attempt to have a simplified access to transpose operation
+#
+
+# (backend, shape, dtype, dtype_out)
+_transposes_store = {}
+
+
+def transpose(array, dst=None, **backend_options):
+    if hasattr(array, "with_queue"):
+        backend = "opencl"
+        transpose_cls = OpenCLTranspose
+        backend_options["queue"] = array.queue  # !
+    elif hasattr(array, "bind_to_texref"):
+        backend = "cuda"
+        transpose_cls = CudaTranspose
+    else:
+        raise ValueError("array should be either a pycuda.gpuarray.GPUArray or pyopencl.array.Array instance")
+
+    dst_dtype = dst.dtype if dst is not None else None
+    key = (backend, array.shape, np.dtype(array.dtype), dst_dtype)
+    transpose_instance = _transposes_store.get(key, None)
+    if transpose_instance is None:
+        transpose_instance = transpose_cls(array.shape, array.dtype, dst_dtype=dst_dtype, **backend_options)
+        _transposes_store[key] = transpose_instance
+
+    return transpose_instance(array, dst=dst)

nabu/processing/unsharp.py

@@ -0,0 +1,79 @@
+import numpy as np
+from scipy.ndimage import convolve1d
+from silx.image.utils import gaussian_kernel
+
+
+class UnsharpMask:
+    """
+    A helper class for unsharp masking.
+    """
+
+    avail_methods = ["gaussian", "log", "imagej"]
+
+    def __init__(self, shape, sigma, coeff, mode="reflect", method="gaussian"):
+        """
+        Initialize a Unsharp mask.
+        `UnsharpedImage =  (1 + coeff)*Image - coeff * ConvolutedImage`
+
+        If method == "log":
+        `UnsharpedImage = Image + coeff*ConvolutedImage`
+
+        Parameters
+        -----------
+        shape: tuple
+            Shape of the image.
+        sigma: float
+            Standard deviation of the Gaussian kernel
+        coeff: float
+            Coefficient in the linear combination of unsharp mask
+        mode: str, optional
+            Convolution mode. Default is "reflect"
+        method: str, optional
+            Method of unsharp mask. Can be "gaussian" (default) or "log" (Laplacian of Gaussian),
+            or "imagej".
+
+
+        Notes
+        -----
+        The computation is the following depending on the method:
+
+           - For method="gaussian": output = (1 + coeff) * image - coeff * image_blurred
+           - For method="log": output = image + coeff * image_blurred
+           - For method="imagej": output = (image - coeff*image_blurred)/(1-coeff)
+        """
+        self.shape = shape
+        self.ndim = len(self.shape)
+        self.sigma = sigma
+        self.coeff = coeff
+        self._set_method(method)
+        self.mode = mode
+        self._compute_gaussian_kernel()
+
+    def _set_method(self, method):
+        if method not in self.avail_methods:
+            raise ValueError("Unknown unsharp method '%s'. Available are %s" % (method, str(self.avail_methods)))
+        self.method = method
+
+    def _compute_gaussian_kernel(self):
+        self._gaussian_kernel = np.ascontiguousarray(gaussian_kernel(self.sigma), dtype=np.float32)
+
+    def _blur2d(self, image):
+        res1 = convolve1d(image, self._gaussian_kernel, axis=1, mode=self.mode)
+        res = convolve1d(res1, self._gaussian_kernel, axis=0, mode=self.mode)
+        return res
+
+    def unsharp(self, image, output=None):
+        """
+        Reference unsharp mask implementation.
+        """
+        image_b = self._blur2d(image)
+        if self.method == "gaussian":
+            res = (1 + self.coeff) * image - self.coeff * image_b
+        elif self.method == "log":
+            res = image + self.coeff * image_b
+        else:  # "imagej":
+            res = (image - self.coeff * image_b) / (1 - self.coeff)
+        if output is not None:
+            output[:] = res[:]
+            return output
+        return res

nabu/processing/unsharp_cuda.py

@@ -0,0 +1,53 @@
+from ..cuda.utils import __has_pycuda__
+from ..processing.convolution_cuda import Convolution
+from ..cuda.processing import CudaProcessing
+from .unsharp import UnsharpMask
+
+if __has_pycuda__:
+    from pycuda.elementwise import ElementwiseKernel
+
+
+class CudaUnsharpMask(UnsharpMask):
+    def __init__(self, shape, sigma, coeff, mode="reflect", method="gaussian", **cuda_options):
+        """
+        Unsharp Mask, cuda backend.
+        """
+        super().__init__(shape, sigma, coeff, mode=mode, method=method)
+        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
+        self._init_convolution()
+        self._init_mad_kernel()
+        self.cuda_processing.init_arrays_to_none(["_d_out"])
+
+    def _init_convolution(self):
+        self.convolution = Convolution(
+            self.shape,
+            self._gaussian_kernel,
+            mode=self.mode,
+            extra_options={  # Use the lowest amount of memory
+                "allocate_input_array": False,
+                "allocate_output_array": False,
+                "allocate_tmp_array": True,
+            },
+        )
+
+    def _init_mad_kernel(self):
+        # garray.GPUArray.mul_add is out of place...
+        self.mad_kernel = ElementwiseKernel(
+            "float* array, float fac, float* other, float otherfac",
+            "array[i] = fac * array[i] + otherfac * other[i]",
+            name="mul_add",
+        )
+
+    def unsharp(self, image, output=None):
+        if output is None:
+            output = self.cuda_processing.allocate_array("_d_out", self.shape, "f")
+        self.convolution(image, output=output)
+        if self.method == "gaussian":
+            self.mad_kernel(output, -self.coeff, image, 1.0 + self.coeff)
+        elif self.method == "log":
+            # output = output * coeff + image   where output was image_blurred
+            self.mad_kernel(output, self.coeff, image, 1.0)
+        else:  # "imagej":
+            # output = (image - coeff*image_blurred)/(1-coeff)  where output was image_blurred
+            self.mad_kernel(output, -self.coeff / (1 - self.coeff), image, 1.0 / (1 - self.coeff))
+        return output

nabu/processing/unsharp_opencl.py

@@ -0,0 +1,75 @@
+try:
+    import pyopencl.array as parray
+    from pyopencl.elementwise import ElementwiseKernel
+    from ..opencl.processing import OpenCLProcessing
+
+    __have_opencl__ = True
+except ImportError:
+    __have_opencl__ = False
+from .unsharp import UnsharpMask
+
+
+class OpenclUnsharpMask(UnsharpMask):
+    def __init__(
+        self,
+        shape,
+        sigma,
+        coeff,
+        mode="reflect",
+        method="gaussian",
+        **opencl_options,
+    ):
+        """
+        NB: For now, this class is designed to use the lowest amount of GPU memory
+        as possible. Therefore, the input and output image/volumes are assumed
+        to be already on device.
+        """
+        if not (__have_opencl__):
+            raise ImportError("Need pyopencl")
+        super().__init__(shape, sigma, coeff, mode=mode, method=method)
+        self.cl_processing = OpenCLProcessing(**(opencl_options or {}))
+        self._init_convolution()
+        self._init_mad_kernel()
+
+    def _init_convolution(self):
+        # Do it here because silx creates OpenCL contexts all over the place at import
+        from silx.opencl.convolution import Convolution as CLConvolution
+
+        self.convolution = CLConvolution(
+            self.shape,
+            self._gaussian_kernel,
+            mode=self.mode,
+            ctx=self.cl_processing.ctx,
+            extra_options={  # Use the lowest amount of memory
+                "allocate_input_array": False,
+                "allocate_output_array": False,
+                "allocate_tmp_array": True,
+                "dont_use_textures": True,
+            },
+        )
+
+    def _init_mad_kernel(self):
+        # parray.Array.mul_add is out of place...
+        self.mad_kernel = ElementwiseKernel(
+            self.cl_processing.ctx,
+            "float* array, float fac, float* other, float otherfac",
+            "array[i] = fac * array[i] + otherfac * other[i]",
+            name="mul_add",
+        )
+
+    def unsharp(self, image, output):
+        # For now image and output are assumed to be already allocated on device
+        assert isinstance(image, self.cl_processing.array_class)
+        assert isinstance(output, self.cl_processing.array_class)
+        self.convolution(image, output=output)
+        if self.method == "gaussian":
+            self.mad_kernel(output, -self.coeff, image, 1.0 + self.coeff)
+        elif self.method == "log":
+            self.mad_kernel(output, self.coeff, image, 1.0)
+        else:  # "imagej":
+            self.mad_kernel(output, -self.coeff / (1 - self.coeff), image, 1.0 / (1 - self.coeff))
+        return output
+
+
+# Alias
+OpenCLUnsharpMask = OpenclUnsharpMask

nabu/reconstruction/fbp.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pycuda.driver as cuda
 from ..utils import updiv, get_cuda_srcfile
-from ..cuda.utils import copy_array
+from ..cuda.utils import copy_array, check_textures_availability
 from ..cuda.processing import CudaProcessing
 from ..cuda.kernel import CudaKernel
 from .filtering_cuda import CudaSinoFilter
@@ -16,10 +16,16 @@ class CudaBackprojector(BackprojectorBase):
     SinoFilterClass = CudaSinoFilter
     SinoMultClass = CudaSinoMult
 
+    def _check_textures_availability(self):
+        self._use_textures = self.extra_options.get("use_textures", True) and check_textures_availability()
+
     def _get_kernel_signature(self):
-        kern_full_sig = list("PiifiiiiPPPf")
+        kern_full_sig = list("PPiifiiffPPPf")
         if self._axis_correction is None:
-            kern_full_sig[10] = ""
+            kern_full_sig[11] = ""
+        if self._use_textures:
+            # texture references - no object is passed (deprecated, removed in Cuda 12)
+            kern_full_sig[1] = ""
         return "".join(kern_full_sig)
 
     def _get_kernel_options(self):
@@ -39,17 +45,30 @@ class CudaBackprojector(BackprojectorBase):
                 "shared_size": self._kernel_options["shared_size"],
             }
         )
+        # texture references - no object is passed (deprecated, removed in Cuda 12)
+        if self._use_textures:
+            self.kern_proj_args.pop(1)
+        else:
+            self._d_sino = self._processing.allocate_array("_d_sino", self.sino_shape)
+            self.kern_proj_args[1] = self._d_sino.gpudata
 
     def _prepare_textures(self):
-        self.texref_proj = self.gpu_projector.module.get_texref(self._kernel_options["texture_name"])
-        self.texref_proj.set_filter_mode(cuda.filter_mode.LINEAR)
-        self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [self.texref_proj])
-        # Bind texture
-        self._d_sino_cua = cuda.np_to_array(np.zeros(self.sino_shape, "f"), "C")
-        self.texref_proj.set_array(self._d_sino_cua)
+        if self._use_textures:
+            self.texref_proj = self.gpu_projector.module.get_texref(self._kernel_options["texture_name"])
+            self.texref_proj.set_filter_mode(cuda.filter_mode.LINEAR)
+            self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [self.texref_proj])
+            # Bind texture
+            self._d_sino_cua = cuda.np_to_array(np.zeros(self.sino_shape, "f"), "C")
+            self.texref_proj.set_array(self._d_sino_cua)
+        else:
+            # d_sino_ref = self._d_sino.gpudata
+            # self.kern_proj_args.insert(2, d_sino_ref)
+            self.gpu_projector.prepare(self._kernel_options["kernel_signature"], [])
 
     def _compile_kernels(self):
         self._prepare_kernel_args()
+        if self._use_textures:
+            self._kernel_options["sourcemodule_options"].append("-DUSE_TEXTURES")
         self.gpu_projector = CudaKernel(
             self._kernel_options["kernel_name"],
             filename=self._kernel_options["file_name"],
@@ -60,7 +79,12 @@ class CudaBackprojector(BackprojectorBase):
         self._prepare_textures()  # has to be done after compilation for Cuda (to bind texture to built kernel)
 
     def _transfer_to_texture(self, sino, do_checks=True):
-        copy_array(self._d_sino_cua, sino, check=do_checks)
+        if self._use_textures:
+            copy_array(self._d_sino_cua, sino, check=do_checks)
+        else:
+            if id(self._d_sino) == id(sino):
+                return
+            self._d_sino[:] = sino[:]
 
 
 # COMPAT.