prtools 1.3.2__tar.gz → 1.4.0__tar.gz

{prtools-1.3.2/prtools.egg-info → prtools-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prtools
-Version: 1.3.2
+Version: 1.4.0
 Summary: Utility functions for image-based phase retrieval
 Author: Andy Kee
 License: MIT License

{prtools-1.3.2 → prtools-1.4.0}/prtools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.3.2'
+__version__ = '1.4.0'
 
 from prtools.backend import __backend__, use
 
@@ -15,6 +15,16 @@ from prtools.array import (
     medfix
 )
 
+from prtools.convolve import (
+    fftconv,
+    gauss,
+    gauss_blur,
+    gauss_kernel,
+    pixel_kernel,
+    pixelate,
+    sinc,
+)
+
 from prtools.cost import sserror
 
 from prtools.fourier import dft2, idft2
@@ -38,7 +48,6 @@ from prtools.shape import (
     hexagon,
     rectangle,
     spider,
-    gauss,
     sin,
     waffle
 )

prtools-1.4.0/prtools/convolve.py

@@ -0,0 +1,348 @@
+from prtools.backend import numpy as np
+
+
+def fftconv(array, kernel, normalize_kernel=True, fft_array=True,
+            fft_kernel=True):
+    r"""Convolve an array with a kernel using the FFT.
+
+    The colvolution is computed as
+
+    .. math::
+
+        u*v = \mathcal{F}^{-1}\left\{\mathcal{F}\{u\}\cdot\mathcal{F}\{v\}\right\}
+
+    Parameters
+    ----------
+    array : array_like
+        Array to be convolved with `kernel`.
+    kernel : array_like
+        Convolution kernel. Should have the same shape as `array`.
+    normalize_kernel : bool, optional
+        If True (default), kernel is normalized so that `kernel =
+        kernel / np.sum(kernel)`.
+    fft_array : bool, optional
+        If True (default), the array is assumed to be provided in the spatial
+        domain. If False, the array is assumed to be provided in the frequency
+        domain.
+    fft_kernel : bool, optional
+        If True (default), the kernel is assumed to be provided in the spatial
+        domain. If False, the kernel is assumed to be provided in the frequency
+        domain.
+
+    Returns
+    -------
+    ndarray
+
+    See also
+    --------
+    :func:`~prtools.gauss_blur`
+    :func:`~prtools.pixelate`
+    """
+
+    a = np.fft.fft2(array) if fft_array else array
+    k = np.fft.fft2(array) if fft_kernel else kernel
+
+    if normalize_kernel:
+        k /= np.sum(k)
+
+    return np.fft.ifft2(a*k).real
+
+
+def gauss_blur(img, sigma, oversample=1):
+    """Blur an image using a Gaussian filter using the FFT. 
+
+    Parameters
+    ----------
+    img : array_like
+        Array to be blurred
+    sigma : float or (2,) array_like
+        Standard deviation of Gaussian. Providing two values allows for
+        non-symmetric Gaussian interpreted as `(sigma_row, sigma_col)`
+    oversample : float, optional
+        Oversampling factor of `img`. Default is 1.
+    
+    Returns
+    -------
+    ndarray
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> img = prtools.circle((256,256), 100)
+        >>> img_blurred = prtools.gauss_blur(img, sigma=3)
+        >>> fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(5,2))
+        >>> ax[0].imshow(img, cmap='gray')
+        >>> ax[0].set_title('Input image')
+        >>> ax[1].imshow(img_blurred, cmap='gray')
+        >>> ax[1].set_title('Blurred image')
+    """
+    img = np.asarray(img)
+    kernel = gauss_kernel(img.shape, sigma, oversample, fftshift=False)
+    return fftconv(img, kernel, normalize_kernel=True, fft_array=True,
+                   fft_kernel=False)
+
+
+def pixelate(img, oversample=1):
+    """Apply the aperture effects of an idealized square pixel on a discretely
+    sampled image using the FFT.
+
+    Parameters
+    ----------
+    img : array_like
+        Input image
+    oversample : float, optional
+        Oversampling factor of `img`. Default is 1.
+
+    Returns
+    -------
+    out : ndarray
+        Image with pixel sampling effects applied.
+
+    Notes
+    -----
+    To avoid the introduction of numerical artifacts, this function should be
+    performed on data that is at least 2x oversampled.
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> img = prtools.circle((17,17), 5)
+        >>> img_pixelate = prtools.pixelate(img)
+        >>> fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(5,2))
+        >>> ax[0].imshow(img, cmap='gray')
+        >>> ax[0].set_title('Input image')
+        >>> ax[1].imshow(img_pixelate, cmap='gray')
+        >>> ax[1].set_title('Pixelated image')
+
+    Note that the pixelation process preserves image power:
+
+    .. code:: pycon
+
+        >>> print(np.sum(img), np.sum(img_pixelate))
+        64.0, 64.0
+    """
+    img = np.asarray(img)
+    kernel = pixel_kernel(img.shape, oversample=oversample, fftshift=False)
+    return fftconv(img, kernel, normalize_kernel=False, fft_array=True,
+                   fft_kernel=False)
+
+
+def gauss(x1, x2, sigma, oversample=1, indexing='ij', normalize=False):
+    """2D Gaussian function
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        1-D arrays representing the grid coordinates
+    sigma : float or (2,) array_like
+        Standard deviation of Gaussian. Providing two values allows for
+        non-symmetric Gaussian interpreted as `(sigma_row, sigma_col)`
+    oversample : float, optional
+        Oversampling factor. Defailt is 1.
+    indexing : {'ij', 'xy'}, optional
+        Matrix ('ij', default) or cartesian ('xy') indexing of output.
+    normalize : bool, optional
+        If True, the output is normalized such that its sum is equal to 1.
+        If False (default), the output has max equal to one.
+
+    Returns
+    -------
+    ndarray
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> r = np.arange(-128,128)
+        >>> c = np.arange(-128,128)
+        >>> g = prtools.gauss(r, c, sigma=20)
+        >>> plt.imshow(g, cmap='gray')
+    """
+    xx1, xx2 = np.meshgrid(x1, x2, indexing=indexing)
+    sigma = np.broadcast_to(sigma, (2,)) / oversample
+    g = np.exp(-((xx1**2/(2*sigma[0]**2)) + (xx2**2/(2*sigma[1]**2))))
+    if normalize:
+        g = g / (2*np.pi * np.prod(sigma))
+    return g
+
+
+def sinc(x1, x2, indexing='ij'):
+    r"""Normalized 2D sinc function
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        1-D arrays representing the grid coordinates
+    indexing : {'ij', 'xy'}, optional
+        Matrix ('ij', default) or cartesian ('xy') indexing of output.
+    normalize : bool, optional
+        If True, the output is normalized such that its sum is equal to 1.
+        If False (default), the output has max equal to one.
+
+    Returns
+    -------
+    ndarray
+
+    See also
+    --------
+    :func:`~prtools.pixel_kernel`
+
+    Notes
+    -----
+    This function uses ``numpy.sinc``, which computes the sinc function as
+
+    .. math::
+        \mbox{sinc}(x) = \frac{\sin \pi x}{\pi x}
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> r = np.linspace(-3,3,512)
+        >>> c = np.linspace(-3,3,512)
+        >>> s = prtools.sinc(r, c)
+        >>> plt.imshow(s, cmap='gray', extent=[r.min(), r.max(), c.min(), c.max()])
+    """
+    xx1, xx2 = np.meshgrid(x1, x2, indexing=indexing)
+    return np.sinc(xx1) * np.sinc(xx2)
+
+
+def gauss_kernel(shape, sigma, oversample=1, fftshift=True):
+    """2D Gaussian filter kernel
+
+    This function returns the transfer function of a normalized 2D Gaussian
+    function.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the kernel
+    sigma : float
+        Standard deviation of Gaussian. Providing two values allows for
+        non-symmetric Gaussian interpreted as `(sigma_row, sigma_col)`
+    oversample : float, optional
+        Oversampling factor to represent in the kernel. Default is 1.
+    fftshift : bool, optional
+        If True (default), the kernel is FFT-shifted before it is returned.
+
+    Returns
+    -------
+    ndarray
+
+    See also
+    --------
+    :func:`~prtools.fftconv`
+    :func:`~prtools.gauss_blur`
+    :func:`~prtools.gauss`
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> blur_kernel = prtools.gauss_kernel((256,256), 1)
+        >>> plt.imshow(blur_kernel, cmap='gray')
+
+    Note this is functionally equivalent to
+
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> r = np.fft.fftfreq(256)
+        >>> c = np.fft.fftfreq(256)
+        >>> sigma = 1
+        >>> blur_kernel = np.fft.fftshift(prtools.gauss(r, c, 1/(2*np.pi*sigma)))
+        >>> plt.imshow(blur_kernel, cmap='gray')
+    """
+    
+    shape = np.broadcast_to(shape, (2,))
+    sigma = np.broadcast_to(sigma, (2,))
+
+    x1 = np.fft.fftfreq(shape[0])
+    x2 = np.fft.fftfreq(shape[1])
+
+    k = gauss(x1, x2, 1/(2*np.pi*sigma), oversample, indexing='ij',
+              normalize=False)
+
+    if fftshift:
+        return np.fft.fftshift(k)
+    else:
+        return k
+
+
+def pixel_kernel(shape, oversample=1, fftshift=True):
+    r"""2D pixel MTF filter kernel
+    
+    This function returns a normalized 2D sinc function sized to represent
+    the transfer function of an idealized square pixel.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the kernel
+    oversample : float, optional
+        Oversampling factor to represent in the kernel. Default is 1.
+    fftshift : bool, optional
+        If True (default), the kernel is FFT-shifted before it is returned.
+
+    Returns
+    -------
+    ndarray
+
+    See also
+    --------
+    :func:`~prtools.fftconv`
+    :func:`~prtools.pixelate`
+    :func:`~prtools.sinc`
+
+    Examples
+    --------
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> pixel_mtf = prtools.pixel_kernel((256,256), 1)
+        >>> plt.imshow(pixel_mtf, cmap='gray', vmin=0)
+
+    Note this is functionally equivalent to
+
+    .. plot::
+        :include-source:
+        :context: reset
+        :scale: 50
+
+        >>> r = np.fft.fftfreq(256)
+        >>> c = np.fft.fftfreq(256)
+        >>> pixel_mtf = np.fft.fftshift(np.abs(prtools.sinc(r, c)))
+        >>> plt.imshow(pixel_mtf, cmap='gray', vmin=0)
+    """
+    shape = np.broadcast_to(shape, (2,))
+
+    x1 = np.fft.fftfreq(shape[0]) / oversample
+    x2 = np.fft.fftfreq(shape[1]) / oversample
+
+    k = np.abs(sinc(x1, x2, indexing='ij'))
+
+    if fftshift:
+        return np.fft.fftshift(k)
+    else:
+        return k

{prtools-1.3.2 → prtools-1.4.0}/prtools/fourier.py

@@ -74,7 +74,7 @@ def dft2(f, alpha, shape=None, shift=(0, 0), offset=(0, 0), unitary=True,
     References
     ----------
     [1] Soummer, et. al. Fast computation of Lyot-style coronagraph
-        propagation (2007)
+    propagation (2007)
     """
     return _dftcore(f, alpha, shape, shift, offset, unitary, out, forward=True)
 

{prtools-1.3.2 → prtools-1.4.0}/prtools/jax.py

@@ -31,14 +31,22 @@ class JaxOptimizeResult:
     state: Any  #: Optimizer state
 
 
-def lbfgs(fun, x0, gtol=None, maxiter=None, callback=None):
+def lbfgs(fn, x0, gtol=None, maxiter=None, callback=None, fn_args=None, 
+          fn_kwargs=None):
     """Minimize a scalar function of one or more variables using the L-BFGS
     algorithm
 
     Parameters
     ----------
-    fun : callable
-        The objective function to be minimied
+    fn : callable
+        The objective function to be minimized:
+
+        .. code:: python
+
+            fn(x, *fn_args, **fn_kwargs)
+        
+        where ``x`` is a 1-D array with shape (n,) and ``fn_args`` and
+        ``fn_kwargs`` are optional positional and keyword arguments.
     x0 : jax.Array
         Initial guess
     gtol : float
@@ -53,6 +61,10 @@ def lbfgs(fun, x0, gtol=None, maxiter=None, callback=None):
             callback(intermediate_result: JaxOptimizeResult)
 
         where ``intermediate_result`` is a :class:`JaxOptimizeResult`.
+    fn_args : iterable or None
+        Extra positional arguments passed to ``fn()``
+    fn_kwargs : dict or None
+        Extra keyword arguments passed to the ``fn()``
 
     Returns
     -------
@@ -71,14 +83,21 @@ def lbfgs(fun, x0, gtol=None, maxiter=None, callback=None):
     if not any((gtol, maxiter)):
         raise ValueError('At least one termination tolerance must be specified.')
 
+    fn_args = [] if fn_args is None else fn_args
+    fn_kwargs = {} if fn_kwargs is None else fn_kwargs
+
     opt = optax.lbfgs()
-    value_and_grad_fun = optax.value_and_grad_from_state(fun)
+    value_and_grad_fn = optax.value_and_grad_from_state(fn)
     
     def step(carry):
         params, state = carry
-        value, grad = value_and_grad_fun(params, state=state)
+        # NOTE: passing *args and **kwargs to value_and_grad_fun is very
+        # poorly documented in optax (as of v0.2.6 - 10/2025) but this
+        # seems to work for now
+        value, grad = value_and_grad_fn(params, *fn_args, state=state, 
+                                         **fn_kwargs)
         updates, state = opt.update(
-            grad, state, params, value=value, grad=grad, value_fn=fun)
+            grad, state, params, value=value, grad=grad, value_fn=fn)
         if callback:
             res = JaxOptimizeResult(
                 n=otu.tree_get(state, 'count')-1,

{prtools-1.3.2 → prtools-1.4.0}/prtools/zernike.py

@@ -4,7 +4,7 @@ import prtools
 from prtools.backend import numpy as np
 
 
-def zernike(mask, index, normalize=True, rho=None, theta=None):
+def zernike(mask, index, normalize=True, order='noll', rho=None, theta=None):
     """Compute the circular Zernike polynomial for a given mask.
 
     Parameters
@@ -17,6 +17,8 @@ def zernike(mask, index, normalize=True, rho=None, theta=None):
     normalize : bool, optional
         If True (default), the output is normalized according to [1]. If False,
         the output value ranges [-1, 1] over the mask.
+    order : {'noll', 'fringe', 'ansi'}, optional
+        Zernike ordering scheme. Default is 'noll'.
     rho : array_like, optional
         Radial coordinates of the mask array. :attr:`rho` should be 0 at the
         origin and 1 at the edge of the circle.
@@ -44,9 +46,15 @@ def zernike(mask, index, normalize=True, rho=None, theta=None):
 
     """
     mask = np.asarray(mask)
-    #out = np.zeros_like(mask)
-    #mask_slice = util.boundary_slice(mask, pad=0)
-    #mask = mask[mask_slice]
+
+    if order == 'noll':
+        n, m = noll_to_nm(index)
+    elif order == 'fringe':
+        n, m = fringe_to_nm(index)
+    elif order =='ansi':
+        n, m = ansi_to_nm(index)
+    else:
+        raise ValueError('Unknown order', order)
     
     if rho is None:
         rho, theta = zernike_coordinates(mask)
@@ -54,8 +62,6 @@ def zernike(mask, index, normalize=True, rho=None, theta=None):
         if theta is None:
             raise ValueError("Both rho and theta must be specified")
 
-    m, n = zernike_index(index)
-
     if m == 0:
         if n == 0:
             Z = mask
@@ -97,26 +103,24 @@ def R(m, n, rho):
         return R
     
 
-def zernike_compose(mask, coeffs, normalize=True, rho=None, theta=None):
+def zernike_compose(mask, coeffs, normalize=True, order='noll', rho=None, theta=None):
     """Create an OPD based on the supplied Zernike coefficients.
 
     Parameters
     ----------
     mask : array_like
         Binary mask defining the extent to compute the Zernike polynomial over.
-
     coeffs : array_like
         List of coefficients corresponding to Zernike indices (Noll ordering)
         used to create the OPD.
-
     normalize : bool, optional
         If True (default), the output is normalized according to [1]. If False,
         the output value ranges [-1, 1] over the mask.
-
+    order : {'noll', 'fringe', 'ansi'}, optional
+        Zernike ordering scheme. Default is 'noll'.
     rho : array_like, optional
         Radial coordinates of the mask array. :attr:`rho` should be 0 at the
         origin and 1 at the edge of the circle.
-
     theta : array_like, optional
         Angular coordinates of the mask array in radians.
 
@@ -159,11 +163,12 @@ def zernike_compose(mask, coeffs, normalize=True, rho=None, theta=None):
     opd = np.zeros(mask.shape)
 
     for index, coeff in enumerate(coeffs):
-        opd += coeff * zernike(mask, index+1, normalize, rho, theta)
+        opd += coeff * zernike(mask, index+1, normalize, order, rho, theta)
 
     return opd
 
-def zernike_basis(mask, modes, vectorize=False, normalize=True, rho=None, theta=None):
+def zernike_basis(mask, modes, vectorize=False, normalize=True, order='noll',
+                  rho=None, theta=None):
     """Compute a Zernike basis set for a given mask.
 
     Parameters
@@ -180,6 +185,8 @@ def zernike_basis(mask, modes, vectorize=False, normalize=True, rho=None, theta=
     normalize : bool, optional
         If True (default), the output is normalized according to [1]. If False,
         the output value ranges [-1, 1] over the mask.
+    order : {'noll', 'fringe', 'ansi'}, optional
+        Zernike ordering scheme. Default is 'noll'.
     rho : array_like, optional
         Radial coordinates of the mask array. :attr:`rho` should be 0 at the
         origin and 1 at the edge of the circle.
@@ -203,7 +210,7 @@ def zernike_basis(mask, modes, vectorize=False, normalize=True, rho=None, theta=
 
     basis = []
     for index, mode in enumerate(modes):
-        basis.append(zernike(mask, mode, normalize, rho, theta))
+        basis.append(zernike(mask, mode, normalize, order, rho, theta))
     basis = np.asarray(basis)
 
     if vectorize:
@@ -211,9 +218,10 @@ def zernike_basis(mask, modes, vectorize=False, normalize=True, rho=None, theta=
         return basis.reshape(basis.shape[0], -1)
     else:
         return basis
-    
 
-def zernike_fit(opd, mask, modes, normalize=True, rho=None, theta=None):
+
+def zernike_fit(opd, mask, modes, normalize=True, order='noll', rho=None,
+                theta=None):
     """Fit a Zernike basis set to an OPD.
 
     Parameters
@@ -227,6 +235,8 @@ def zernike_fit(opd, mask, modes, normalize=True, rho=None, theta=None):
     normalize : bool, optional
         If True (default), the output is normalized according to [1]. If False,
         the output value ranges [-1, 1] over the mask.
+    order : {'noll', 'fringe', 'ansi'}, optional
+        Zernike ordering scheme. Default is 'noll'.
     rho : array_like, optional
         Radial coordinates of the mask array. :attr:`rho` should be 0 at the
         origin and 1 at the edge of the circle.
@@ -263,14 +273,14 @@ def zernike_fit(opd, mask, modes, normalize=True, rho=None, theta=None):
     opd = np.asarray(opd)
     mask = np.asarray(mask)
 
-    basis = zernike_basis(mask, modes, True, normalize, rho, theta)
+    basis = zernike_basis(mask, modes, True, normalize, order, rho, theta)
 
     basis = np.linalg.pinv(basis)
 
     return np.einsum('ij,i->j', basis, opd.ravel())
 
 
-def zernike_remove(opd, mask, modes, rho=None, theta=None):
+def zernike_remove(opd, mask, modes, order='noll', rho=None, theta=None):
     """Fit and remove a Zernike basis set from an OPD.
 
     Parameters
@@ -281,6 +291,8 @@ def zernike_remove(opd, mask, modes, rho=None, theta=None):
         Binary mask defining the extent to compute the Zernike basis over.
     modes : array_like
         List of modes (Noll ordering) to remove.
+    order : {'noll', 'fringe', 'ansi'}, optional
+        Zernike ordering scheme. Default is 'noll'.
     rho : array_like, optional
         Radial coordinates of the mask array. :attr:`rho` should be 0 at the
         origin and 1 at the edge of the circle.
@@ -303,35 +315,34 @@ def zernike_remove(opd, mask, modes, rho=None, theta=None):
     opd = np.asarray(opd)
     mask = np.asarray(mask)
 
-    coeffs = zernike_fit(opd, mask, modes, rho, theta)
-    fit_opd = zernike_compose(mask, coeffs, rho, theta)
+    coeffs = zernike_fit(opd, mask, modes, True, order, rho, theta)
+    fit_opd = zernike_compose(mask, coeffs, True, order, rho, theta)
 
     residual = opd - fit_opd
 
     return residual
 
 
-def zernike_index(j):
-    """Convert a 1-D Noll index to a 2-D radiul and azimuthal index.
+def noll_to_nm(j):
+    """Convert Noll index to (n, m) index.
 
     Parameters
     ----------
     j : int
-        Noll Zernike index.
+        Noll Zernike index
 
     Returns
     -------
     n : int
-        Radial Zernike index.
+        Radial degree.
     m : int
-        Azimuthal Zernike index.
-
+        Azimuthal degree.
     """
     if j < 1:
-        raise ValueError('Zernike index j must be a positive integer')
+        raise ValueError('Noll index must be greater than zero')
 
     # find the row j is in
-    n = int(np.ceil((-1 + np.sqrt(1 + 8*j)) / 2) - 1)
+    n = int(np.ceil((-1 + np.sqrt(1 + 8 * j)) / 2) - 1)
     if n == 0:
         m = 0
     else:
@@ -349,13 +360,63 @@ def zernike_index(j):
         else:
             row_m = [0]
 
-        for i in range(int(np.floor(n / 2))):
+        for _ in range(n // 2):
             row_m.append(row_m[-1] + 2)
             row_m.append(row_m[-1])
 
         m = row_m[r] * sign
 
-    return m, n
+    return int(n), int(m)
+
+
+def ansi_to_nm(j):
+    """Convert ANSI index to (n, m) index.
+
+    Parameters
+    ----------
+    j : int
+        ANSI index
+
+    Returns
+    -------
+    n : int
+        Radial degree
+    m : int
+        Azimuthal degree
+    """
+    if j < 0:
+        raise ValueError('ANSI index must be zero or larger')
+    
+    # https://en.wikipedia.org/wiki/Zernike_polynomials
+    n = np.floor((np.sqrt(8 * j + 1) - 1) / 2)
+    m = 2*j - n*(n + 2)
+    return int(n), int(m)
+
+
+def fringe_to_nm(j):
+    """Convert Fringe index to (n, m) index.
+
+    Parameters
+    ----------
+    j : int
+        Fringe index
+
+    Returns
+    -------
+    n : int
+        Radial degree
+    m : int
+        Azimuthal degree
+    """
+    if j < 1:
+        raise ValueError('Fringe index must be greater than zero')
+    
+    # https://github.com/arielmission-space/PAOS/blob/main/paos/classes/zernike.py
+    m_n = 2 * (np.ceil(np.sqrt(j)) - 1)
+    g_s = (m_n / 2) ** 2 + 1
+    n = m_n / 2 + np.floor((j - g_s) / 2)
+    m = (m_n - n) * (1 - np.mod(j - g_s, 2) * 2)
+    return int(n), int(m)
 
 
 def zernike_coordinates(mask, shift=None, angle=0, indexing='ij'):

{prtools-1.3.2 → prtools-1.4.0/prtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prtools
-Version: 1.3.2
+Version: 1.4.0
 Summary: Utility functions for image-based phase retrieval
 Author: Andy Kee
 License: MIT License

{prtools-1.3.2 → prtools-1.4.0}/prtools.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.rst
 pyproject.toml
 prtools/__init__.py
 prtools/array.py
+prtools/convolve.py
 prtools/cost.py
 prtools/fourier.py
 prtools/jax.py