nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

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

@@ -1,247 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/processing/tests/test_roll.py

@@ -1,63 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/processing/tests/test_rotation.py

@@ -1,83 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/processing/tests/test_transpose.py

@@ -1,72 +0,0 @@
-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/build/lib/build/lib/build/lib/nabu/processing/tests/test_unsharp.py

@@ -1,106 +0,0 @@
-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")