impy-array 2.3.2__py3-none-any.whl → 2.4.0__py3-none-any.whl

impy/__init__.py

@@ -1,19 +1,19 @@
-__version__ = "2.3.2"
+__version__ = "2.4.0"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 
 import logging
 
-from ._const import Const, SetConst, use
+from ._const import Const, SetConst, use  # noqa
 
-from .collections import DataList, DataDict
-from .core import *
-from .binder import bind
-from .viewer import gui
-from .correlation import *
-from .arrays import ImgArray, LazyImgArray, BigImgArray, Label  # for typing
-from . import random, io, lazy
-from .axes import slicer
+from .collections import DataList, DataDict  # noqa
+from .core import *  # noqa
+from .binder import bind  # noqa
+from .viewer import gui  # noqa
+from .correlation import *  # noqa
+from .arrays import ImgArray, LazyImgArray, BigImgArray, Label  # noqa
+from . import random, io, lazy  # noqa
+from .axes import slicer  # noqa
 
 # Inheritance
 # -----------
@@ -34,7 +34,7 @@ logging.getLogger("tifffile").setLevel(logging.ERROR)
 del logging
 
 # dtypes
-from numpy import (
+from numpy import (  # noqa
     uint8, uint16, uint32, uint64,
     int8, int16, int32, int64,
     float16, float32, float64,

impy/arrays/_utils/_deconv.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
 from functools import partial
 import numpy as np
 from impy.array_api import xp
 
-if TYPE_CHECKING:
-    from impy.arrays import ImgArray
-    
 try:
     gradient = xp.gradient
 except AttributeError:
@@ -17,18 +13,18 @@ except AttributeError:
         out = numpy.gradient(a.get(), axis=axis)
         return xp.asarray(out)
 
-__all__ = ["wiener", "lucy", "lucy_tv", "check_psf"]
+__all__ = ["wiener", "richardson_lucy", "richardson_lucy_tv", "check_psf"]
 
 def wiener(obs, psf_ft, psf_ft_conj, lmd):
     obs = xp.asarray(obs)
     fft = xp.fft.rfftn
     ifft = partial(xp.fft.irfftn, s=obs.shape)
-    
+
     img_ft = fft(obs)
-    
+
     estimated = xp.real(ifft(img_ft*psf_ft_conj / (psf_ft*psf_ft_conj + lmd)))
     return xp.fft.fftshift(estimated)
-    
+
 def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
     # Identical to the algorithm in Deconvolution.jl of Julia.
     obs = xp.asarray(obs)
@@ -36,12 +32,12 @@ def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
     ifft = partial(xp.fft.irfftn, s=obs.shape)
     conv = factor = xp.empty(obs.shape, dtype=xp.float32) # placeholder
     estimated = xp.real(ifft(fft(obs) * psf_ft))   # initialization
-    
+
     for _ in range(niter):
         conv[:] = ifft(fft(estimated) * psf_ft).real
         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
         estimated *= factor
-        
+
     return xp.fft.fftshift(estimated)
 
 def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
@@ -51,21 +47,21 @@ def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
     est_old = ifft(fft(obs) * psf_ft).real
     est_new = xp.empty(obs.shape, dtype=xp.float32)
     conv = factor = norm = gg = xp.empty(obs.shape, dtype=np.float32) # placeholder
-    
+
     for _ in range(max_iter):
         conv[:] = ifft(fft(est_old) * psf_ft).real
         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
         est_new[:] = est_old * factor
         grad = gradient(est_old)
         norm[:] = xp.sqrt(sum(g**2 for g in grad))
-        gg[:] = sum(gradient(_safe_div(grad[i], norm, eps=1e-8), axis=i) 
+        gg[:] = sum(gradient(_safe_div(grad[i], norm, eps=1e-8), axis=i)
                     for i in range(obs.ndim))
         est_new /= (1 - lmd * gg)
         gain = xp.sum(xp.abs(est_new - est_old))/xp.sum(xp.abs(est_old))
         if gain < tol:
             break
         est_old[:] = est_new
-        
+
     return xp.fft.fftshift(est_new)
 
 
@@ -81,7 +77,7 @@ def check_psf(img_shape: tuple[int, ...], img_scale: tuple[float, ...], psf):
         psf = psf(img_shape, img_scale)
     psf = xp.asarray(psf, dtype=np.float32)
     psf /= xp.sum(psf)
-    
+
     if img_shape != psf.shape:
         raise ValueError(
             f"observation and PSF have different shape: {img_shape} and {psf.shape}"

impy/arrays/_utils/_filters.py

@@ -4,16 +4,16 @@ from ._linalg import hessian_eigval
 from impy.array_api import xp, cupy_dispatcher
 from scipy import ndimage as scipy_ndi
 
-               
+
 __all__ = ["binary_erosion",
-    "erosion"
+    "erosion",
     "binary_dilation",
     "dilation",
     "binary_opening",
     "opening",
     "binary_closing",
     "closing",
-    "gaussian_filter", 
+    "gaussian_filter",
     "gaussian_filter_fourier",
     "median_filter",
     "convolve",
@@ -124,7 +124,7 @@ def coef_filter(data, selem, mode="reflect", cval=0.0):
     x2 = convolve(data**2, selem, mode=mode, cval=cval)
     out = _safe_sqrt(xp.asnumpy(x2 - x1**2), fill=0)/xp.asnumpy(x1)
     return out
-    
+
 def dog_filter(img, low_sigma, high_sigma, mode="reflect", cval=0.0):
     filt_l = gaussian_filter(img, low_sigma, mode=mode, cval=cval)
     filt_h = gaussian_filter(img, high_sigma, mode=mode, cval=cval)
@@ -164,23 +164,23 @@ def population(img, selem):
 # See skimage/feature/template.py
 def ncc_filter(img: np.ndarray, template: np.ndarray, bg=0, mode="constant"):
     from scipy.signal import fftconvolve
-    from skimage import feature
+    from skimage.feature import template as skimage_template
     ndim = template.ndim
-    _win_sum = feature.template._window_sum_2d if ndim == 2 else feature.template._window_sum_3d
+    _win_sum = skimage_template._window_sum_2d if ndim == 2 else skimage_template._window_sum_3d
     pad_width = [(w, w) for w in template.shape]
     padimg = np.pad(img, pad_width=pad_width, mode=mode, constant_values=bg)
-    
+
     corr = fftconvolve(padimg, template[(slice(None,None,-1),)*ndim], mode="valid")[(slice(1,-1,None),)*ndim]
-    
+
     win_sum1 = _win_sum(padimg, template.shape)
     win_sum2 = _win_sum(padimg**2, template.shape)
-    
+
     template_mean = np.mean(template)
     template_volume = np.prod(template.shape)
     template_ssd = np.sum((template - template_mean)**2)
-    
+
     var = (win_sum2 - win_sum1**2/template_volume) * template_ssd
-    
+
     # zero division happens when perfectly matched
     response = np.ones_like(corr)
     mask = var > np.finfo(np.float32).eps
@@ -192,7 +192,7 @@ def ncc_filter(img: np.ndarray, template: np.ndarray, bg=0, mode="constant"):
         slices.append(slice(d0, d1))
     out = response[tuple(slices)]
     return out
-    
+
 def _safe_sqrt(a: np.ndarray, fill=0):
     out = np.full(a.shape, fill, dtype=np.float32)
     out = np.zeros_like(a)

impy/arrays/_utils/_glcm.py

@@ -1,6 +1,6 @@
 import numpy as np
-from ...collections import DataDict
 import scipy
+from impy.collections import DataDict
 
 __all__ = ["glcm_props_", "check_glcm"]
 
@@ -15,7 +15,7 @@ def asm_(glcm, ref, nei):
 
 def idm_(glcm, ref, nei):
     return np.sum(glcm/(1+(ref-nei)**2), axis=(0,1))
-    
+
 def energy_(glcm, ref, nei):
     return np.sqrt(np.sum(glcm**2, axis=(0,1)))
 
@@ -29,11 +29,11 @@ def entropy_(glcm, ref, nei):
 def correlation_(glcm, ref, nei):
     diffy = ref - np.sum(glcm * ref, axis=(0,1))
     diffx = nei - np.sum(glcm * nei, axis=(0,1))
-    
+
     stdy = np.sqrt(np.sum(glcm*diffy**2, axis=(0,1)))
     stdx = np.sqrt(np.sum(glcm*diffx**2, axis=(0,1)))
     cov = np.sum(glcm*diffx*diffy, axis=(0,1))
-    
+
     out = np.empty(glcm.shape[2:], dtype=np.float32)
     mask_0 = np.logical_or(stdx<1e-15, stdy<1e-15)
     mask_1 = ~mask_0
@@ -73,7 +73,7 @@ propdict = {"contrast": contrast_,
 def glcm_props_(data, distances, angles, levels, radius, properties):
     outshape = (len(distances), len(angles)) + \
         (data.shape[0]-2*radius, data.shape[1]-2*radius)
-        
+
     propout = DataDict()
     for prop in properties:
         if isinstance(prop, str):
@@ -82,13 +82,13 @@ def glcm_props_(data, distances, angles, levels, radius, properties):
             propout[prop.__name__] = np.empty(outshape, dtype=np.float32)
     # placeholder
     glcm = np.empty((levels, levels, len(distances), len(angles)), dtype=np.float32)
-    
+
     ref, nei = np.indices((levels, levels), dtype=np.float32)
     ref = ref[:, :, np.newaxis, np.newaxis]
     nei = nei[:, :, np.newaxis, np.newaxis]
-    
+
     from ._process_numba import _calc_glcm
-    
+
     for x in range(outshape[3]):
         for y in range(outshape[2]):
             # calc glcm
@@ -101,7 +101,7 @@ def glcm_props_(data, distances, angles, levels, radius, properties):
                 else:
                     # only callable
                     propout[prop.__name__][:,:,y,x] = prop(glcm, ref, nei)
-    
+
     return propout
 
 def check_glcm(self, bins, rescale_max):
@@ -112,22 +112,22 @@ def check_glcm(self, bins, rescale_max):
             bins = 256
     elif bins > 256:
         raise ValueError("`bins` must be smaller than 256.")
-    
+
     if self.dtype == np.uint16:
         self = self.as_uint8()
     elif self.dtype == np.uint8:
         pass
     else:
         raise TypeError(f"Cannot calculate comatrix of {self.dtype} image.")
-        
+
     imax = np.iinfo(self.dtype).max
-    
+
     if rescale_max:
         scale = int(imax/self.max())
         self *= scale
-    
+
     if (imax+1) % bins != 0 or bins > imax+1:
         raise ValueError(f"`bins` must be a divisor of {imax+1} (max value of {self.dtype}).")
     self = self // ((imax+1) // bins)
-    
-    return self, bins, rescale_max
+
+    return self, bins, rescale_max

impy/arrays/_utils/_misc.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import numpy as np
-from ...array_api import xp
+from impy.array_api import xp
 
 def adjust_bin(
     img: np.ndarray,
@@ -44,12 +44,12 @@ def make_rotated_axis(src, dst):
 def make_pad(pad_width, dims, all_axes, **kwargs):
     """More flexible padding than `np.pad`."""
     pad_width_ = []
-        
+
     # for consistency with scipy-format
     if "cval" in kwargs.keys():
         kwargs["constant_values"] = kwargs["cval"]
         kwargs.pop("cval")
-        
+
     if hasattr(pad_width, "__iter__") and len(pad_width) == len(dims):
         pad_iter = iter(pad_width)
         for a in all_axes:
@@ -57,7 +57,7 @@ def make_pad(pad_width, dims, all_axes, **kwargs):
                 pad_width_.append(next(pad_iter))
             else:
                 pad_width_.append((0, 0))
-        
+
     elif isinstance(pad_width, int):
         for a in all_axes:
             if a in dims:
@@ -66,7 +66,7 @@ def make_pad(pad_width, dims, all_axes, **kwargs):
                 pad_width_.append((0, 0))
     else:
         raise TypeError(f"pad_width must be iterable or int, but got {type(pad_width)}")
-    
+
     return pad_width_
 
 def dft(img: xp.ndarray, exps: list[xp.ndarray] = None):

impy/arrays/_utils/_structures.py

@@ -1,5 +1,5 @@
 import numpy as np
-from ...array_api import xp
+from impy.array_api import xp
 
 def circle(radius, shape, dtype="bool"):
     x = xp.arange(-(shape[0] - 1) / 2, (shape[0] - 1) / 2 + 1)
@@ -10,7 +10,7 @@ def circle(radius, shape, dtype="bool"):
 def ball_like(radius, ndim:int):
     half_int = int(2*radius)/2
     L = xp.arange(-half_int, half_int + 1)
-    
+
     if ndim == 1:
         return xp.ones(int(radius)*2+1, dtype=np.uint8)
     elif ndim == 2:
@@ -32,9 +32,9 @@ def ball_like_odd(radius, ndim):
      [1, 1, 1, 1],
      [0, 1, 1, 0]]
     This is not suitable for specify().
-    """    
+    """
     xc = int(radius)
     l = xc*2 + 1
     coords = xp.indices((l,)*ndim)
     s = xp.sum((a-xc)**2 for a in coords)
-    return xp.array(s <= radius*radius, dtype=bool)
+    return xp.array(s <= radius*radius, dtype=bool)