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

impy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.4.6"
+__version__ = "2.4.7"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 

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/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/arrays/imgarray.py

@@ -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)
         )
 
@@ -3986,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
@@ -3999,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
         -------
@@ -4013,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
@@ -4022,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:
@@ -4047,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,
@@ -4109,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/arrays/lazy.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 from functools import lru_cache, wraps
 import itertools
 from pathlib import Path
-from typing import Any, Callable, TYPE_CHECKING, Sequence
-import warnings
+from typing import Any, Callable, TYPE_CHECKING, Literal, Sequence
 import numpy as np
-from numpy.typing import ArrayLike, DTypeLike
+from numpy.typing import DTypeLike
 from warnings import warn
 import tempfile
 import operator
@@ -300,8 +299,8 @@ class LazyImgArray(AxesMixin):
 
     def compute(self, ignore_limit: bool = False) -> ImgArray:
         """
-        Compute all the task and convert the result into ImgArray. If image size overwhelms MAX_GB
-        then MemoryError is raised.
+        Compute all the task and convert the result into ImgArray. If image size
+        overwhelms MAX_GB then MemoryError is raised.
         """
         if self.gb > Const["MAX_GB"] and not ignore_limit:
             raise MemoryError(f"Too large: {self.gb:.2f} GB")
@@ -316,8 +315,8 @@ class LazyImgArray(AxesMixin):
 
     def release(self, update: bool = True) -> LazyImgArray:
         """
-        Compute all the tasks and store the data in memory map, and read it as a dask array
-        again.
+        Compute all the tasks and store the data in memory map, and read it as a dask
+        array again.
         """
         from dask import array as da
 
@@ -528,25 +527,21 @@ class LazyImgArray(AxesMixin):
         kwargs: dict[str, Any] = None
     ) -> DaskArray:
         from dask import array as da
+
         if args is None:
             args = ()
         if kwargs is None:
             kwargs = {}
         all_axes = str(self.axes)
-        def _func(input: ArrayLike, *args, **kwargs):
-            out = xp.empty(input.shape, input.dtype)
-            for sl in iter_slice(input.shape, c_axes, all_axes):
-                out[sl] = func(input[sl], *args, **kwargs)
-            return out
-
+        _func = _make_map_blocks_func(func, self.dtype, c_axes, all_axes)
         return da.map_blocks(_func, self.value, dtype=self.dtype, *args, **kwargs)
 
     def _apply_map_overlap(
         self,
         func: Callable,
-        c_axes: str = None,
+        c_axes: str | None = None,
         depth: int = 16,
-        boundary="reflect",
+        boundary="none",
         dtype: DTypeLike = None,
         args: tuple | None = None,
         kwargs: dict[str, Any] | None = None
@@ -560,16 +555,9 @@ class LazyImgArray(AxesMixin):
         if dtype is None:
             dtype = self.dtype
         all_axes = str(self.axes)
-        def _func(input: np.ndarray, *args, **kwargs):
-            out = xp.empty(input.shape, dtype=dtype)
-            for sl in iter_slice(input.shape, c_axes, all_axes):
-                out[sl] = func(input[sl], *args, **kwargs).astype(dtype, copy=False)
-            return out
-        depth = switch_slice(c_axes, self.axes, 0, depth)
-        return da.map_overlap(
-            _func, self.value, *args, depth=depth, boundary=boundary, dtype=dtype,
-            **kwargs
-        )
+        _func = _make_map_overlap_func(func, dtype, c_axes, all_axes)
+        depths = switch_slice(c_axes, self.axes, 0, depth)
+        return da.map_overlap(_func, self.value, *args, depth=depths, dtype=dtype, **kwargs, boundary=boundary, align_arrays=False)
 
     def _apply_dask_filter(
         self,
@@ -589,6 +577,61 @@ class LazyImgArray(AxesMixin):
             out[sl] = func(img, *args, **kwargs)
         return out
 
+    @_docs.copy_docs(ImgArray.shift)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def shift(
+        self,
+        translation: Coords,
+        *,
+        order: int = 3,
+        mode: PaddingMode = "constant",
+        cval: float = 0,
+        prefilter: bool | None = None,
+        dims: Dims = 2,
+        update: bool = False
+    ) -> LazyImgArray:
+
+        prefilter = prefilter or order > 1
+
+        return self._apply_map_blocks(
+            _transform.shift,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(shift=translation, order=order, mode=mode, cval=cval,
+                        prefilter=prefilter)
+        )
+
+    @_docs.copy_docs(ImgArray.rotate)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def rotate(
+        self,
+        degree: float,
+        center: Sequence[float] | Literal["center"] = "center",
+        *,
+        order: int = 3,
+        mode: PaddingMode = "constant",
+        cval: float = 0,
+        dims: Dims = 2,
+        update: bool = False
+    ) -> LazyImgArray:
+        if center == "center":
+            center = np.array(self.sizesof(dims))/2. - 0.5
+        else:
+            center = np.asarray(center)
+
+        translation_0 = _transform.compose_affine_matrix(translation=center)
+        rotation = _transform.compose_affine_matrix(rotation=np.deg2rad(degree))
+        translation_1 = _transform.compose_affine_matrix(translation=-center)
+
+        mx = translation_0 @ rotation @ translation_1
+        mx[-1, :] = [0] * len(dims) + [1]
+        return self._apply_map_blocks(
+            _transform.warp,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(matrix=mx, order=order, mode=mode, cval=cval),
+        )
+
     # TODO: This should wait for dask-image implement map_coordinates
     # @_docs.copy_docs(LabeledArray.rotated_crop)
     # @dims_to_spatial_axes
@@ -702,6 +745,28 @@ class LazyImgArray(AxesMixin):
             kwargs=dict(footprint=disk)
         )
 
+
+    @_docs.copy_docs(ImgArray.tophat)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def tophat(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0.0,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        disk = _structures.ball_like(radius, len(dims))
+        return self._apply_map_overlap(
+            _filters.white_tophat,
+            c_axes=complement_axes(dims, self.axes),
+            dtype=self.dtype,
+            kwargs=dict(footprint=disk, mode=mode, cval=cval)
+        )
+
+
     @_docs.copy_docs(ImgArray.gaussian_filter)
     @dims_to_spatial_axes
     @same_dtype(asfloat=True)
@@ -722,6 +787,64 @@ class LazyImgArray(AxesMixin):
             kwargs=dict(sigma=sigma),
         )
 
+    @_docs.copy_docs(ImgArray.dog_filter)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def dog_filter(
+        self,
+        low_sigma: nDFloat = 1.0,
+        high_sigma: nDFloat = 2.0,
+        *,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        c_axes = complement_axes(dims, self.axes)
+        depth = _ceilint(high_sigma*4)
+        return self._apply_map_overlap(
+            _filters.dog_filter,
+            c_axes=c_axes,
+            depth=depth,
+            kwargs=dict(low_sigma=low_sigma, high_sigma=high_sigma),
+        )
+
+    @_docs.copy_docs(ImgArray.doh_filter)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def doh_filter(
+        self,
+        sigma: nDFloat = 1.0,
+        *,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        c_axes = complement_axes(dims, self.axes)
+        depth = _ceilint(sigma*4)
+        return self._apply_map_overlap(
+            _filters.doh_filter,
+            c_axes=c_axes,
+            depth=depth,
+            kwargs=dict(sigma=sigma),
+        )
+
+    @_docs.copy_docs(ImgArray.log_filter)
+    @dims_to_spatial_axes
+    @check_input_and_output_lazy
+    def log_filter(
+        self,
+        sigma: nDFloat = 1.0,
+        *,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        c_axes = complement_axes(dims, self.axes)
+        depth = _ceilint(sigma*4)
+        return -self._apply_map_overlap(
+            _filters.gaussian_laplace,
+            c_axes=c_axes,
+            depth=depth,
+            kwargs=dict(sigma=sigma),
+        )
+
     @_docs.copy_docs(ImgArray.spline_filter)
     @dims_to_spatial_axes
     @same_dtype(asfloat=True)
@@ -754,6 +877,8 @@ class LazyImgArray(AxesMixin):
         self,
         radius: float = 1,
         *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
         dims: Dims = None,
         update: bool = False
     ) -> LazyImgArray:
@@ -762,8 +887,51 @@ class LazyImgArray(AxesMixin):
             xp.ndi.median_filter,
             depth=_ceilint(radius),
             c_axes=complement_axes(dims, self.axes),
-            kwargs=dict(footprint=disk)
-            )
+            kwargs=dict(footprint=disk, mode=mode, cval=cval),
+        )
+
+
+    @_docs.copy_docs(ImgArray.std_filter)
+    @dims_to_spatial_axes
+    @same_dtype
+    @check_input_and_output_lazy
+    def std_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        disk = _structures.ball_like(radius, len(dims))
+        return self._apply_map_overlap(
+            _filters.std_filter,
+            depth=_ceilint(radius),
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(selem=disk, mode=mode, cval=cval),
+        )
+
+    @_docs.copy_docs(ImgArray.coef_filter)
+    @dims_to_spatial_axes
+    @same_dtype
+    @check_input_and_output_lazy
+    def coef_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        disk = _structures.ball_like(radius, len(dims))
+        return self._apply_map_overlap(
+            _filters.coef_filter,
+            depth=_ceilint(radius),
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(selem=disk, mode=mode, cval=cval),
+        )
 
     @_docs.copy_docs(ImgArray.mean_filter)
     @same_dtype(asfloat=True)
@@ -773,17 +941,19 @@ class LazyImgArray(AxesMixin):
         self,
         radius: float = 1,
         *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
         dims: Dims = None,
         update: bool = False
     ) -> LazyImgArray:
         disk = _structures.ball_like(radius, len(dims))
-        kernel = (disk/np.sum(disk)).astype(np.float32)
+        kernel = (disk / np.sum(disk)).astype(np.float32)
         return self._apply_map_overlap(
             xp.ndi.convolve,
             depth=_ceilint(radius),
             c_axes=complement_axes(dims, self.axes),
-            kwargs=dict(weights=kernel),
-            )
+            kwargs=dict(weights=kernel, mode=mode, cval=cval),
+        )
 
     @_docs.copy_docs(ImgArray.convolve)
     @dims_to_spatial_axes
@@ -793,7 +963,7 @@ class LazyImgArray(AxesMixin):
         self,
         kernel,
         *,
-        mode: str = "reflect",
+        mode: PaddingMode = "reflect",
         cval: float = 0,
         dims: Dims = None,
         update: bool = False
@@ -915,7 +1085,7 @@ class LazyImgArray(AxesMixin):
         thr: float | str,
         *,
         along: AxisLike | None = None,
-    ) -> ImgArray:
+    ) -> LazyImgArray:
         if self.dtype == bool:
             return self
 
@@ -943,7 +1113,7 @@ class LazyImgArray(AxesMixin):
     @dims_to_spatial_axes
     @check_input_and_output_lazy
     def fft(self, *, shape: int | Iterable[int] | str = "same", shift: bool = True,
-            dims: Dims = None) -> LazyImgArray:
+            double_precision: bool = False, dims: Dims = None) -> LazyImgArray:
         from dask import array as da
 
         axes = [self.axisof(a) for a in dims]
@@ -955,7 +1125,8 @@ class LazyImgArray(AxesMixin):
         else:
             shape = check_nd(shape, len(dims))
         fft = _get_fft_func(Const["RESOURCE"])
-        freq = fft(self.value.astype(np.float32), s=shape, axes=axes)
+        dtype = np.float64 if double_precision else np.float32
+        freq = fft(self.value.astype(dtype), s=shape, axes=axes)
         if shift:
             freq[:] = da.fft.fftshift(freq, axes=axes)
         return freq
@@ -963,16 +1134,24 @@ class LazyImgArray(AxesMixin):
     @_docs.copy_docs(ImgArray.ifft)
     @dims_to_spatial_axes
     @check_input_and_output_lazy
-    def ifft(self, real: bool = True, *, shift: bool = True, dims: Dims = None) -> LazyImgArray:
+    def ifft(
+        self,
+        real: bool = True,
+        *,
+        shift: bool = True,
+        double_precision: bool = False,
+        dims: Dims = None,
+    ) -> LazyImgArray:
         from dask import array as da
 
+        dtype = np.complex128 if double_precision else np.complex64
         axes = [self.axisof(a) for a in dims]
         if shift:
             freq = da.fft.ifftshift(self.value, axes=axes)
         else:
             freq = self.value
         ifft = _get_ifft_func(Const["RESOURCE"])
-        out = ifft(freq, axes=axes)
+        out = ifft(freq.astype(dtype), axes=axes)
 
         if real:
             out = da.real(out)
@@ -982,9 +1161,16 @@ class LazyImgArray(AxesMixin):
     @_docs.copy_docs(ImgArray.power_spectra)
     @dims_to_spatial_axes
     @check_input_and_output_lazy
-    def power_spectra(self, shape = "same", norm: bool = False, zero_norm: bool = False, *,
-                      dims: Dims = None) -> LazyImgArray:
-        freq = self.fft(dims=dims, shape=shape)
+    def power_spectra(
+        self,
+        shape = "same",
+        norm: bool = False,
+        zero_norm: bool = False,
+        *,
+        double_precision: bool = False,
+        dims: Dims = None,
+    ) -> LazyImgArray:
+        freq = self.fft(dims=dims, shape=shape, double_precision=double_precision)
         pw = freq.value.real ** 2 + freq.value.imag ** 2
         if norm:
             pw /= pw.max()
@@ -1572,3 +1758,19 @@ def _get_ifft_func(resource) -> Callable[[DaskArray], DaskArray]:
     from dask import array as da
 
     return da.fft.fft_wrap(scipy_fft.ifftn)
+
+def _make_map_blocks_func(func, dtype, c_axes, all_axes):
+    def _func(input: np.ndarray, *args, **kwargs):
+        out = xp.empty(input.shape, dtype)
+        for sl in iter_slice(input.shape, c_axes, all_axes):
+            out[sl] = func(input[sl], *args, **kwargs)
+        return out
+    return _func
+
+def _make_map_overlap_func(func, dtype, c_axes, all_axes):
+    def _func(input: np.ndarray, *args, **kwargs):
+        out = xp.empty(input.shape, dtype=dtype)
+        for sl in iter_slice(input.shape, c_axes, all_axes):
+            out[sl] = func(input[sl], *args, **kwargs).astype(dtype, copy=False)
+        return out
+    return _func

impy/axes/_axis.py

@@ -21,20 +21,20 @@ class RangeLabels(LabelBase[_T]):
         self._start = start
         self._stop = stop
         self._step = step
-    
+
     def __getitem__(self, key):
         val = self._start + key * self._step
         if val > self._stop:
             raise IndexError("Index out of range.")
         return val
-    
+
     def __len__(self) -> int:
         return (self._stop - self._start) // self._step
 
 
 class Labels(LabelBase):
     """A tuple-like object storing label specifiers."""
-    
+
     def __init__(self, seq: Iterable[_T]):
         self._labels = tuple(seq)
         self._hash_map: dict[_T, int] = {}
@@ -44,29 +44,29 @@ class Labels(LabelBase):
     def __repr__(self) -> str:
         clsname = type(self).__name__
         return f"{clsname}{self._labels!r}"
-    
+
     def __len__(self) -> int:
         """Length of labels"""
         return len(self._labels)
-    
+
     def __getitem__(self, key):
         out = self._labels[key]
         if isinstance(key, slice):
             return Labels(out)
         return out
-    
+
     def __eq__(self, other: Sequence[_T]) -> bool:
         return self._labels == other
-    
+
     @property
     def has_duplicate(self) -> bool:
         """True if self has duplicated labels."""
         return len(self._labels) != len(self._hash_map)
-        
+
     def get_item(self, key: _T | slice):
         idx = self.get_slice(key)
         return self._labels[idx]
-    
+
     def get_slice(self, key: _T | slice) -> int | slice:
         if self.has_duplicate:
             raise ValueError("Labels have duplicate.")
@@ -95,67 +95,67 @@ class Labels(LabelBase):
 class Axis:
     """
     An axis object.
-    
+
     This object behaves like a length-1 string as much as possible.
-    
-    Parameters 
+
+    Parameters
     ----------
     name : str
         Name of axis.
     """
-    
+
     def __init__(self, name: str, metadata: dict[str, Any] | None = None):
         self._name = str(name)
         self._metadata = metadata or {}
-    
+
     def __str__(self) -> str:
         """String representation of the axis."""
         return self._name
-    
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}[{self._name!r}]"
-    
+
     def __hash__(self) -> int:
         """Hash as a string."""
         return hash(str(self))
-    
+
     def __eq__(self, other) -> bool:
         """Check equality as a string."""
         return str(self) == other
-    
+
     def __add__(self, other: str) -> str:
         """Add as a string ans returns a string."""
         return self._name + other
-    
+
     def __radd__(self, other: str) -> str:
         """Add as a string ans returns a string."""
         return other + self._name
-    
+
     def __lt__(self, other) -> bool:
         """To support alphabetic ordering."""
         return str(self) < str(other)
-    
+
     def __len__(self) -> int:
         """Length of the string representation."""
         return len(str(self))
-    
+
     def __iter__(self) -> Iterable[str]:
         """Iterate as a string."""
         return iter(str(self))
-    
+
     def __copy__(self) -> Self:
         return self.__class__(self._name, self._metadata.copy())
-    
+
     @property
     def metadata(self) -> dict[str, Any]:
         """Metadata dictionary."""
         return self._metadata
-    
+
     @property
     def scale(self) -> float:
         """Physical scale of axis."""
         return self.metadata.get(_SCALE, 1.0)
-    
+
     @scale.setter
     def scale(self, value: float) -> None:
         """Set physical scale to the axis."""
@@ -163,37 +163,37 @@ class Axis:
         if value <= 0:
             raise ValueError(f"Cannot set negative scale: {value!r}.")
         self.metadata[_SCALE] = value
-    
+
     @property
     def unit(self) -> str:
         """Physical scale unit of axis."""
-        return self.metadata.get(_UNIT, "px")
-    
+        return self.metadata.get(_UNIT, "")
+
     @unit.setter
     def unit(self, value: str | None):
         """Set physical unit to the axis."""
         if value is None:
-            value = "px"
+            value = ""
         elif value.startswith("\\u00B5") or value.startswith("\\u03BC"):
             value = "μ" + value[6:]
-        
+
         self.metadata[_UNIT] = value
-    
+
     @property
     def labels(self) -> Labels | None:
         """Axis labels."""
         return self.metadata.get(_LABELS, None)
-    
+
     @labels.setter
     def labels(self, value: Iterable[Hashable]) -> None:
         """Set axis labels."""
         self.metadata[_LABELS] = Labels(value)
-    
+
     @labels.deleter
     def labels(self) -> None:
         """Set axis labels."""
         del self.metadata[_LABELS]
-    
+
     def isin(self, values: Iterable[Hashable]) -> np.ndarray:
         """Check if labels are in values."""
         if self.labels is None:
@@ -223,23 +223,23 @@ class Axis:
                 metadata.update(labels=Labels([labels[i] for i in sl]))
         return self.__class__(self._name, metadata=metadata)
 
-    
+
 
 AxisLike = Union[str, Axis]
 
 
 class UndefAxis(Axis):
     """Undefined axis object."""
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__("#")
-    
+
     def __repr__(self) -> str:
         return "#undef"
-    
+
     def __hash__(self) -> str:
         return id(self)
-    
+
     def __eq__(self, other) -> bool:
         return isinstance(other, str) and other == "#"
 

impy/core.py

@@ -764,18 +764,18 @@ def _imread_stack(
 def imread_collection(
     path: str | list[str],
     filt: Callable[[np.ndarray], bool] | None = None,
-) -> DataList:
+) -> DataList[ImgArray]:
     """
     Open images as ImgArray and store them in DataList.
 
     Parameters
     ----------
     path : str or list of str
-        Path than can be passed to ``glob.glob``. If a list of path is given, all the matched
-        images will be read and concatenated into a DataList.
+        Path than can be passed to ``glob.glob``. If a list of path is given, all the
+        matched images will be read and concatenated into a DataList.
     filt : callable, optional
-        If specified, only images that satisfies filt(img)==True will be stored in the returned
-        DataList.
+        If specified, only images that satisfies filt(img)==True will be stored in the
+        returned DataList.
 
     Returns
     -------

{impy_array-2.4.6.dist-info → impy_array-2.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: impy-array
-Version: 2.4.6
+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>

{impy_array-2.4.6.dist-info → impy_array-2.4.7.dist-info}/RECORD

@@ -1,11 +1,11 @@
-impy/__init__.py,sha256=Wg_wo7SXRVFZfIDT7fD4jYsFxoURZCcVF0JKuMIQQY0,1638
+impy/__init__.py,sha256=ElW_q_sd5NE1DWtX7zciQLcgl47n3a55WpQwq2ChVLk,1638
 impy/__main__.py,sha256=BAQkQ4X8EFo42pbNx__EqpZ5KL4MTfTUWsVbJIQF0O0,4974
 impy/_const.py,sha256=XFkgkyqs_clQJDqr2vdh5rCyfM83iMFChOLJjwNWHtM,3736
 impy/_types.py,sha256=gO4l0hx9qxe6eI0PyC4ukW3k4IYxCEZ9gT-rQ3jj3zU,808
 impy/array_api.py,sha256=9suP_Wck9maSiEa5qK6aZrCfaky6xhCMfIRcc9WuIs8,5585
 impy/binder.py,sha256=CTMb11g6uYDVVQV5Wtef865IO0G2V3vGXc8SiGYRD5k,9651
 impy/collections.py,sha256=2e55bLjZN7W4LFUCkyxekcDfLwZodMaU4JG5NQ3RS54,10946
-impy/core.py,sha256=v5_Uvaur__FBPOwYqxWCp2U0rwjL8U1ebBdgt-IBoVY,25799
+impy/core.py,sha256=UcMY7vQpp9l1CW_hukexqx92RZcEBWR48Ce_bVrQv0U,25809
 impy/correlation.py,sha256=Yw1T_0eL9FmsMcnCysc49oRJQMn8ho5z9bAzNg5i59Y,28232
 impy/random.py,sha256=RJZAgXp3gkOcCsKbAbuMI1pDdA4_atY3mausFxPNWpk,6973
 impy/roi.py,sha256=p9ttjBl5SGHHXj0xg5UjPlg_V9cY3MnNZxFfYIjTYsg,14164
@@ -13,15 +13,15 @@ impy/arrays/__init__.py,sha256=IHpTBIJysomS64rOZsv960YBmM1vc4M-asTSs1OJBWg,454
 impy/arrays/_imshow.py,sha256=6mJ_PDqmE4UZO9e9SUgyY_YrzQdR2QKlTG7KF_aC_tI,6949
 impy/arrays/axesmixin.py,sha256=9PK6kMZAfNVipTL65aF5-yR3qt2fy4ATl1OACXLYrAE,10596
 impy/arrays/big.py,sha256=tHNijyPgyIfTltLP3hQwZdHOpSX3IwG5DHPamajZ8Kg,2745
-impy/arrays/imgarray.py,sha256=l9exYjK7wB0Zk2Gk_wOYxZu-nCI_fxKNyQpCkOIytxE,158709
+impy/arrays/imgarray.py,sha256=MxPVVdxnsJDqNVawSykNkFr2y6Cb1ESVYeCzAQXzrN4,159129
 impy/arrays/label.py,sha256=l0SZXcZxU8qwUgj0QZPZ32XsNaoBtenlrn6hNR03SPI,6406
 impy/arrays/labeledarray.py,sha256=ZbwgP1Fk-lzFckQ12aQO7QnjNMxpmn_y6E3j3DMLCl0,57081
-impy/arrays/lazy.py,sha256=w1HHjy79fa5yaRxJRF-gxJOmFijn6ytikH8RA9TZxbU,53723
+impy/arrays/lazy.py,sha256=hYTZeaW6HEq0CgPcpfqLcLWSpBrJli6ZTN_ddH_56ro,59902
 impy/arrays/phasearray.py,sha256=IojWaNs5sEujn6Lhgqe00H0xF-4CZEFWt5cVW6U_DWQ,13981
 impy/arrays/specials.py,sha256=4sNg_zeJUce_rwnasPoyL2eZ0-gx_4Z-KwitmLB4a5k,7896
 impy/arrays/tiled.py,sha256=T44sS6v1Ovln1z1g61Eg8irgZR1Jmpb6BCY3nS6TmDE,9400
 impy/arrays/_utils/__init__.py,sha256=M5HogfyUBvV8kp-X1ZthS8vDLUP7-O2f9Gvsc1ZXdT8,271
-impy/arrays/_utils/_corr.py,sha256=uBjqjwe6v6oCEe7QkbH3kqmxTa9aP4Zs98dYxrTAGIQ,9944
+impy/arrays/_utils/_corr.py,sha256=ThGQV3KSv8ir8BTWDoV83ysalPB2p--LmSCv-J9qq2w,10047
 impy/arrays/_utils/_deconv.py,sha256=5UM7CoRpWphEYuuiq89bmFCKU-n1G_ArMCkDq7tamdQ,2754
 impy/arrays/_utils/_docs.py,sha256=AT6tRxXcX433FCfPXhE9wsaeduy_Um44KOqrYHYTFZE,4968
 impy/arrays/_utils/_filters.py,sha256=aigQnaURbUnmOXGDxkWksISWQbKAUdwtS8kzbaMzgoQ,7226
@@ -30,7 +30,7 @@ impy/arrays/_utils/_linalg.py,sha256=06jnv-P6nwUjYVTHX2f9i-KDSYZ0bxwNfWWP8A8e_Vw
 impy/arrays/_utils/_misc.py,sha256=vyyw-G4iu7RiNRAJWyvWWGRalWlcMy5Kg_0VvLBBPq8,2953
 impy/arrays/_utils/_plot.py,sha256=AzY33TBzQ97DaTZu_EIu5GpN-sUTLKY1tY2qu76Ro10,5077
 impy/arrays/_utils/_process_numba.py,sha256=1WjNRwqggSMYyKLeXo6W97lm93A47cAFvR6sBF086PI,3428
-impy/arrays/_utils/_skimage.py,sha256=p10aiqIgXvPH8j_7iy_fbWD08jMolHSd1WJZAemDAEk,808
+impy/arrays/_utils/_skimage.py,sha256=mjChNVHq8C1urL9T2s4U3jmGQYBBhCiB8B_Z0EMiONI,996
 impy/arrays/_utils/_structures.py,sha256=K0gHjv9lF90wizAvFZQyHF02l2TC-texdYJTfB5I2H8,1301
 impy/arrays/_utils/_transform.py,sha256=P999uJ_G2csoUAbY6e6SBzr2uo0bvvgTDaePc5VZAQI,12698
 impy/arrays/bases/__init__.py,sha256=aHsAYta5CQkEDlbFShEtEGYN89N2qYedg99SM6Oo7wk,99
@@ -39,7 +39,7 @@ impy/arrays/bases/overload.py,sha256=FNm2hK60tOmxJyin4IJ1hJzane_UzV2eObXkixehQ34
 impy/axes/__init__.py,sha256=qzhWAJMT_mc-MXcuaMEDjVd_n0dFRmZxaphh6x_Wzb4,239
 impy/axes/_axes.py,sha256=tqJ3yASv4LX4To0TM_a46CieSaXywDYyNoMlaDpUpn4,12170
 impy/axes/_axes_tuple.py,sha256=hkgTr_n36gFcnnffmSp3z4oJ_52MxT1JnaszdJ3JnrY,1522
-impy/axes/_axis.py,sha256=oj2lyOH2uqMyoclAZEeQC-BQIULvBwaAXFLguINdfps,7630
+impy/axes/_axis.py,sha256=TlaF_Ya1DLcNwz8LFAL4xWC0Xt8HA0WR4ZUC3SYJPP0,7469
 impy/axes/_slicer.py,sha256=Ts4m9V3PBlEb3xeHd6j1XdMEb1SwYGbBF5rnC9WWYZE,2657
 impy/frame/__init__.py,sha256=Z4XfXzFSDq49tMrVoeYx1ThnHyw43iLVSVcte6b6-as,65
 impy/frame/frames.py,sha256=7NxDeuaG8CxzMnzczarmLz6ANBpl1tZIhn8KwdvBYg8,12450
@@ -64,8 +64,8 @@ impy/utils/utilcls.py,sha256=3Td9G2ZkU4C0BiW2LH0sq7RBjdco_BtyxNr-s-seLhs,437
 impy/viewer/__init__.py,sha256=MH-jhpFxP8JVJwUzbKMLRhhWSEYavVHuik9uOS3dDNU,292
 impy/viewer/utils.py,sha256=_RWV9LePbmYeC8qRBUBf3qG70BaLOndlzRLcvUYgTtE,12248
 impy/viewer/viewer.py,sha256=Sfq-obSLoHkBkIW0NDWCxEEaX7-YsC4ifAJ-nxpvJws,17632
-impy_array-2.4.6.dist-info/METADATA,sha256=rLSGd3PJ0fBqPhe8k-9pxLaIdbebqJB46cHB77xev-Q,7547
-impy_array-2.4.6.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-impy_array-2.4.6.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
-impy_array-2.4.6.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
-impy_array-2.4.6.dist-info/RECORD,,
+impy_array-2.4.7.dist-info/METADATA,sha256=pQoD1_kxoBzLFncPKdriWz4-mLvI2DUt_jo3u7Pl0CA,7547
+impy_array-2.4.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+impy_array-2.4.7.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
+impy_array-2.4.7.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
+impy_array-2.4.7.dist-info/RECORD,,

{impy_array-2.4.6.dist-info → impy_array-2.4.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any