impy-array 2.4.4__py3-none-any.whl → 2.4.6__py3-none-any.whl

impy/__init__.py

@@ -1,19 +1,19 @@
-__version__ = "2.4.4"
+__version__ = "2.4.6"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 
 import logging
+from typing import TYPE_CHECKING
 
-from ._const import Const, SetConst, use  # noqa
+from impy._const import Const, SetConst, use  # noqa
 
-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
+from impy.collections import DataList, DataDict  # noqa
+from impy.core import *  # noqa
+from impy.binder import bind  # noqa
+from impy.correlation import *  # noqa
+from impy.arrays import ImgArray, LazyImgArray, BigImgArray, Label  # noqa
+from impy import random, io, lazy  # noqa
+from impy.axes import slicer  # noqa
 
 # Inheritance
 # -----------
@@ -41,3 +41,23 @@ from numpy import (  # noqa
     complex64, complex128,
     bool_,
 )
+
+# lazy loading
+
+_VIEWER_CACHE = None
+if TYPE_CHECKING:
+    from impy.viewer import napariViewers
+
+    gui: "napariViewers"
+
+def __getattr__(key):
+    global _VIEWER_CACHE
+
+    if key == "gui":
+        from impy.viewer import napariViewers
+
+        if _VIEWER_CACHE is None:
+            _VIEWER_CACHE = napariViewers()
+        return _VIEWER_CACHE
+    else:
+        raise AttributeError(f"module 'impy' has no attribute '{key}'")

impy/arrays/_utils/_misc.py

@@ -41,6 +41,9 @@ def make_rotated_axis(src, dst):
     n = int(round(d))
     return np.linspace(src, src + dr / d * (n - 1), n)
 
+def make_rotated_axis_by_vec(src, unit_vec, n: int):
+    return np.linspace(src, src + unit_vec * (n - 1), n)
+
 def make_pad(pad_width, dims, all_axes, **kwargs):
     """More flexible padding than `np.pad`."""
     pad_width_ = []

impy/arrays/big.py

@@ -31,7 +31,6 @@ class BigImgArray(LazyImgArray):
     fft = wrap_method(LazyImgArray.fft)
     ifft = wrap_method(LazyImgArray.ifft)
     power_spectra = wrap_method(LazyImgArray.power_spectra)
-    tiled_lowpass_filter = wrap_method(LazyImgArray.tiled_lowpass_filter)
     proj = wrap_method(LazyImgArray.proj)
     binning = wrap_method(LazyImgArray.binning)
     track_drift = wrap_method(LazyImgArray.track_drift)

impy/arrays/imgarray.py

@@ -217,13 +217,13 @@ class ImgArray(LabeledArray):
             c_axes=complement_axes(dims, self.axes),
             kwargs=dict(matrix=mx, order=order, mode=mode, cval=cval),
         )
-    
+
     @_docs.write_docs
     @dims_to_spatial_axes
     @same_dtype(asfloat=True)
     @check_input_and_output
     def shift(
-        self, translation, order: int = 3, mode: PaddingMode = "constant", 
+        self, translation, order: int = 3, mode: PaddingMode = "constant",
         cval: float = 0, prefilter: bool | None = None, dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
@@ -329,7 +329,9 @@ class ImgArray(LabeledArray):
         out.set_scale({a: self.scale[a]/scale for a, scale in zip(self.axes, zoom_)})
         return out
 
-    rescale = zoom  # backward compatibility
+    def log(self, eps: float = 1e-8) -> ImgArray:
+        """Calculate natural logarithm of the image, with a small epsilon."""
+        return np.log(self.as_float() + eps)
 
     @_docs.write_docs
     @dims_to_spatial_axes
@@ -902,6 +904,51 @@ class ImgArray(LabeledArray):
         return xp.asnumpy(out)
 
 
+    @_docs.write_docs
+    @dims_to_spatial_axes
+    @same_dtype(asfloat=True)
+    @check_input_and_output
+    def bandpass_filter(
+        self,
+        cuton: nDFloat = 0.02,
+        cutoff: nDFloat = 0.2,
+        order: float = 2,
+        *,
+        dims: Dims = None,
+        update: bool = False
+    ):
+        """
+        Butterworth band-pass filter.
+
+        Parameters
+        ----------
+        cuton, cutoff : float or array-like
+            Cuton and Cutoff frequency. Fequency domain between these two values will be
+            passed.
+        order : float, default is 2
+            Steepness of cutoff.
+        {dims}{update}
+
+        Returns
+        -------
+        ImgArray
+            Filtered image
+        """
+        from ._utils._skimage import _get_ND_butterworth_filter
+        cuton = check_nd(cuton, len(dims))
+        cutoff = check_nd(cutoff, len(dims))
+        spatial_shape = self.sizesof(dims)
+        spatial_axes = [self.axisof(a) for a in dims]
+        weight_on = _get_ND_butterworth_filter(spatial_shape, cuton, order, True, True)
+        weight_off = _get_ND_butterworth_filter(spatial_shape, cutoff, order, False, True)
+        weight = weight_off * weight_on
+        input = xp.asarray(self.value)
+        if len(dims) < self.ndim:
+            weight = add_axes(self.axes, self.shape, weight, dims)
+        out = xp.fft.irfftn(xp.asarray(weight)*xp.fft.rfftn(input, axes=spatial_axes),
+                            s=spatial_shape, axes=spatial_axes)
+        return xp.asnumpy(out)
+
     @_docs.write_docs
     @dims_to_spatial_axes
     @same_dtype(asfloat=True)

impy/arrays/labeledarray.py

@@ -848,8 +848,8 @@ class LabeledArray(MetaArray):
         Parameters
         ----------
         pixel : int or array-like, default is 1
-            Number of pixels to remove. If an array is given, each axis will be cropped with different pixels,
-            using each value respectively.
+            Number of pixels to remove. If an array is given, each axis will be cropped
+            with different pixels, using each value respectively.
         {dims}
 
         Returns
@@ -869,16 +869,65 @@ class LabeledArray(MetaArray):
         out = self[fmt[sl]]
         return out
 
+    def crop_subregion(
+        self,
+        centers: Coords,
+        shape: tuple[int, int],
+        angles: float | Sequence[float] = 0,
+        *,
+        order=3,
+    ) -> Self:
+        """
+        Crop a subragion of an image.
+
+        Parameters
+        ----------
+        centers : sequence of (float, float)
+            Center coordinates in pixels.
+        shape : (int, int)
+            Shape of the subregion.
+        angles : float or sequence of float, default is 0
+            Clockwise angle of the subregion.
+        {dims}
+        """
+        if order > 1:
+            self_filt = self.spline_filter(order).value
+        else:
+            self_filt = self.value
+        centers = np.asarray(centers)
+        if np.isscalar(angles):
+            angles = [angles] * len(centers)
+        else:
+            if len(centers) != len(angles):
+                raise ValueError("Length of centers and angles must be the same.")
+        cropped_imgs = []
+        for center, angle in zip(centers, angles, strict=True):
+            center = np.asarray(center)
+            rad = np.deg2rad(angle)
+            ey = np.array([np.sin(rad), np.cos(rad)])
+            ex = np.array([np.cos(rad), -np.sin(rad)])
+            ny, nx = shape
+            origin = center - ey * (nx - 1) / 2 - ex * (ny - 1) / 2
+            ax0 = _misc.make_rotated_axis_by_vec(origin, ex, nx)
+            ax1 = _misc.make_rotated_axis_by_vec(origin, ey, ny)
+            all_coords = ax0[:, np.newaxis] + ax1[np.newaxis] - origin
+            all_coords = np.moveaxis(all_coords, -1, 0)
+            cropped_img = ndi.map_coordinates(self_filt, all_coords, prefilter=False, order=order)
+            cropped_imgs.append(cropped_img)
+        cropped_imgs = np.stack(cropped_imgs, axis=0).view(self.__class__)
+        return cropped_imgs._set_info(self, new_axes="p" + self.axes)
+
     @_docs.write_docs
     @check_input_and_output
     @dims_to_spatial_axes
-    def rotated_crop(self, origin, dst1, dst2, dims=2) -> Self:
+    def rotated_crop(self, origin, dst1, dst2, *, crop_labels: bool = True, dims=2) -> Self:
         """
-        Crop the image at four courners of an rotated rectangle. Currently only supports rotation within
-        yx-plane. An rotated rectangle is specified with positions of a origin and two destinations `dst1`
-        and `dst2`, i.e., vectors (dst1-origin) and (dst2-origin) represent a rotated rectangle. Let
-        origin be the origin of a xy-plane, the rotation direction from dst1 to dst2 must be counter-
-        clockwise, or the cropped image will be reversed.
+        Crop the image at four courners of an rotated rectangle. Currently only supports
+        rotation within yx-plane. An rotated rectangle is specified with positions of a
+        origin and two destinations `dst1` and `dst2`, i.e., vectors (dst1-origin) and
+        (dst2-origin) represent a rotated rectangle. Let origin be the origin of a
+        xy-plane, the rotation direction from dst1 to dst2 must be counter-clockwise,
+        or the cropped image will be reversed.
 
         Parameters
         ----------
@@ -907,7 +956,7 @@ class LabeledArray(MetaArray):
         )
         cropped_img = cropped_img.view(self.__class__)
         cropped_img.axes = self.axes
-        if self.labels is not None:
+        if crop_labels and self.labels is not None:
             try:
                 lbl = self.labels
                 cropped_labels = np.empty(lbl.shape[:-2] + all_coords.shape[1:], dtype=lbl.dtype)

impy/arrays/lazy.py

@@ -1041,19 +1041,6 @@ class LazyImgArray(AxesMixin):
 
         return out
 
-    @dims_to_spatial_axes
-    @check_input_and_output_lazy
-    def tiled_lowpass_filter(self, cutoff: float = 0.2, order: int = 2, overlap: int = 16, *,
-                             dims: Dims = None, update: bool = False) -> LazyImgArray:
-        warnings.warn(
-            "`tiled_lowpass_filter` is deprecated. Please use "
-            f"`img.tiled({overlap=}).lowpass_filter({cutoff=}, {order=})` instead.",
-            DeprecationWarning,
-        )
-        return self.tiled(
-            chunks=self.chunksizesof(dims), overlap=overlap, dims=dims,
-        ).lowpass_filter(cutoff, order)
-
     @_docs.copy_docs(ImgArray.proj)
     @same_dtype
     def proj(self, axis: str = None, method: str = "mean") -> LazyImgArray:

impy/arrays/tiled.py

@@ -24,10 +24,10 @@ class TiledAccessor(Generic[_T]):
 class _PartialTiledImage(Generic[_T]):
     def __init__(self, img: _T):
         self._img = weakref.ref(img)
-    
+
     def __call__(
-        self, 
-        chunks: tuple[int, ...] | Literal["auto"] = "auto", 
+        self,
+        chunks: tuple[int, ...] | Literal["auto"] = "auto",
         overlap: int | tuple[int, ...] = 32,
         boundary: Boundary | list[Boundary] = "reflect",
         dims: Dims = None,
@@ -78,13 +78,13 @@ class TiledImage(Generic[_T]):
         else:
             img_repr = repr(img)
         return f"TiledImage<chunks={self.chunks}, depth={self.depth}, boundary={self.boundary}> of \n{img_repr}"
-    
+
     def _deref_image(self) -> _T:
         img = self._img()
         if img is None:
             raise RuntimeError("Image has been deleted")
         return img
-    
+
     def _map_overlap(self, func: Callable[[np.ndarray], np.ndarray], *args, **kwargs) -> np.ndarray:
         from .imgarray import ImgArray
         from .lazy import LazyImgArray
@@ -92,14 +92,14 @@ class TiledImage(Generic[_T]):
         img = self._deref_image()
         if isinstance(img, ImgArray):
             from dask import array as da
-            
+
             input = da.from_array(img.value, chunks=self._chunks)
-            
+
             def _func(arr: np.ndarray, *args, **kwargs) -> np.ndarray:
                 return func(arr, *args, **kwargs).astype(arr.dtype, copy=False)
             out: np.ndarray = xp.asnumpy(
                 da.map_overlap(
-                    _func, 
+                    _func,
                     input,
                     *args,
                     depth=self.depth,
@@ -116,7 +116,7 @@ class TiledImage(Generic[_T]):
                 func,
                 c_axes="",
                 depth=self.depth,
-                boundary=self.boundary, 
+                boundary=self.boundary,
                 dtype=img.dtype,
                 args=args,
                 kwargs=kwargs,
@@ -138,7 +138,33 @@ class TiledImage(Generic[_T]):
             Steepness of cutoff.
         """
         return self._map_overlap(_lowpass, cutoff=cutoff, order=order)
-    
+
+    def highpass_filter(self, cutoff: float = 0.2, order: int = 2) -> _T:
+        """
+        Tile-wise butterworth highpass filter.
+
+        Parameters
+        ----------
+        cutoff : float or array-like, default is 0.2
+            Cutoff frequency.
+        order : float, default is 2
+            Steepness of cutoff.
+        """
+        return self._map_overlap(_highpass, cutoff=cutoff, order=order)
+
+    def bandpass_filter(self, cuton: float, cutoff: float, order: int = 2) -> _T:
+        """
+        Tile-wise butterworth bandpass filter.
+
+        Parameters
+        ----------
+        cuton, cutoff : float or array-like
+            Cuton and cutoff frequency.
+        order : float, default is 2
+            Steepness of cutoff.
+        """
+        return self._map_overlap(_bandpass, low_cutoff=cuton, high_cutoff=cutoff, order=order)
+
     def lucy(
         self,
         psf: np.ndarray | Callable[[tuple[int, ...]], np.ndarray],
@@ -147,7 +173,7 @@ class TiledImage(Generic[_T]):
     ) -> _T:
         """
         Deconvolution of N-dimensional image, using Richardson-Lucy's algorithm.
-        
+
         Parameters
         ----------
         psf : ndarray or callable
@@ -156,30 +182,30 @@ class TiledImage(Generic[_T]):
         niter : int, default is 50.
             Number of iterations.
         eps : float, default is 1e-5
-            During deconvolution, division by small values in the convolve image 
-            of estimation and PSF may cause divergence. Therefore, division by 
+            During deconvolution, division by small values in the convolve image
+            of estimation and PSF may cause divergence. Therefore, division by
             values under `eps` is substituted to zero.
         """
         img = self._deref_image()
         scale = tuple(img.scale.values())
-        
+
         def func(arr: np.ndarray):
             psf_ft, psf_ft_conj = _deconv.check_psf(arr.shape, scale, psf)
             return _deconv.richardson_lucy(arr, psf_ft, psf_ft_conj, niter, eps)
-            
+
         return self._map_overlap(func)
-    
+
     def gaussian_filter(self, sigma: float = 1.0, fourier: bool = False) -> _T:
         """
         Run Gaussian filter (Gaussian blur).
-        
+
         Parameters
         ----------
         {sigma}{fourier}
         """
         filter_func = _filters.gaussian_filter_fourier if fourier else _filters.gaussian_filter
         return self._map_overlap(filter_func, sigma=sigma)
-    
+
     def dog_filter(
         self,
         low_sigma: float = 1.0,
@@ -189,7 +215,7 @@ class TiledImage(Generic[_T]):
         """
         Run Difference of Gaussian filter. This function does not support `update`
         argument because intensity can be negative.
-        
+
         Parameters
         ----------
         low_sigma : scalar or array of scalars, default is 1.
@@ -197,7 +223,7 @@ class TiledImage(Generic[_T]):
         high_sigma : scalar or array of scalars, default is x1.6 of low_sigma.
             higher standard deviation(s) of Gaussian.
         {fourier}
-        """        
+        """
         if high_sigma is None:
             high_sigma = low_sigma * 1.6
         filter_func = _filters.dog_filter_fourier if fourier else _filters.dog_filter
@@ -222,3 +248,24 @@ def _lowpass(arr, cutoff, order=2):
     ft = xp.asarray(weight) * xp.fft.rfftn(arr)
     ift = xp.fft.irfftn(ft, s=shape)
     return xp.asnumpy(ift)
+
+def _highpass(arr, cutoff, order=2):
+    arr = xp.asarray(arr)
+    shape = arr.shape
+    _cutoff = check_nd(cutoff, len(shape))
+    weight = _get_ND_butterworth_filter(shape, _cutoff, order, True, True)
+    ft = xp.asarray(weight) * xp.fft.rfftn(arr)
+    ift = xp.fft.irfftn(ft, s=shape)
+    return xp.asnumpy(ift)
+
+def _bandpass(arr, low_cutoff, high_cutoff, order=2):
+    arr = xp.asarray(arr)
+    shape = arr.shape
+    _low_cutoff = check_nd(low_cutoff, len(shape))
+    _high_cutoff = check_nd(high_cutoff, len(shape))
+    low_weight = _get_ND_butterworth_filter(shape, _low_cutoff, order, False, True)
+    high_weight = _get_ND_butterworth_filter(shape, _high_cutoff, order, True, True)
+    weight = low_weight * high_weight
+    ft = xp.asarray(weight) * xp.fft.rfftn(arr)
+    ift = xp.fft.irfftn(ft, s=shape)
+    return xp.asnumpy(ift)