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

{impy_array-2.4.6 → 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.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 → impy_array-2.4.7}/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_array-2.4.6 → 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.6 → 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.6 → impy_array-2.4.7}/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_array-2.4.6 → impy_array-2.4.7}/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_array-2.4.6 → impy_array-2.4.7}/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_array-2.4.6 → impy_array-2.4.7}/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 → impy_array-2.4.7}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling>=1.26.1"]
 build-backend = "hatchling.build"
 
 [project]