impy-array 2.4.5__tar.gz → 2.4.7__tar.gz

{impy_array-2.4.5 → impy_array-2.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: impy-array
-Version: 2.4.5
+Version: 2.4.7
 Summary: Speed up coding/extending image analysis in Python.
 Project-URL: Download, https://github.com/hanjinliu/impy
 Author-email: Hanjin Liu <liuhanjin-sc@g.ecc.u-tokyo.ac.jp>
@@ -39,6 +39,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9

impy_array-2.4.7/impy/__init__.py

@@ -0,0 +1,63 @@
+__version__ = "2.4.7"
+__author__ = "Hanjin Liu"
+__email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
+
+import logging
+from typing import TYPE_CHECKING
+
+from impy._const import Const, SetConst, use  # 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
+# -----------
+#
+# AxesMixin -----> LazyImgArray ------> BigImgArray
+#     |
+#     +-----> MetaArray --+--> LabeledArray --+--> ImgArray
+#     |                   |                   |
+# np.ndarray              +--> Label          +--> PhaseArray
+#                         |
+#                         +--> PropArray
+
+
+logging.getLogger("skimage").setLevel(logging.ERROR)
+logging.getLogger("tifffile").setLevel(logging.ERROR)
+
+
+del logging
+
+# dtypes
+from numpy import (  # noqa
+    uint8, uint16, uint32, uint64,
+    int8, int16, int32, int64,
+    float16, float32, float64,
+    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_array-2.4.5 → impy_array-2.4.7}/impy/arrays/_utils/_corr.py

@@ -34,7 +34,7 @@ def subpixel_pcc(
     f0: np.ndarray,
     f1: np.ndarray,
     upsample_factor: int,
-    max_shifts: tuple[float, ...] | None = None,
+    max_shifts: float | tuple[float, ...] | None = None,
 ):
     power, product = _pcc_and_power_spec(f0, f1, max_shifts)
     maxima = xp.unravel_index(xp.argmax(power), power.shape)
@@ -60,6 +60,8 @@ def subpixel_pcc(
         power = abs2(cross_correlation)
 
         if max_shifts is not None:
+            if np.isscalar(max_shifts):
+                max_shifts = (max_shifts,) * f0.ndim
             max_shifts = xp.asarray(max_shifts)
             _upsampled_left_shifts = (shifts + max_shifts) * upsample_factor
             _upsampled_right_shifts = (max_shifts - shifts) * upsample_factor

{impy_array-2.4.5 → impy_array-2.4.7}/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_array-2.4.5 → impy_array-2.4.7}/impy/arrays/_utils/_skimage.py

@@ -6,8 +6,19 @@ from functools import reduce, lru_cache
 
 # same as the function in skimage.filters._fft_based (available in scikit-image >= 0.19)
 @lru_cache(maxsize=4)
-def _get_ND_butterworth_filter(shape: tuple[int, ...], cutoff: float, order: int, 
-                               high_pass: bool, real: bool):
+def _get_ND_butterworth_filter(
+    shape: tuple[int, ...],
+    cutoff: float,
+    order: int,
+    high_pass: bool,
+    real: bool,
+):
+    if cutoff == 0:
+        if high_pass:
+            wfilt = np.ones(shape, dtype=np.float32)
+        else:
+            wfilt = np.zeros(shape, dtype=np.float32)
+        return wfilt
     ranges = []
     for d, fc in zip(shape, cutoff):
         axis = np.arange(-(d - 1) // 2, (d - 1) // 2 + 1, dtype=np.float32) / (d*fc)
@@ -19,4 +30,4 @@ def _get_ND_butterworth_filter(shape: tuple[int, ...], cutoff: float, order: int
     wfilt = 1 / (1 + q2**order)
     if high_pass:
         wfilt = 1 - wfilt
-    return wfilt
+    return wfilt

{impy_array-2.4.5 → impy_array-2.4.7}/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_array-2.4.5 → impy_array-2.4.7}/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:
@@ -247,12 +247,11 @@ class ImgArray(LabeledArray):
             cval = cval(self.value)
 
         prefilter = prefilter or order > 1
-        mtx = _transform.compose_affine_matrix(translation=translation)
 
         return self._apply_dask(
-            _transform.warp,
+            _transform.shift,
             c_axes=complement_axes(dims, self.axes),
-            kwargs=dict(matrix=mtx, order=order, mode=mode, cval=cval,
+            kwargs=dict(shift=translation, order=order, mode=mode, cval=cval,
                         prefilter=prefilter)
         )
 
@@ -329,7 +328,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 +903,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)
@@ -3939,6 +3985,7 @@ class ImgArray(LabeledArray):
         along: AxisLike | None = None,
         show_drift: bool = False,
         upsample_factor: int = 10,
+        max_shift: nDFloat | None = None,
     ) -> MarkerFrame:
         """
         Calculate yx-directional drift using the method equivalent to
@@ -3952,6 +3999,8 @@ class ImgArray(LabeledArray):
             If True, plot the result.
         upsample_factor : int, default is 10
             Up-sampling factor when calculating phase cross correlation.
+        max_shift : tuple of float, optional
+            Maximum shift in spatial directions.
 
         Returns
         -------
@@ -3966,7 +4015,9 @@ class ImgArray(LabeledArray):
             raise ValueError("`along` must be single character.")
         if not isinstance(upsample_factor, int):
             raise TypeError(f"upsample-factor must be integer but got {type(upsample_factor)}")
-
+        if max_shift is not None:
+            if np.isscalar(max_shift):
+                max_shift = np.full(self.ndim - 1, max_shift)
         result = np.zeros((self.sizeof(along), self.ndim-1), dtype=np.float32)
         c_axes = complement_axes(along, self.axes)
         last_img = None
@@ -3975,7 +4026,12 @@ class ImgArray(LabeledArray):
             img = xp.asarray(img)
             if last_img is not None:
                 result[i] = xp.asnumpy(
-                    _corr.subpixel_pcc(last_img, img, upsample_factor=upsample_factor)[0]
+                    _corr.subpixel_pcc(
+                        last_img,
+                        img,
+                        max_shifts=max_shift,
+                        upsample_factor=upsample_factor,
+                    )[0]
                 )
                 last_img = img
             else:
@@ -4000,6 +4056,7 @@ class ImgArray(LabeledArray):
         *,
         zero_ave: bool = True,
         along: AxisLike | None = None,
+        max_shift: nDFloat | None = None,
         order: int = 1,
         mode: str = "constant",
         cval: float = 0,
@@ -4062,7 +4119,7 @@ class ImgArray(LabeledArray):
                     )
                 return out
 
-            shift = ref.track_drift(along=along).values
+            shift = ref.track_drift(along=along, max_shift=max_shift).values
 
         else:
             shift = np.asarray(shift, dtype=np.float32)

{impy_array-2.4.5 → impy_array-2.4.7}/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)