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

build/lib/build/lib/build/lib/nabu/processing/tests/test_padding.py

@@ -0,0 +1,247 @@
+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.processing.padding_cuda import CudaPadding
+from nabu.processing.padding_opencl import OpenCLPadding
+from nabu.utils import calc_padding_lengths, get_cuda_srcfile
+from nabu.testutils import __do_long_tests__
+from nabu.testutils import get_data, generate_tests_scenarios
+
+scenarios = {
+    "shape": [(511, 512), (512, 511)],
+    "pad_width": [((256, 255), (128, 127))],
+    "mode_cuda": CudaPadding.supported_modes[:2] if __has_pycuda__ else [],
+    "mode_opencl": OpenCLPadding.supported_modes[:2] if __has_pyopencl__ else [],
+    "constant_values": [0, ((1.0, 2.0), (3.0, 4.0))],
+    "output_is_none": [True, False],
+    "backend": ["cuda", "opencl"],
+}
+
+
+if __do_long_tests__:
+    scenarios["mode_cuda"] = CudaPadding.supported_modes if __has_pycuda__ else []
+    scenarios["mode_opencl"] = OpenCLPadding.supported_modes if __has_pyopencl__ else []
+    scenarios["pad_width"].extend([((0, 0), (6, 7))])
+
+scenarios = generate_tests_scenarios(scenarios)
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.data = get_data("brain_phantom.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 TestPadding:
+    @pytest.mark.parametrize("config", scenarios)
+    def test_padding(self, config):
+        backend = config["backend"]
+        shape = config["shape"]
+        padding_mode = config["mode_%s" % backend]
+        data = self.data[: shape[0], : shape[1]]
+        kwargs = {}
+        if padding_mode == "constant":
+            kwargs["constant_values"] = config["constant_values"]
+        ref = np.pad(data, config["pad_width"], mode=padding_mode, **kwargs)
+
+        PaddingCls = CudaPadding if backend == "cuda" else OpenCLPadding
+        if backend == "cuda":
+            backend_options = {"cuda_options": {"ctx": self.cu_ctx}}
+        else:
+            backend_options = {"opencl_options": {"ctx": self.cl_ctx}}
+
+        padding = PaddingCls(
+            config["shape"],
+            config["pad_width"],
+            mode=padding_mode,
+            constant_values=config["constant_values"],
+            **backend_options,
+        )
+        if config["output_is_none"]:
+            output = None
+        else:
+            output = padding.processing.allocate_array("output", ref.shape, dtype="f")
+
+        d_img = padding.processing.allocate_array("d_img", data.shape, dtype="f")
+        d_img.set(np.ascontiguousarray(data, dtype="f"))
+        res = padding.pad(d_img, output=output)
+
+        err_max = np.max(np.abs(res.get() - ref))
+        assert err_max < self.tol, str("Something wrong with padding for configuration %s" % (str(config)))
+
+    @pytest.mark.skipif(not (__has_pycuda__) and not (__has_pyopencl__), reason="need pycuda or pyopencl")
+    def test_custom_coordinate_transform(self):
+        data = self.data
+        R, C = np.indices(data.shape, dtype=np.int32)
+
+        pad_width = ((256, 255), (254, 251))
+        mode = "reflect"
+
+        coords_R = np.pad(R, pad_width[0], mode=mode)[:, 0]
+        coords_C = np.pad(C, pad_width[1], mode=mode)[0, :]
+
+        # Further transform of coordinates - here FFT layout
+        coords_R = np.roll(coords_R, -pad_width[0][0])
+        coords_C = np.roll(coords_C, -pad_width[1][0])
+
+        padding_classes_to_test = []
+        if __has_pycuda__:
+            padding_classes_to_test.append(CudaPadding)
+        if __has_pyopencl__:
+            padding_classes_to_test.append(OpenCLPadding)
+
+        for padding_cls in padding_classes_to_test:
+            ctx = self.cl_ctx if padding_cls.backend == "opencl" else self.cu_ctx
+            padding = padding_cls(data.shape, (coords_R, coords_C), mode=mode, ctx=ctx)
+
+            d_img = padding.processing.allocate_array("d_img", data.shape, dtype="f")
+            d_img.set(data)
+            d_out = padding.processing.allocate_array("d_out", padding.padded_shape, dtype="f")
+
+            res = padding.pad(d_img, output=d_out)
+
+            ref = np.roll(np.pad(data, pad_width, mode=mode), (-pad_width[0][0], -pad_width[1][0]), axis=(0, 1))
+
+            err_max = np.max(np.abs(d_out.get() - ref))
+            assert err_max < self.tol, "Something wrong with custom padding"
+
+
+#
+# The following is testing a previous version of padding kernels
+# They use specific code (instead of a generic coordinate transform)
+#
+
+if __has_pycuda__:
+    from nabu.cuda.kernel import CudaKernel
+    import pycuda.gpuarray as garray
+
+
+scenarios_legacy = [
+    {
+        "shape": (512, 501),
+        "shape_padded": (1023, 1022),
+        "constant_values": ((1.0, 2.0), (3.0, 4.0)),
+    },
+]
+
+
+# parametrize with fixture and "params=" will launch a new class for each scenario.
+# the attributes set to "cls" will remain for all the tests done in this class
+# with the current scenario.
+@pytest.fixture(scope="class", params=scenarios_legacy)
+def bootstrap_legacy(request):
+    cls = request.cls
+    cls.data = get_data("mri_proj_astra.npz")["data"]
+    cls.tol = 1e-7
+    cls.params = request.param
+    cls.ctx = get_cuda_context(cleanup_at_exit=False)
+    cls._calc_pad()
+    cls._init_kernels()
+    yield
+    cls.ctx.pop()
+
+
+@pytest.mark.skipif(not (__has_pycuda__), reason="Need Cuda and pycuda for this test")
+@pytest.mark.usefixtures("bootstrap_legacy")
+class TestPaddingLegacy:
+    @classmethod
+    def _calc_pad(cls):
+        cls.shape = cls.params["shape"]
+        cls.data = np.ascontiguousarray(cls.data[: cls.shape[0], : cls.shape[1]])
+        cls.shape_padded = cls.params["shape_padded"]
+        ((pt, pb), (pl, pr)) = calc_padding_lengths(cls.shape, cls.shape_padded)
+        cls.pad_top_len = pt
+        cls.pad_bottom_len = pb
+        cls.pad_left_len = pl
+        cls.pad_right_len = pr
+
+    @classmethod
+    def _init_kernels(cls):
+        cls.pad_kern = CudaKernel(
+            "padding_constant",
+            filename=get_cuda_srcfile("padding.cu"),
+            signature="Piiiiiiiiffff",
+        )
+        cls.pad_edge_kern = CudaKernel(
+            "padding_edge",
+            filename=get_cuda_srcfile("padding.cu"),
+            signature="Piiiiiiii",
+        )
+        cls.d_data_padded = garray.zeros(cls.shape_padded, "f")
+
+    def _init_padding(self, arr=None):
+        arr = arr or self.data
+        self.d_data_padded.fill(0)
+        Ny, Nx = self.shape
+        self.d_data_padded[:Ny, :Nx] = self.data
+
+    def _pad_numpy(self, arr=None, **np_pad_kwargs):
+        arr = arr or self.data
+        data_padded_ref = np.pad(
+            arr, ((self.pad_top_len, self.pad_bottom_len), (self.pad_left_len, self.pad_right_len)), **np_pad_kwargs
+        )
+        # Put in the FFT layout
+        data_padded_ref = np.roll(data_padded_ref, (-self.pad_top_len, -self.pad_left_len), axis=(0, 1))
+        return data_padded_ref
+
+    def test_constant_padding(self):
+        self._init_padding()
+        # Pad using the cuda kernel
+        ((val_top, val_bottom), (val_left, val_right)) = self.params["constant_values"]
+        Ny, Nx = self.shape
+        Nyp, Nxp = self.shape_padded
+
+        self.pad_kern(
+            self.d_data_padded,
+            Nx,
+            Ny,
+            Nxp,
+            Nyp,
+            self.pad_left_len,
+            self.pad_right_len,
+            self.pad_top_len,
+            self.pad_bottom_len,
+            val_left,
+            val_right,
+            val_top,
+            val_bottom,
+        )
+        # Pad using numpy
+        data_padded_ref = self._pad_numpy(mode="constant", constant_values=self.params["constant_values"])
+        # Compare
+        errmax = np.max(np.abs(self.d_data_padded.get() - data_padded_ref))
+        assert errmax < self.tol, "Max error is too high"
+
+    def test_edge_padding(self):
+        self._init_padding()
+        # Pad using the cuda kernel
+        ((val_top, val_bottom), (val_left, val_right)) = self.params["constant_values"]
+        Ny, Nx = self.shape
+        Nyp, Nxp = self.shape_padded
+
+        self.pad_edge_kern(
+            self.d_data_padded,
+            Nx,
+            Ny,
+            Nxp,
+            Nyp,
+            self.pad_left_len,
+            self.pad_right_len,
+            self.pad_top_len,
+            self.pad_bottom_len,
+        )
+        # Pad using numpy
+        data_padded_ref = self._pad_numpy(mode="edge")
+        # Compare
+        errmax = np.max(np.abs(self.d_data_padded.get() - data_padded_ref))
+        assert errmax < self.tol, "Max error is too high"

build/lib/build/lib/build/lib/nabu/processing/tests/test_roll.py

@@ -0,0 +1,63 @@
+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.roll_opencl import OpenCLRoll
+
+configs_roll = {
+    "shape": [(300, 451), (300, 300), (255, 300)],
+    "offset_x": [0, 10, 155],
+    "dtype": [np.float32],  # , np.complex64],
+}
+
+
+scenarios_roll = generate_tests_scenarios(configs_roll)
+
+
+@pytest.fixture(scope="class")
+def bootstrap_roll(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_roll")
+class TestRoll:
+    @staticmethod
+    def _compute_ref(data, direction, offset):
+        ref = data.copy()
+        ref[:, offset:] = np.roll(data[:, offset:], direction, axis=1)
+        return ref
+
+    @pytest.mark.skipif(not (__has_pyopencl__), reason="Need pyopencl for this test")
+    @pytest.mark.parametrize("config", scenarios_roll)
+    def test_opencl_roll(self, config):
+        shape = config["shape"]
+        dtype = config["dtype"]
+        offset_x = config["offset_x"]
+        data = np.ascontiguousarray(self.data[: shape[0], : shape[1]], dtype=dtype)
+
+        ref_forward = self._compute_ref(data, 1, offset_x)
+        ref_backward = self._compute_ref(data, -1, offset_x)
+
+        roll_forward = OpenCLRoll(dtype, direction=1, offset=offset_x, ctx=self.cl_ctx)
+        d_data = roll_forward.processing.allocate_array("data", data.shape, dtype=dtype)
+        d_data.set(data)
+        roll_backward = OpenCLRoll(dtype, direction=-1, offset=offset_x, queue=roll_forward.processing.queue)
+
+        roll_forward(d_data)
+        # from spire.utils import ims
+        # ims([d_data.get(), ref_forward, d_data.get() - ref_forward])
+        assert np.allclose(d_data.get(), ref_forward), "roll_forward: something wrong with config=%s" % (str(config))
+
+        d_data.set(data)
+        roll_backward(d_data)
+        assert np.allclose(d_data.get(), ref_backward), "roll_backward: something wrong with config=%s" % (str(config))

build/lib/build/lib/build/lib/nabu/processing/tests/test_rotation.py

@@ -0,0 +1,83 @@
+import numpy as np
+import pytest
+from nabu.testutils import generate_tests_scenarios
+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__:
+    from skimage.transform import rotate
+    from skimage.data import chelsea
+
+    ny, nx = chelsea().shape[:2]
+if __has_pycuda__:
+    from nabu.processing.rotation_cuda import CudaRotation
+    import pycuda.gpuarray as garray
+
+if __have__skimage__:
+    scenarios = generate_tests_scenarios(
+        {
+            # ~ "output_is_none": [False, True],
+            "mode": ["edge"],
+            "angle": [5.0, 10.0, 45.0, 57.0, 90.0],
+            "center": [None, ((nx - 1) / 2.0, (ny - 1) / 2.0), ((nx - 1) / 2.0, ny - 1)],
+        }
+    )
+else:
+    scenarios = {}
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.image = chelsea().mean(axis=-1, dtype=np.float32)
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context(cleanup_at_exit=False)
+        cls.d_image = garray.to_gpu(cls.image)
+    yield
+    if __has_pycuda__:
+        cls.ctx.pop()
+
+
+@pytest.mark.skipif(not (__have__skimage__), reason="Need scikit-image for rotation")
+@pytest.mark.usefixtures("bootstrap")
+class TestRotation:
+    def _get_reference_rotation(self, config):
+        return rotate(
+            self.image,
+            config["angle"],
+            resize=False,
+            center=config["center"],
+            order=1,
+            mode=config["mode"],
+            clip=False,  #
+            preserve_range=False,
+        )
+
+    def _check_result(self, res, config, tol):
+        ref = self._get_reference_rotation(config)
+        mae = np.max(np.abs(res - ref))
+        err_msg = str("Max error is too high for this configuration: %s" % str(config))
+        assert mae < tol, err_msg
+
+    # parametrize on a class method will use the same class, and launch this
+    # method with different scenarios.
+    @pytest.mark.parametrize("config", scenarios)
+    def test_rotation(self, config):
+        R = Rotation(self.image.shape, config["angle"], center=config["center"], mode=config["mode"])
+        res = R(self.image)
+        self._check_result(res, config, 1e-6)
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need cuda rotation")
+    @pytest.mark.parametrize("config", scenarios)
+    def test_cuda_rotation(self, config):
+        R = CudaRotation(
+            self.image.shape,
+            config["angle"],
+            center=config["center"],
+            mode=config["mode"],
+            cuda_options={"ctx": self.ctx},
+        )
+        d_res = R(self.d_image)
+        res = d_res.get()
+        self._check_result(res, config, 0.5)

build/lib/build/lib/build/lib/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)

build/lib/build/lib/build/lib/nabu/processing/tests/test_unsharp.py

@@ -0,0 +1,106 @@
+from itertools import product
+import numpy as np
+import pytest
+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
+
+if __has_pyopencl__:
+    from pyopencl import CommandQueue
+    import pyopencl.array as parray
+    from silx.opencl.common import ocl
+if __has_pycuda__:
+    import pycuda.gpuarray as garray
+    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
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context(cleanup_at_exit=False)
+    if __has_pyopencl__:
+        cls.cl_ctx = ocl.create_context()
+    yield
+    if __has_pycuda__:
+        cls.ctx.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestUnsharp:
+    def get_reference_result(self, method, data=None):
+        if data is None:
+            data = self.data
+        unsharp_mask = UnsharpMask(data.shape, self.sigma, self.coeff, method=method)
+        return unsharp_mask.unsharp(data)
+
+    def check_result(self, result, method, data=None, error_msg_prefix=None):
+        reference = self.get_reference_result(method, data=data)
+        mae = np.max(np.abs(result - reference))
+        err_msg = str(
+            "%s: max error is too high with method=%s: %.2e > %.2e" % (error_msg_prefix or "", method, mae, self.tol)
+        )
+        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 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)
+        for method in OpenclUnsharpMask.avail_methods:
+            d_image = parray.to_device(cl_queue, self.data)
+            d_out = parray.zeros_like(d_image)
+
+            opencl_unsharp = OpenclUnsharpMask(self.data.shape, self.sigma, self.coeff, method=method, ctx=self.cl_ctx)
+            opencl_unsharp.unsharp(d_image, output=d_out)
+            res = d_out.get()
+            self.check_result(res, method, error_msg_prefix="OpenclUnsharpMask")
+
+    @pytest.mark.skipif(not (__has_pycuda__), reason="Need cuda/pycuda for this test")
+    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, ctx=self.ctx)
+            cuda_unsharp.unsharp(d_image, output=d_out)
+            res = d_out.get()
+            self.check_result(res, method, error_msg_prefix="CudaUnsharpMask")