impy-array 2.3.3__py3-none-any.whl → 2.4.1__py3-none-any.whl

impy/__init__.py

@@ -1,19 +1,19 @@
-__version__ = "2.3.3"
+__version__ = "2.4.1"
 __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

@@ -6,7 +6,7 @@ from scipy import ndimage as scipy_ndi
 
 
 __all__ = ["binary_erosion",
-    "erosion"
+    "erosion",
     "binary_dilation",
     "dilation",
     "binary_opening",

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)

impy/arrays/_utils/_transform.py

@@ -10,9 +10,9 @@ if TYPE_CHECKING:
     from impy import ImgArray
 
 __all__ = [
-    "compose_affine_matrix", 
+    "compose_affine_matrix",
     "decompose_affine_matrix",
-    "affinefit", 
+    "affinefit",
     "check_matrix",
     "warp",
 ]
@@ -24,8 +24,8 @@ class AffineTransformationParameters(NamedTuple):
     shear: np.ndarray
 
 def warp(
-    img: xp.ndarray,
-    matrix: xp.ndarray,
+    img: np.ndarray,
+    matrix: np.ndarray,
     mode="constant",
     cval=0,
     output_shape=None,
@@ -35,13 +35,13 @@ def warp(
 ):
     img = xp.asarray(img, dtype=img.dtype)
     matrix = xp.asarray(matrix)
-    out = xp.ndi.affine_transform(img, matrix, cval=cval, mode=mode, output_shape=output_shape, 
+    out = xp.ndi.affine_transform(img, matrix, cval=cval, mode=mode, output_shape=output_shape,
                                   offset=offset, order=order, prefilter=prefilter)
     return out
 
-def shift(img: xp.ndarray, shift: xp.ndarray, cval=0, mode="constant", order=1, prefilter=False):
+def shift(img: np.ndarray, shift: np.ndarray, cval=0, mode="constant", order=1, prefilter=False):
     img = xp.asarray(img, dtype=img.dtype)
-    out = xp.ndi.shift(img, shift, cval=cval, mode=mode, 
+    out = xp.ndi.shift(img, shift, cval=cval, mode=mode,
                        order=order, prefilter=prefilter)
     return out
 
@@ -71,10 +71,10 @@ def compose_affine_matrix(
             translation = [translation] * ndim
         if rotation is not None:
             rotation = np.rad2deg(rotation)
-        
+
         af = Affine(scale=scale, translate=translation, rotate=rotation, shear=shear)
         mx = af.affine_matrix
-    
+
     return mx
 
 
@@ -83,12 +83,12 @@ def decompose_affine_matrix(matrix: np.ndarray):
     if ndim == 2:
         from skimage.transform import AffineTransform
         af = AffineTransform(matrix=matrix)
-        out = AffineTransformationParameters(translation=af.translation, rotation=af.rotation, 
+        out = AffineTransformationParameters(translation=af.translation, rotation=af.rotation,
                                              scale=af.scale, shear=af.shear)
     else:
         from napari.utils.transforms import Affine
         af = Affine(affine_matrix=matrix)
-        out = AffineTransformationParameters(translation=af.translate, rotation=af.rotate, 
+        out = AffineTransformationParameters(translation=af.translate, rotation=af.rotate,
                                              scale=af.scale, shear=af.shear)
     return out
 
@@ -104,8 +104,10 @@ def affinefit(img, imgref, bins=256, order=1):
     from scipy.stats import entropy
     from scipy.optimize import minimize
     from skimage.transform import warp
-    
-    as_3x3_matrix = lambda mtx: np.vstack((mtx.reshape(2,3), [0., 0., 1.]))
+
+    def as_3x3_matrix(mtx: np.ndarray):
+        return np.vstack((mtx.reshape(2,3), [0., 0., 1.]))
+
     def normalized_mutual_information(img, imgref):
         """
         Y(A,B) = (H(A)+H(B))/H(A,B)
@@ -117,15 +119,15 @@ def affinefit(img, imgref, bins=256, order=1):
         e2 = entropy(np.sum(hist, axis=1))
         e12 = entropy(np.ravel(hist)) # mutual entropy
         return (e1 + e2)/e12
-    
+
     def cost_nmi(mtx, img, imgref):
         mtx = as_3x3_matrix(mtx)
         img_transformed = warp(img, mtx, order=order)
         return -normalized_mutual_information(img_transformed, imgref)
-    
+
     mtx0 = np.array([[1., 0., 0.],
                      [0., 1., 0.]]) # aberration makes little difference
-    
+
     result = minimize(
         cost_nmi, mtx0, args=(np.asarray(img), np.asarray(imgref)), method="Powell"
     )
@@ -134,24 +136,24 @@ def affinefit(img, imgref, bins=256, order=1):
 
 
 def check_matrix(matrices: list[np.ndarray | float]):
-    """Check Affine transformation matrix."""    
+    """Check Affine transformation matrix."""
     mtx = []
     for m in matrices:
-        if np.isscalar(m): 
+        if np.isscalar(m):
             if m == 1:
                 mtx.append(m)
             else:
                 raise ValueError(f"Only `1` is ok, but got {m}")
-            
+
         elif m.shape != (3, 3) or not np.allclose(m[2,:2], 0):
             raise ValueError(f"Wrong Affine transformation matrix:\n{m}")
-        
+
         else:
             mtx.append(m)
     return mtx
 
 def polar2d(
-    img: xp.ndarray,
+    img: np.ndarray,
     rmax: int,
     dtheta: float = 0.1,  # radian
     order: int = 1,
@@ -170,14 +172,14 @@ def polar2d(
     return out
 
 def normalize_radon_input(
-    self: ImgArray, 
-    dims: Axes, 
-    central_axis: AxisLike, 
+    self: ImgArray,
+    dims: Axes,
+    central_axis: AxisLike,
     degrees: Sequence[float] | float,
-):    
+):
     ndim = len(dims)
     squeeze = not hasattr(degrees, "__iter__")
-    
+
     if squeeze:
         degrees = [degrees]
     if ndim != self.ndim:
@@ -213,7 +215,7 @@ def normalize_radon_input(
             central_axis: np.ndarray
             if central_axis.shape != (ndim,):
                 raise ValueError(f"Image is {ndim}D but central_axis is {central_axis.ndim}D.")
-        
+
         # construct Affine transform matrices
         height = int(np.ceil(np.linalg.norm(self.shape)))
         output_shape = (height, self.shape[1], self.shape[2])
@@ -222,11 +224,11 @@ def normalize_radon_input(
         )
     else:
         raise ValueError("Only 2D or 3D input is supported.")
-    
+
     return params, output_shape, squeeze
 
 def normalize_iradon_input(
-    self: ImgArray, 
+    self: ImgArray,
     central_axis: AxisLike,
     height_axis: AxisLike,
     degree_axis: AxisLike,
@@ -250,7 +252,7 @@ def normalize_iradon_input(
     output_shape = (height, self.shape[-1])
     return central_axis, degree_axis, output_shape, new_axes
 
-def radon_single(img: xp.ndarray, mtx: np.ndarray, order: int = 3, output_shape=None):
+def radon_single(img: np.ndarray, mtx: np.ndarray, order: int = 3, output_shape=None):
     """Radon transform of 2D image."""
     img_rot = warp(img, mtx, order=order, output_shape=output_shape, prefilter=False)
     return xp.sum(img_rot, axis=0)
@@ -290,13 +292,13 @@ def _get_rotation_matrices_for_radon_3d(
     return np.einsum("ij,njk,kl->nil", tr_0, rotation, tr_1)
 
 # This function is mostly ported from `skimage.transform`.
-# The most important difference is that this implementation support arbitrary 
+# The most important difference is that this implementation support arbitrary
 # output shape.
 def iradon(
-    img: xp.ndarray, 
-    degrees: xp.ndarray,
+    img: np.ndarray,
+    degrees: np.ndarray,
     output_shape: tuple[int, int],
-    filter_func: xp.ndarray,
+    filter_func: np.ndarray,
     interp: Callable[[np.ndarray, np.ndarray], np.ndarray],
 ):
     angles_count = len(degrees)
@@ -322,7 +324,7 @@ def iradon(
 
     return reconstructed * np.pi / (2 * angles_count)
 
-# This function is almost ported from `skimage.transform`, but create a ramp 
+# This function is almost ported from `skimage.transform`, but create a ramp
 # filter in a simpler way.
 def get_fourier_filter(size: int, filter_name: str):
     # ramp filter