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

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/binning.py

@@ -0,0 +1,98 @@
+import numpy as np
+from ..utils import deprecated
+
+
+def binning(img, bin_factor, out_dtype=np.float32):
+    """
+    Bin an image by a factor of "bin_factor".
+
+    Parameters
+    ----------
+    bin_factor: tuple of int
+        Binning factor in each axis.
+    out_dtype: dtype, optional
+        Output data type. Default is float32.
+
+    Notes
+    -----
+    If the image original size is not a multiple of the binning factor,
+    the last items (in the considered axis) will be dropped.
+    The resulting shape is (img.shape[0] // bin_factor[0], img.shape[1] // bin_factor[1])
+    """
+    s = img.shape
+    n0, n1 = bin_factor
+    shp = (s[0] - (s[0] % n0), s[1] - (s[1] % n1))
+    sub_img = img[: shp[0], : shp[1]]
+    out_shp = (shp[0] // n0, shp[1] // n1)
+    res = np.zeros(out_shp, dtype=out_dtype)
+    for i in range(n0):
+        for j in range(n1):
+            res[:] += sub_img[i::n0, j::n1]
+    res /= n0 * n1
+    return res
+
+
+def binning_n_alt(img, bin_factor, out_dtype=np.float32):
+    """
+    Alternate, "clever" but slower implementation
+    """
+    n0, n1 = bin_factor
+    new_shape = tuple(s - (s % n) for s, n in zip(img.shape, bin_factor))
+    sub_img = img[: new_shape[0], : new_shape[1]]
+    img_view_4d = sub_img.reshape((new_shape[0] // n0, n0, new_shape[1] // n1, n1))
+    return img_view_4d.astype(out_dtype).mean(axis=1).mean(axis=-1)
+
+
+#
+# COMPAT.
+#
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning2(img, out_dtype=np.float32):
+    return binning(img, (2, 2), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning2_horiz(img, out_dtype=np.float32):
+    return binning(img, (1, 2), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning2_vertic(img, out_dtype=np.float32):
+    return binning(img, (2, 1), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning3(img, out_dtype=np.float32):
+    return binning(img, (3, 3), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning3_horiz(img, out_dtype=np.float32):
+    return binning(img, (1, 3), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def binning3_vertic(img, out_dtype=np.float32):
+    return binning(img, (3, 1), out_dtype=out_dtype)
+
+
+@deprecated("Please use binning()", do_print=True)
+def get_binning_function(binning_factor):
+    """
+    Determine the binning function to use.
+    """
+    binning_functions = {
+        (2, 2): binning2,
+        (2, 1): binning2_vertic,
+        (1, 2): binning2_horiz,
+        (3, 3): binning3,
+        (3, 1): binning3_vertic,
+        (1, 3): binning3_horiz,
+        (2, 3): None,  # was a limitation
+        (3, 2): None,  # was a limitation
+    }
+    if binning_factor not in binning_functions:
+        raise ValueError("Could not get a function for binning factor %s" % binning_factor)
+    return binning_functions[binning_factor]

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/fftshift.py

@@ -0,0 +1,6 @@
+from ..processing.fftshift import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.fftshift has been moved to nabu.processing.fftshift", do_print=True, func_name="fftshift"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/filters.py

@@ -0,0 +1,24 @@
+import numpy as np
+import scipy.signal
+
+
+def correct_spikes(image, threshold):
+    """
+    Perform a conditional median filtering
+    The filtering is done in-place, meaning that the array content is modified.
+
+    Parameters
+    ----------
+    image: numpy.ndarray
+        Image to filter
+    threshold: float
+        Median filter threshold
+    """
+    m_im = scipy.signal.medfilt2d(image)
+    fixed_part = np.array(image[[0, 0, -1, -1], [0, -1, 0, -1]])
+
+    where = abs(image - m_im) > threshold
+    image[where] = m_im[where]
+    image[[0, 0, -1, -1], [0, -1, 0, -1]] = fixed_part
+
+    return image

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/fourier_filters.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+"""
+Fourier filters.
+"""
+from functools import lru_cache
+import numpy as np
+import scipy.special as spspe
+
+
+@lru_cache(maxsize=10)
+def get_lowpass_filter(img_shape, cutoff_par=None, use_rfft=False, data_type=np.float64):
+    """Computes a low pass filter using the erfc function.
+
+    Parameters
+    ----------
+    img_shape: tuple
+        Shape of the image
+    cutoff_par: float or sequence of two floats
+        Position of the cut off in pixels, if a sequence is given the second float expresses the
+        width of the transition region which is given as a fraction of the cutoff frequency.
+        When only one float is given for this argument a gaussian is applied whose sigma is the
+        parameter.
+        When a sequence of two numbers is given then the filter is 1 ( no filtering) till the cutoff
+        frequency while a smooth erfc transition to zero is done
+    use_rfft: boolean, optional
+        Creates a filter to be used with the result of a rfft type of Fourier transform. Defaults to False.
+    data_type: `numpy.dtype`, optional
+        Specifies the data type of the computed filter. It defaults to `numpy.float64`
+
+    Raises
+    ------
+    ValueError
+        In case of malformed cutoff_par
+
+    Returns
+    -------
+    numpy.array_like
+        The computed filter
+    """
+    if cutoff_par is None:
+        return 1
+    elif isinstance(cutoff_par, (int, float)):
+        cutoff_pix = cutoff_par
+        cutoff_trans_fact = None
+    else:
+        try:
+            cutoff_pix, cutoff_trans_fact = cutoff_par
+        except ValueError:
+            raise ValueError(
+                "Argument cutoff_par  (which specifies the pass filter shape) must be either a scalar or a"
+                " sequence of two scalars"
+            )
+        if (not isinstance(cutoff_pix, (int, float))) or (not isinstance(cutoff_trans_fact, (int, float))):
+            raise ValueError(
+                "Argument cutoff_par  (which specifies the pass filter shape) must be  one number or a sequence"
+                "of two numbers"
+            )
+
+    coords = [np.fft.fftfreq(s, 1) for s in img_shape]
+    coords = np.meshgrid(*coords, indexing="ij")
+
+    r = np.sqrt(np.sum(np.array(coords, dtype=data_type) ** 2, axis=0))
+
+    if cutoff_trans_fact is not None:
+        k_cut = 0.5 / cutoff_pix
+        k_cut_width = k_cut * cutoff_trans_fact
+        k_pos_rescaled = (r - k_cut) / k_cut_width
+        res = spspe.erfc(k_pos_rescaled) / 2
+    else:
+        res = np.exp(-(np.pi**2) * (r**2) * (cutoff_pix**2) * 2)
+
+    # Making sure to force result to chosen data type
+    res = res.astype(data_type)
+
+    if use_rfft:
+        slicelist = [slice(None)] * (len(res.shape) - 1) + [slice(0, res.shape[-1] // 2 + 1)]
+        return res[tuple(slicelist)]
+    else:
+        return res
+
+
+def get_highpass_filter(img_shape, cutoff_par=None, use_rfft=False, data_type=np.float64):
+    """Computes a high pass filter using the erfc function.
+
+    Parameters
+    ----------
+    img_shape: tuple
+        Shape of the image
+    cutoff_par: float or sequence of two floats
+        Position of the cut off in pixels, if a sequence is given the second float expresses the
+        width of the transition region which is given as a fraction of the cutoff frequency.
+        When only one float is given for this argument a gaussian is applied whose sigma is the
+        parameter, and the result is subtracted from 1 to obtain the high pass filter
+        When a sequence of two numbers is given then the filter is 1 ( no filtering) above the cutoff
+        frequency and then a smooth  transition to zero is done for smaller frequency
+    use_rfft: boolean, optional
+        Creates a filter to be used with the result of a rfft type of Fourier transform. Defaults to False.
+    data_type: `numpy.dtype`, optional
+        Specifies the data type of the computed filter. It defaults to `numpy.float64`
+
+    Raises
+    ------
+    ValueError
+        In case of malformed cutoff_par
+
+    Returns
+    -------
+    numpy.array_like
+        The computed filter
+    """
+    if cutoff_par is None:
+        return 1
+    else:
+        return 1 - get_lowpass_filter(img_shape, cutoff_par, use_rfft=use_rfft, data_type=data_type)
+
+
+def get_bandpass_filter(img_shape, cutoff_lowpass=None, cutoff_highpass=None, use_rfft=False, data_type=np.float64):
+    """Computes a band pass filter using the erfc function.
+
+    The cutoff structures should be formed as follows:
+
+    - tuple of two floats: the first indicates the cutoff frequency, the second \
+        determines the width of the transition region, as fraction of the cutoff frequency.
+
+    - one float -> it represents the sigma of a gaussian which acts as a filter or anti-filter (1 - filter).
+
+    Parameters
+    ----------
+    img_shape: tuple
+        Shape of the image
+    cutoff_lowpass: float or sequence of two floats
+        Cutoff parameters for the low-pass filter
+    cutoff_highpass: float or sequence of two floats
+        Cutoff parameters for the high-pass filter
+    use_rfft: boolean, optional
+        Creates a filter to be used with the result of a rfft type of Fourier transform. Defaults to False.
+    data_type: `numpy.dtype`, optional
+        Specifies the data type of the computed filter. It defaults to `numpy.float64`
+
+    Raises
+    ------
+    ValueError
+        In case of malformed cutoff_par
+
+    Returns
+    -------
+    numpy.array_like
+        The computed filter
+    """
+    return get_lowpass_filter(
+        img_shape, cutoff_par=cutoff_lowpass, use_rfft=use_rfft, data_type=data_type
+    ) * get_highpass_filter(img_shape, cutoff_par=cutoff_highpass, use_rfft=use_rfft, data_type=data_type)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/histogram.py

@@ -0,0 +1,6 @@
+from ..processing.histogram import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.histogram has been moved to nabu.processing.histogram", do_print=True, func_name="histogram"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/histogram_cuda.py

@@ -0,0 +1,8 @@
+from ..processing.histogram_cuda import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.histogram_cuda has been moved to nabu.processing.histogram_cuda",
+    do_print=True,
+    func_name="histogram_cuda",
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/kernel_base.py

@@ -0,0 +1,4 @@
+from nabu.processing.kernel_base import KernelBase
+from ..utils import deprecated_class
+
+KernelBase = deprecated_class("KernelBase has been moved to nabu.processing", do_print=True)(KernelBase)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/padding.py

@@ -0,0 +1,83 @@
+import math
+import numpy as np
+
+
+def pad_interpolate(im, padded_img_shape_vh, translation_vh=None, padding_mode="reflect"):
+    """
+    This function produces a centered padded image and , optionally if translation_vh is set,
+    performs a Fourier shift of the whole image. In case of translation, the image is first padded to
+    a larger extent, that encompasses the final padded with plus a translation margin, and then translated,
+    and final recut to the required padded width.
+    The values are translated: if a feature appear at x in the original image it will appear at pad+translation+x
+    in the final image.
+
+    Parameters
+    ------------
+    im: np.ndaray
+       the input image
+    translation_vh: a sequence of two float
+       the vertical and horizontal shifts
+    """
+
+    if translation_vh is not None:
+        pad_extra = 2 ** (1 + np.ceil(np.log2(np.maximum(1, np.ceil(abs(np.array(translation_vh)))))).astype(np.int32))
+    else:
+        pad_extra = [0, 0]
+
+    origy, origx = im.shape
+    rety = padded_img_shape_vh[0] + pad_extra[0]
+    retx = padded_img_shape_vh[1] + pad_extra[1]
+
+    xpad = [0, 0]
+    xpad[0] = math.ceil((retx - origx) / 2)
+    xpad[1] = retx - origx - xpad[0]
+
+    ypad = [0, 0]
+    ypad[0] = math.ceil((rety - origy) / 2)
+    ypad[1] = rety - origy - ypad[0]
+
+    y2 = origy - ypad[1]
+    x2 = origx - xpad[1]
+
+    if ypad[0] + 1 > origy or xpad[0] + 1 > origx or y2 < 1 or x2 < 1:
+        raise ValueError("Too large padding for this reflect padding type")
+
+    padded_im = np.pad(im, pad_width=((ypad[0], ypad[1]), (xpad[0], xpad[1])), mode=padding_mode)
+
+    if translation_vh is not None:
+        freqs_list = list(map(np.fft.fftfreq, padded_im.shape))
+        shifts_list = [np.exp(-2.0j * np.pi * freqs * trans) for (freqs, trans) in zip(freqs_list, translation_vh)]
+        shifts_2D = shifts_list[0][:, None] * shifts_list[1][None, :]
+        padded_im = np.fft.ifft2(np.fft.fft2(padded_im) * shifts_2D).real
+        padded_im = recut(padded_im, padded_img_shape_vh)
+
+    return padded_im
+
+
+def recut(im, new_shape_vh):
+    """
+    This method implements a centered cut which reverts the centered padding
+    applied in the present class.
+
+    Parameters
+    -----------
+    im: np.ndarray
+        A 2D image.
+    new_shape_vh:  tuple
+        The shape of the cutted image.
+
+    Returns
+    --------
+        The image cutted to new_shape_vh.
+    """
+
+    new_shape_vh = np.array(new_shape_vh)
+
+    old_shape_vh = np.array(im.shape)
+
+    center_vh = (old_shape_vh - 1) / 2
+
+    start_vh = np.round(0.5 + center_vh - new_shape_vh / 2).astype(np.int32)
+    end_vh = start_vh + new_shape_vh
+
+    return im[start_vh[0] : end_vh[0], start_vh[1] : end_vh[1]]

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/padding_base.py

@@ -0,0 +1,6 @@
+from ..processing.padding_base import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.padding has been moved to nabu.processing.padding_base", do_print=True, func_name="padding_base"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/processing_base.py

@@ -0,0 +1,4 @@
+from nabu.processing.processing_base import ProcessingBase
+from ..utils import deprecated_class
+
+ProcessingBase = deprecated_class("ProcessingBase has been moved to nabu.processing", do_print=True)(ProcessingBase)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/rotation.py

@@ -0,0 +1,6 @@
+from ..processing.rotation import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.rotation has been moved to nabu.processing.rotation", do_print=True, func_name="rotation"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/rotation_cuda.py

@@ -0,0 +1,6 @@
+from ..processing.rotation_cuda import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.rotation_cuda has been moved to nabu.processing.rotation_cuda", do_print=True, func_name="rotation_cuda"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/tests/__init__.py

@@ -0,0 +1 @@
+

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/tests/test_binning.py

@@ -0,0 +1,48 @@
+from itertools import product
+import numpy as np
+import pytest
+from nabu.misc.binning import *
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.data = np.arange(100 * 99, dtype=np.uint16).reshape(100, 99)
+    cls.tol = 1e-5
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestBinning:
+    def testBinning(self):
+        """
+        Test the general-purpose binning function with an image defined by its indices.
+        The test "image" is an array where entry [i, j] equals i * Nx + j (where Nx = array.shape[1]).
+        Let (b_i, b_j) be the binning factor along each dimension,
+        then the binned array at position [p_i, p_j] is equal to
+           1/(b_i*b_j) * Sum(Sum(Nx*i + j, (j, p_j, p_j+b_j-1)), (i, p_i, p_i+b_i-1))
+        which happens to be equal to
+           (Nx * b_i + 2*Nx * p_i - Nx + b_j + 2*p_j - 1) /2
+        """
+
+        def get_reference_binned_image(img_shape, bin_factor):
+            # reference[p_i, p_j] = 0.5 * (Nx * b_i + 2*Nx * p_i - Nx + b_j + 2*p_j - 1)
+            Ny, Nx = img_shape
+            img_shape_reduced = tuple(s - (s % b) for s, b in zip(img_shape, bin_factor))
+            b_i, b_j = bin_factor
+            inds_i, inds_j = np.indices(img_shape_reduced)
+            p_i = inds_i[::b0, ::b1]
+            p_j = inds_j[::b0, ::b1]
+            return 0.5 * (Nx * b_i + 2 * Nx * p_i - Nx + b_j + 2 * p_j - 1)
+
+        # Various test settings
+        binning_factors = [2, 3, 4, 5, 6, 8, 10]
+        n_items = [63, 64, 65, 66, 125, 128, 130]
+
+        # Yep, that's 2401 tests...
+        params = product(n_items, n_items, binning_factors, binning_factors)
+        for s0, s1, b0, b1 in params:
+            img = np.arange(s0 * s1).reshape((s0, s1))
+            ref = get_reference_binned_image(img.shape, (b0, b1))
+            res = binning(img, (b0, b1))
+
+            assert np.allclose(res, ref)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/tests/test_interpolation.py

@@ -0,0 +1,70 @@
+import numpy as np
+import pytest
+from scipy.interpolate import interp1d
+from nabu.testutils import generate_tests_scenarios, get_data
+from nabu.utils import get_cuda_srcfile, updiv
+from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+
+if __has_pycuda__:
+    import pycuda.gpuarray as garray
+    from nabu.cuda.kernel import CudaKernel
+
+
+img0 = get_data("brain_phantom.npz")["data"]
+
+scenarios = generate_tests_scenarios(
+    {
+        "image": [img0, img0[:, :511], img0[:511, :]],
+        "x_bounds": [(180, 360), (0, 180), (50, 50 + 180)],
+        "x_to_x_new": [0.1, -0.2, 0.3],
+    }
+)
+
+
+@pytest.fixture(scope="class")
+def bootstrap(request):
+    cls = request.cls
+    cls.tol = 1e-4
+    if __has_pycuda__:
+        cls.ctx = get_cuda_context(cleanup_at_exit=False)
+    yield
+    if __has_pycuda__:
+        cls.ctx.pop()
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestInterpolation:
+    def _get_reference_interpolation(self, img, x, x_new):
+        interpolator = interp1d(x, img, kind="linear", axis=0, fill_value="extrapolate", copy=True)
+        ref = interpolator(x_new)
+        return ref
+
+    def _compare(self, res, img, x, x_new):
+        ref = self._get_reference_interpolation(img, x, x_new)
+        mae = np.max(np.abs(res - ref))
+        return mae
+
+    # parametrize on a class method will use the same class, and launch this
+    # method with different scenarios.
+    @pytest.mark.skipif(not (__has_pycuda__), reason="need pycuda for this test")
+    @pytest.mark.parametrize("config", scenarios)
+    def test_cuda_interpolation(self, config):
+        img = config["image"]
+        Ny, Nx = img.shape
+
+        xmin, xmax = config["x_bounds"]
+        x = np.linspace(xmin, xmax, num=img.shape[0], endpoint=False, dtype="f")
+        x_new = x + config["x_to_x_new"]
+
+        d_img = garray.to_gpu(img)
+        d_out = garray.zeros_like(d_img)
+        d_x = garray.to_gpu(x)
+        d_x_new = garray.to_gpu(x_new)
+
+        cuda_interpolator = CudaKernel(
+            "linear_interp_vertical", get_cuda_srcfile("interpolation.cu"), signature="PPiiPP"
+        )
+        cuda_interpolator(d_img, d_out, Nx, Ny, d_x, d_x_new, grid=(updiv(Nx, 16), updiv(Ny, 16), 1), block=(16, 16, 1))
+        err = self._compare(d_out.get(), img, x, x_new)
+        err_msg = str("Max error is too high for this configuration: %s" % str(config))
+        assert err < self.tol, err_msg

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/transpose.py

@@ -0,0 +1,6 @@
+from ..processing.transpose import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.transpose has been moved to nabu.processing.transpose", do_print=True, func_name="transpose"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/unsharp.py

@@ -0,0 +1,4 @@
+from ..processing.unsharp import *
+from ..utils import deprecation_warning
+
+deprecation_warning("nabu.misc.unsharp has been moved to nabu.processing.unsharp", do_print=True, func_name="unsharp")

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/unsharp_cuda.py

@@ -0,0 +1,6 @@
+from ..processing.unsharp_cuda import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.unsharp_cuda has been moved to nabu.processing.unsharp_cuda", do_print=True, func_name="unsharp_cuda"
+)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/misc/unsharp_opencl.py

@@ -0,0 +1,8 @@
+from ..processing.unsharp_opencl import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.unsharp_opencl has been moved to nabu.processing.unsharp_opencl",
+    do_print=True,
+    func_name="unsharp_opencl",
+)