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/misc/binning.py

@@ -1,98 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,152 +0,0 @@
-# -*- 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

@@ -1,6 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-

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

@@ -1,48 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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