arrlp 0.1.6__tar.gz

arrlp-0.1.6/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.3
+Name: arrlp
+Version: 0.1.6
+Summary: A library providing custom functions for arrays.
+Requires-Dist: astropy
+Requires-Dist: corelp
+Requires-Dist: ipykernel
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: pytest
+Requires-Dist: scipy
+Requires-Dist: sphinx
+Requires-Dist: sphinx-design
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: spyder-kernels
+Requires-Dist: toml
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# arrLP
+
+```text
+Author        : Lancelot PINCET
+GitHub        : https://github.com/LancelotPincet/arrLP
+HTTPS         : https://github.com/LancelotPincet/arrLP.git
+SSH           : git@github.com:LancelotPincet/arrLP.git
+PyPI          : https://pypi.org/project/arrLP
+Docs          : https://arrLP.readthedocs.io
+```
+
+**A library providing custom functions for arrays.**
+
+arrLP is available on [PyPI](https://pypi.org/project/arrLP) for pip installs.
+For more information, do not hesitate to consult the [Documentation](https://arrLP.readthedocs.io).
+
+---
+
+## MIT License
+
+<details>
+<summary>details</summary>
+
+Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.
+
+The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.
+
+The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.
+
+</details>

arrlp-0.1.6/README.md

@@ -0,0 +1,30 @@
+# arrLP
+
+```text
+Author        : Lancelot PINCET
+GitHub        : https://github.com/LancelotPincet/arrLP
+HTTPS         : https://github.com/LancelotPincet/arrLP.git
+SSH           : git@github.com:LancelotPincet/arrLP.git
+PyPI          : https://pypi.org/project/arrLP
+Docs          : https://arrLP.readthedocs.io
+```
+
+**A library providing custom functions for arrays.**
+
+arrLP is available on [PyPI](https://pypi.org/project/arrLP) for pip installs.
+For more information, do not hesitate to consult the [Documentation](https://arrLP.readthedocs.io).
+
+---
+
+## MIT License
+
+<details>
+<summary>details</summary>
+
+Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.
+
+The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.
+
+The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.
+
+</details>

arrlp-0.1.6/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "arrlp"
+version = "0.1.6"
+description = "A library providing custom functions for arrays."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [ "astropy", "corelp", "ipykernel", "numba", "numpy", "pytest", "scipy", "sphinx", "sphinx-design", "sphinx-rtd-theme", "spyder-kernels", "toml",]
+
+[build-system]
+requires = [ "uv_build>=0.8.8,<0.9.0",]
+build-backend = "uv_build"
+
+[tool.uv]
+required-environments = [ "sys_platform == 'linux' and platform_machine == 'x86_64'", "sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86_64')",]
+
+[tool.uv.sources.corelp]
+workspace = true

arrlp-0.1.6/src/arrlp/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+
+"""
+A library providing custom functions for arrays.
+"""
+
+
+
+# %% Lazy imports
+from corelp import getmodule
+__getattr__, __all__ = getmodule(__file__)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/compress_LP/compress.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-11-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : compress
+
+"""
+Compresses an array between values by normalizing, with possibility to saturate extrema.
+"""
+
+
+
+# %% Libraries
+import numpy as np
+
+
+
+# %% Function
+def compress(array, /, max=1, min=0, *, dtype=None, white=None, black=None, white_percent=None, black_percent=None, saturate=None) :
+    '''
+    Compresses an array between values by normalizing, with possibility to saturate extrema.
+    
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to normalize.
+    max : int or float or None
+        white value in output. None for no changing of white
+    min : int or float or None
+        black value in output. None for no changing of black
+    dtype : np.dtype or str or None
+        dtype of output, None for same as input
+    white : int or float or None
+        white value in input. None for maximum
+    black : int or float or None
+        black value in input. None for minimum
+    white_percent : int or None
+        white percentage distribution in input if white is None.
+    black_percent : int or None
+        black percentage distribution in input if black is None.
+    saturate : Any or bool or None
+        If True, will saturate values above white and black. If Any, will replace by this value. If None no saturation.
+
+    Returns
+    -------
+    array : np.ndarray
+        Normalized and saturated copy of array.
+
+    Examples
+    --------
+    >>> from arrlp import compress
+    >>> array = np.arange(100, dtype=np.float32)
+    ...
+    >>> compress(array, 10, 5) # compresses array between 10 and 5
+    >>> compress(array, white=50, black=40) # compresses array linearly so that 50 value is at 1 and 40 is at 0
+    >>> compress(array, white=50, black=40, saturate=np.nan) # compresses array linearly so that 50 value is at 1 and 40 is at 0, replace outside values by np.nan
+    >>> compress(array, white_percent=10, black=1) # compresses array linearly so that 10% of array will be white, and 1% black (without saturation)
+    >>> compress(array, white_percent=10, black=1, saturate=True) # compresses array linearly so that 10% of array will be white, and 1% black (with saturation)
+    '''
+
+    # init
+    array = np.asarray(array)
+    if dtype is None :
+        dtype = array.dtype
+
+    # Get white/black
+    if white is None :
+        white = np.nanmax(array) if white_percent is None else np.nanpercentile(array, 100-white_percent)
+    if black is None :
+        black = np.nanmin(array) if black_percent is None else np.nanpercentile(array, black_percent)
+    if white >= black :
+        raise ValueError('white >= black is not possible while compressing')
+
+    # Normalization
+    if max is not None and min is not None and min >= max :
+        raise ValueError('min >= max is not possible while compressing')
+    if max is not None :
+        array = normalization(array, value=max, norm=white, fix=black)
+        white = max
+    if min is not None :
+        array = normalization(array, value=min, norm=black, fix=white)
+        black = min
+    if max is None and min is None :
+        array = np.copy(array)
+
+    # Saturation
+    if saturate is not None :
+        if saturate is True :
+            sat_min, sat_max = min, max
+        else :
+            sat_min, sat_max = saturate, saturate
+        array[array>max] = sat_max
+        array[array<min] = sat_min
+    
+    return array.astype(dtype)
+
+
+
+def normalization(array, /, value:float=None, norm:float=None, fix:float=None):
+    '''Basic normalization process of array copy while keeping a fixed point'''
+
+    if fix is None : fix = 0
+    if norm is None : norm = max(np.nanmax(array),-np.nanmin(array))
+    if value is None : value = 1*np.sign(norm)
+    return (array-fix)/(norm-fix)*(value-fix) + fix
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/compress_LP/test_compress.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-11-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : compress
+
+"""
+This file allows to test compress
+
+compress : Compresses an array between values by normalizing, with possibility to saturate extrema.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from arrlp import compress
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test compress function
+    '''
+    print('Hello world!')
+
+
+
+# %% Instance fixture
+@pytest.fixture()
+def instance() :
+    '''
+    Create a new instance at each test function
+    '''
+    return compress()
+
+def test_instance(instance) :
+    '''
+    Test on fixture
+    '''
+    pass
+
+
+# %% Returns test
+@pytest.mark.parametrize("args, kwargs, expected, message", [
+    #([], {}, None, ""),
+    ([], {}, None, ""),
+])
+def test_returns(args, kwargs, expected, message) :
+    '''
+    Test compress return values
+    '''
+    assert compress(*args, **kwargs) == expected, message
+
+
+
+# %% Error test
+@pytest.mark.parametrize("args, kwargs, error, error_message", [
+    #([], {}, None, ""),
+    ([], {}, None, ""),
+])
+def test_errors(args, kwargs, error, error_message) :
+    '''
+    Test compress error values
+    '''
+    with pytest.raises(error, match=error_message) :
+        compress(*args, **kwargs)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/convolve_LP/convolve.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : convolve
+
+"""
+This function convolves two numpy arrays (1D, 2D, 3D).
+"""
+
+
+
+# %% Libraries
+from arrlp import correlate
+import numpy as np
+
+
+
+# %% Function
+def convolve(arr, k=None, /, out=None, **kwargs) :
+    '''
+    This function convolves two numpy arrays (1D, 2D, 3D).
+    
+    Parameters
+    ----------
+    arr : numpy.ndarray
+        first array to correlate.
+    k : numpy.ndarray
+        second array to correlate, if is None is auto created.
+    out : numpy.ndarray
+        array where to put correlation, same shape as arr, if None is auto initialized.
+    kwargs : dict
+        Parameters to pass to arrlp.correlate function.
+
+    Returns
+    -------
+    out : numpy.ndarray
+        Correlated array.
+
+    Raises
+    ------
+    TypeError
+        if output shape does not match array shape.
+
+    Examples
+    --------
+    >>> from arrlp import correlate
+    ...
+    >>> convolve(img, sigma=5) # Gaussian convolve
+    >>> convolve(img, window=10) # Mask convolve
+    >>> convolve(img, wl=640, NA=1.5) # Airy convolve
+    '''
+
+    if k is not None :
+        for dim in range(np.ndim(k)) :
+            k = np.flip(k, axis=dim)
+    return correlate(arr, k, out, **kwargs)
+    
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/convolve_LP/test_convolve.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : convolve
+
+"""
+This file allows to test convolve
+
+convolve : This function convolves two numpy arrays (1D, 2D, 3D).
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+import pytest
+from matplotlib import pyplot as plt
+from arrlp import kernel, convolve
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+@pytest.mark.parametrize("kwargs, title", [
+    ({"window":10}, "Mask"),
+    ({"sigma":5}, "Gaussian"),
+    ({"wl":640, "NA":1.5}, "Airy"),
+])
+def test_function(kwargs, title) :
+    '''
+    Test correlate values
+    '''
+
+    img = kernel(pixel=5, window=1000)
+    
+    plt.figure()
+    plt.imshow(img, cmap="hot")
+    plt.tight_layout()
+    plt.colorbar()
+    plt.savefig(debug_folder / f"{title}_before.png")
+
+    out = convolve(img, pixel=5, **kwargs)
+
+    plt.figure()
+    plt.imshow(out, cmap="hot")
+    plt.tight_layout()
+    plt.colorbar()
+    plt.savefig(debug_folder / f"{title}.png")
+
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/coordinates_LP/coordinates.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : coordinates
+
+"""
+This function will return a ndarray corresponding to the coordinates array of the input.
+"""
+
+
+
+# %% Libraries
+import numpy as np
+
+
+
+# %% Function
+def coordinates(shape, pixel=1., *, ndims=1, center=True, grid=False, origin=0.) :
+    '''
+    This function will return a ndarray corresponding to the coordinates array of the input.
+    
+    Parameters
+    ----------
+    shape : int or tuple or np.ndarray
+        Describes the shape of the coordinates.
+        If int, all dimensions will have this value.
+        If tuple, corresponds to the shape.
+        If array, will take the shape attribute of the array
+    pixel : float, tuple(float)
+        Says what is the size of one bin, default is 1.
+        If tuple, corresponds to the pixel for each dimension.
+    ndims : int
+        Number of dimensions if input shape is int.
+        Will be overriden by any other input dimension.
+    center : bool or tuple(bool)
+        True to center origin, False to start by origin.
+        If tuple, defines how to place origin for each dimension.
+    grid : bool
+        True to return full meshgrid for each dimensions, False for broadcastable arrays.
+    origin : float or tuple(float)
+        Value of origin (default 0).
+        If tuple, value for each dimension.
+
+    Returns
+    -------
+    coords : np.ndarray or tuple(np.ndarray)
+        for 1 dimensional shape, returns coordinates array.
+        else, return a tuple of arrays for each dimensions.
+
+    Raises
+    ------
+    ValueError
+        if input or passed as tuples that do not have the good number of dimensions.
+
+    Examples
+    --------
+    >>> from arrlp import coordinates
+    ...
+    >>> array = np.ones((5,4))
+    >>> coordinates = coordinates(array, pixel=10, center=(True, False), grid=False, origin=(0,3))
+    ... array([[-20.], [-10.], [0.], [10.], [20.]]), array([[3., 13., 23., 33.]])
+    '''
+
+    # Manage shape argument
+    if isinstance(shape, int) :
+        shape = (shape,) * ndims
+    elif isinstance(shape, tuple) :
+        pass
+    else :
+        shape = np.shape(shape)
+
+    # Correct ndims
+    ndims = len(shape)
+
+    # Correct input dimensions
+    pixel = iterable(pixel, ndims)
+    center = iterable(center, ndims)
+    origin = iterable(origin, ndims)
+
+    #looping on shape
+    coords = []
+    for dim, (n, pix, cent, orig) in enumerate(zip(shape, pixel, center, origin)) :
+        coord = n2coord(n, pixel=pix, center=cent, origin=orig)
+        reshape = np.ones(ndims, dtype=int)
+        reshape[dim] = len(coord)
+        coord = coord.reshape(tuple(reshape))
+        coords.append(coord)
+
+    #Meshgrid
+    if ndims == 1 :
+        return coords[0]
+    elif grid :
+        return np.meshgrid(*coords, indexing='ij')
+    else :
+        return coords
+
+
+
+def iterable(arg, ndims) :
+    try :
+        if len(arg) != ndims :
+            raise ValueError('Argument does not have good number of dimensions')
+        else :
+            return arg
+    except TypeError :
+        return (arg,) * ndims
+
+
+
+def n2coord(n, pixel=1., center=False, origin=0.) :
+    if center :
+        start, stop = -(n - 1) / 2,(n - 1) / 2
+    else :
+        start,stop = 0, n - 1
+    return np.linspace(start, stop, n) * pixel + origin
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/coordinates_LP/test_coordinates.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : coordinates
+
+"""
+This file allows to test coordinates
+
+coordinates : This function will return a ndarray corresponding to the coordinates array of the input.
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+import pytest
+import numpy as np
+from arrlp import coordinates
+debug_folder = debug(__file__)
+
+print(coordinates())
+
+# %% Returns test
+@pytest.mark.parametrize("args, kwargs, expected, message", [
+    #([], {}, None, ""),
+    ([np.ones((5,4))], {"pixel":10, "center":(True, False), "grid":False, "origin":(0,3)}, (np.array([[-20.], [-10.], [0.], [10.], [20.]]), np.array([[3., 13., 23., 33.]])), ""),
+])
+def test_returns(args, kwargs, expected, message) :
+    '''
+    Test coordinates return values
+    '''
+    assert (coordinates(*args, **kwargs)[0] == expected[0]).all(), message
+    assert (coordinates(*args, **kwargs)[1] == expected[1]).all(), message
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/correlate_LP/correlate.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : correlate
+
+"""
+This function correlates two numpy arrays (1D, 2D, 3D).
+"""
+
+
+
+# %% Libraries
+from arrlp import kernel
+from numba import njit, prange
+import numpy as np
+import astropy
+
+
+
+# %% Function
+def correlate(arr, k=None, /, out=None, *, method="mean", **kernel_kwargs) :
+    '''
+    This function correlates two numpy arrays (1D, 2D, 3D).
+    
+    Parameters
+    ----------
+    arr : numpy.ndarray
+        first array to correlate.
+    k : numpy.ndarray
+        second array to correlate, if is None is auto created.
+    out : numpy.ndarray
+        array where to put correlation, same shape as arr, if None is auto initialized.
+    method : str
+        define function to use for correlation. Should be in ["astro", "mean", "std", "min", "max", "sum", "prod"].
+    kernel_kwargs : dict
+        Parameters passed to kernel function for auto-creation.
+
+    Returns
+    -------
+    out : numpy.ndarray
+        Correlated array.
+
+    Raises
+    ------
+    TypeError
+        if output shape does not match array shape.
+
+    Examples
+    --------
+    >>> from arrlp import correlate
+    ...
+    >>> correlate(img, sigma=5) # Gaussian correlation
+    >>> correlate(img, window=10) # Mask correlation
+    >>> correlate(img, wl=640, NA=1.5) # Airy correlation
+    '''
+
+    # Method
+    ndims = len(np.shape(arr))
+    method = f"{method}{ndims}"
+
+    # Kernel
+    if k is None :
+        k = kernel(ndims, **kernel_kwargs)
+    
+    # Output
+    if out is None :
+        out = np.empty_like(arr)
+    if np.shape(out) != np.shape(arr) :
+        raise TypeError('Output shape does not match array shape')
+    
+    # Function
+    function = function_factory(method)
+    function(arr, k, out)
+    
+    return out
+
+
+
+_cached = {}
+funcs = {
+    'mean' : np.nanmean,
+    'std' : np.nanstd,
+    'min' : np.nanmin,
+    'max' : np.nanmax,
+    'sum' : np.nansum,
+    'prod' : np.nanprod,
+    }
+
+def function_factory(method) :
+    function = _cached.get(method, None)
+    if function is not None :
+        return function
+
+    if method.startswith("astro") :
+        if method.endswith("1") :
+            def invert(k) :
+                return k[::-1]
+        elif method.endswith("2") :
+            def invert(k) :
+                return k[::-1, ::-1]
+        elif method.endswith("3") :
+            def invert(k) :
+                return k[::-1, ::-1, ::-1]
+        else :
+            raise SyntaxError(f'Correlation error cannot be {method}')
+
+        def function(arr, k, out, *, kernel_limit=2**12) :
+            k = invert(k)
+            if k.size > kernel_limit :
+                out[:] = astropy.convolution.convolve_fft(arr, k, normalize_kernel=False)
+            else :
+                out[:] = astropy.convolution.convolve(arr, k, boundary='extend', normalize_kernel=False)
+        _cached[method] = function
+        return function
+
+    func = funcs[method[:-1]]
+
+    if method.endswith("1") :
+        @njit(parallel=True)
+        def function(arr, k, out):
+            xlim, = np.shape(arr)
+            xp, = np.shape(k)
+            xp = int(xp / 2)
+            sum = np.sum(k)
+            sizep = k.size
+            for i in prange(xlim):
+                x = i
+                xmin, xmax = max(0, x - xp), min(xlim, x + xp + 1)
+                n = (xmax - xmin)
+                if n != sizep :
+                    ksum = np.sum(k[xmin - x + xp: xmax - x + xp])
+                    if ksum != 0 :
+                        n = n * sum / ksum
+                crop = arr[xmin:xmax] * k[xmin - x + xp: xmax - x + xp] * n
+                out[x] = func(crop)
+
+    elif method.endswith("2") :
+        
+        @njit(parallel=True)
+        def function(arr, k, out):
+            ylim, xlim = np.shape(arr)
+            yp, xp = np.shape(k)
+            yp, xp = int(yp / 2),int(xp / 2)
+            sum = np.sum(k)
+            sizep = k.size
+            for y in prange(ylim):
+                for x in range(xlim) :
+                    ymin, ymax = max(0, y - yp), min(ylim,y + yp + 1)
+                    xmin, xmax = max(0, x - xp), min(xlim,x + xp + 1)
+                    n = (ymax - ymin) * (xmax - xmin)
+                    if n != sizep :
+                        ksum = np.sum(k[ymin - y + yp: ymax - y + yp, xmin - x + xp: xmax - x + xp])
+                        if ksum != 0 :
+                            n = n * sum / ksum
+                    crop = arr[ymin:ymax, xmin:xmax] * k[ymin - y + yp: ymax - y + yp, xmin - x + xp: xmax - x + xp] * n
+                    out[y, x] = func(crop)
+
+    elif method.endswith("3") :
+        
+        @njit(parallel=True)
+        def function(arr, k, out):
+            zlim, ylim, xlim = np.shape(arr)
+            zp, yp, xp = np.shape(k)
+            zp, yp, xp = int(zp / 2), int(yp / 2), int(xp / 2)
+            sum = np.sum(k)
+            sizep = k.size
+            for z in prange(zlim) :
+                for y in range(ylim) :
+                    for x in range(xlim) :
+                        zmin, zmax = max(0, z - zp), min(zlim, z + zp + 1)
+                        ymin, ymax = max(0, y - yp), min(ylim, y + yp + 1)
+                        xmin, xmax = max(0, x - xp), min(xlim, x + xp + 1)
+                        n = (zmax - zmin) * (ymax - ymin) * (xmax - xmin)
+                        if n != sizep :
+                            ksum = np.sum(k[zmin - z + zp: zmax - z + zp, ymin - y + yp: ymax - y + yp, xmin - x + xp: xmax - x + xp])
+                            if ksum != 0 :
+                                n = n * sum / ksum
+                        crop = arr[zmin: zmax, ymin: ymax, xmin: xmax] * k[zmin - z + zp: zmax - z + zp, ymin - y + yp: ymax - y + yp, xmin - x + xp: xmax - x + xp] * n
+                        out[z, y, x] = func(crop)
+        
+    else :
+        raise SyntaxError(f'Correlation error cannot be {method}')
+    _cached[method] = function
+    return function
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/correlate_LP/test_correlate.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : correlate
+
+"""
+This file allows to test correlate
+
+correlate : This function correlates two numpy arrays (1D, 2D, 3D).
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+import pytest
+from matplotlib import pyplot as plt
+from arrlp import kernel, correlate
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+@pytest.mark.parametrize("kwargs, title", [
+    ({"window":10}, "Mask"),
+    ({"sigma":5}, "Gaussian"),
+    ({"wl":640, "NA":1.5}, "Airy"),
+])
+def test_function(kwargs, title) :
+    '''
+    Test correlate values
+    '''
+
+    img = kernel(pixel=5, window=1000)
+    
+    plt.figure()
+    plt.imshow(img, cmap="hot")
+    plt.tight_layout()
+    plt.colorbar()
+    plt.savefig(debug_folder / f"{title}_before.png")
+
+    out = correlate(img, pixel=5, **kwargs)
+
+    plt.figure()
+    plt.imshow(out, cmap="hot")
+    plt.tight_layout()
+    plt.colorbar()
+    plt.savefig(debug_folder / f"{title}.png")
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/kernel_LP/kernel.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : kernel
+
+"""
+This funtion creates kernels small arrays, mainly for convolutions.
+"""
+
+
+
+# %% Libraries
+from arrlp import coordinates
+import numpy as np
+from scipy.special import erf, erfinv, j1
+
+
+
+# %% Function
+def kernel(ndims=2, pixel=1, *, dtype=np.float32, atrou=0, window=None, sigma=None, wl=None, NA=None) :
+    '''
+    This funtion creates kernels small arrays, mainly for convolutions.
+    
+    Parameters
+    ----------
+    ndims : int
+        Number of dimensions.
+    pixel : int
+        Size of pixel for each dimension.
+    dtype : np.dtype
+        data type of kernel.
+    atrou : int
+        Number of trou to put for atrou algorithm, None for normal kernel.
+    window : float
+        Size of window for mask kernel.
+    sigma : float
+        Size of sigma for gaussian kernel.
+    wl : float
+        wavelength for Airy kernel.
+    NA : float
+        Numerical Aperture for Airy kernel.
+
+    Returns
+    -------
+    k : np.array
+        kernel generated.
+
+    Raises
+    ------
+    SyntaxError
+        One keyword input must be put that defines type of kernel, if not will raise Error.
+
+    Examples
+    --------
+    >>> from arrlp import kernel
+    ...
+    >>> kernel(window=10) # Mask
+    >>> kernel(sigma=5) # Gaussian
+    >>> kernel(wl=640, NA=1.5) # Airy
+    '''
+
+    #kernel
+    if sigma is not None :
+        k = kernel_gaus(sigma, pixel, ndims)
+    elif window is not None :
+        k = kernel_mask(window, pixel, ndims)
+    elif wl is not None and NA is not None :
+        k = kernel_airy(wl, NA, pixel, ndims)
+    else :
+        raise SyntaxError('Kernel was not recognized')
+
+    #"à trou" kernel
+    if atrou is not None and atrou != 0 :
+        k = kernel_atrou(k, atrou)
+
+    k = k.astype(dtype)
+    k /= k.sum()
+    return k
+
+
+
+def kernel_gaus(sigma, pixel=1, ndims=1, tol_zero=1/100) :
+    '''gets a n dimensions gaussian kernel'''
+
+    # Coordinates
+    sigma = np.asarray(iterable(sigma, ndims))
+    pixel = np.asarray(iterable(pixel, ndims))
+    shape = np.ceil(sigma * 6 / pixel)
+    shape = tuple((shape + 1 - shape % 2).astype(int)) #odd number shape
+    coords = coordinates(shape, center=True, pixel=pixel)
+
+    # Apply Gaussian on each dimension and calculates distance from origin in sigmas
+    k = 1
+    r2 = 0 # (r/sigma)²
+    for coord, sig, pix in zip(coords, sigma, pixel) :
+        mini = (coord - pix/2) / np.sqrt(2) / sig
+        maxi = (coord + pix/2) / np.sqrt(2) / sig
+        k = k * ((erf(mini) - erf(maxi)) / 2)
+        r2 = r2 + (coord / sig)**2
+
+    # Apply mask
+    mask = r2 > 2 * erfinv((1 - tol_zero)**(1/ndims))**2 # r² > (n**(1/ndims)*sqrt(2))**2
+    k[mask] = 0
+    return k
+
+
+
+def kernel_mask(window, pixel=1, ndims=1) :
+    '''gets a n dimensions mask kernel'''
+
+    # Coordinates
+    window = np.asarray(iterable(window, ndims))
+    pixel = np.asarray(iterable(pixel, ndims))
+    shape = np.ceil(window / pixel)
+    shape = tuple((shape + 1 - shape % 2).astype(int)) #odd number shape
+    coords = coordinates(shape, center=True, pixel=pixel)
+
+    # Calculates distance from origin in windows
+    k = np.ones(shape)
+    r2 = 0 # (r/window)²
+    for coord, win, pix in zip(coords, window, pixel) :
+        r2 = r2 + (coord / win)**2
+
+    # Apply mask
+    mask = r2 > 1/4 #r² > (1/2)**2
+    k[mask] = 0
+    return k
+
+
+
+def kernel_airy(wl, NA, pixel=1, ndims=1) :
+    '''gets a n dimensions mask kernel'''
+
+    # Coordinates
+    pixel = np.asarray(iterable(pixel, ndims))
+    shape = np.ceil((2.44 * wl / NA) / pixel)
+    shape = tuple((shape + 1 - shape % 2).astype(int)) #odd number shape
+    coords = coordinates(shape, center=True, pixel=pixel)
+
+    # Calculates distance from origin in nm and pixel apply Airy function
+    r2 = 0 # r²
+    for coord in coords :
+        r2 = r2 + coord**2
+    r = np.sqrt(r2)
+    z = 2 * np.pi * r * NA / wl
+    ma = r < 1 # < 1 nm
+    k = np.empty(shape, dtype=np.float32)
+    k[~ma] = (2 * j1(z[~ma]) / z[~ma])**2
+    k[ma] = 1
+
+    # Apply mask
+    mask = r2 > (1.22 * wl / NA)**2 #r² > (1.22 * wl/NA)**2
+    k[mask] = 0
+    return k
+
+
+
+def kernel_atrou(k, order) :
+    if order == 0 :
+        return k
+    shape = k.shape
+    newshape = tuple([s + (s - 1) * order for s in shape])
+    newkernel = np.zeros(newshape)
+    slices = [slice(None,None,order+1) for _ in range(k.ndim)]
+    newkernel[*slices] = k
+    return newkernel
+
+
+
+def iterable(arg, ndims) :
+    try :
+        if len(arg) != ndims :
+            raise ValueError('Argument does not have good number of dimensions')
+        else :
+            return arg
+    except TypeError :
+        return (arg,) * ndims
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/kernel_LP/test_kernel.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : kernel
+
+"""
+This file allows to test kernel
+
+kernel : This funtion creates kernels small arrays, mainly for convolutions.
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+import pytest
+from matplotlib import pyplot as plt
+import numpy as np
+from arrlp import kernel
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+@pytest.mark.parametrize("kwargs, title", [
+    ({"window":500}, "Mask"),
+    ({"sigma":250}, "Gaussian"),
+    ({"wl":640, "NA":1.5}, "Airy"),
+])
+def test_function(kwargs, title) :
+    '''
+    Test kernel values
+    '''
+    k = kernel(pixel=10, **kwargs)
+    assert np.isclose(k.sum(), np.float32(1.))
+    plt.figure()
+    plt.imshow(k, cmap="hot")
+    plt.tight_layout()
+    plt.colorbar()
+    plt.savefig(debug_folder / f"{title}.png")
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/relabel_LP/relabel.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-31
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : relabel
+
+"""
+This function redefines a label array to fill potential holes inside.
+"""
+
+
+
+# %% Libraries
+
+import numpy as np
+from numba import njit
+
+@njit()
+def relabel(array):
+    '''
+    This function redefines a label array to fill potential holes inside.
+    
+    Parameters
+    ----------
+    labels : np.ndarray
+        array of labels (ints where each number > 0 corresponds to one object).
+
+    Returns
+    -------
+    labels : np.ndarray
+        1D version of the corrected labels array.
+
+    Examples
+    --------
+    >>> from arrlp import relabel
+    ...
+    >>> relabel(labels)
+    '''
+
+    array = array.ravel()  # Flatten array
+    unique_values = np.unique(array)  # Get sorted unique values
+    mapping = np.zeros(unique_values[-1] + 1, dtype=np.uint32)  # Create mapping array
+
+    # Assign new sequential labels
+    for new_label, old_value in enumerate(unique_values):
+        mapping[old_value] = new_label  # Map old value to new one
+
+    # Apply relabeling
+    for i in range(len(array)):
+        array[i] = mapping[array[i]]
+
+    return array.reshape((-1,))  # Return as 1D array
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules/relabel_LP/test_relabel.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-31
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : arrLP
+# Module        : relabel
+
+"""
+This file allows to test relabel
+
+relabel : This function redefines a label array to fill potential holes inside.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from arrlp import relabel
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test relabel function
+    '''
+    print('Hello world!')
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

arrlp-0.1.6/src/arrlp/modules.json

@@ -0,0 +1,38 @@
+{
+    "compress": {
+        "date": "2025-11-30",
+        "description": "Compresses an array between values by normalizing, with possibility to saturate extrema.",
+        "module": "modules/compress_LP/compress",
+        "object": "compress"
+    },
+    "convolve": {
+        "date": "2025-08-30",
+        "description": "This function convolves two numpy arrays (1D, 2D, 3D).",
+        "module": "modules/convolve_LP/convolve",
+        "object": "convolve"
+    },
+    "coordinates": {
+        "date": "2025-08-30",
+        "description": "This function will return a ndarray corresponding to the coordinates array of the input.",
+        "module": "modules/coordinates_LP/coordinates",
+        "object": "coordinates"
+    },
+    "correlate": {
+        "date": "2025-08-30",
+        "description": "This function correlates two numpy arrays (1D, 2D, 3D).",
+        "module": "modules/correlate_LP/correlate",
+        "object": "correlate"
+    },
+    "kernel": {
+        "date": "2025-08-30",
+        "description": "This funtion creates kernels small arrays, mainly for convolutions.",
+        "module": "modules/kernel_LP/kernel",
+        "object": "kernel"
+    },
+    "relabel": {
+        "date": "2025-08-31",
+        "description": "This function redefines a label array to fill potential holes inside.",
+        "module": "modules/relabel_LP/relabel",
+        "object": "relabel"
+    }
+}

arrlp-0.1.6/src/arrlp/scripts.json

@@ -0,0 +1 @@
+{}