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

impy/__init__.py

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

impy/arrays/_imshow.py

@@ -177,4 +177,33 @@ def _imshow_matplotlib(self: LabeledArray, label, dims, **kwargs) -> LabeledArra
 def _imshow_ipywidgets(arr: LabeledArray, label: bool, dims, **kwargs) -> LabeledArray:
     from ipywidgets import interact
     
-    raise NotImplementedError()
+    raise NotImplementedError()
+
+@register("ndv")
+def _imshow_ndv(self: LabeledArray, label: bool, dims, **kwargs) -> LabeledArray:
+    from ndv import NDViewer
+    
+    app, should_exec = _get_app()
+    if "c" in self.axes:
+        channel_axis = self.axes.index("c")
+    else:
+        channel_axis = None
+    viewer = NDViewer(self, channel_axis=channel_axis)
+    viewer.show()
+    if should_exec:
+        app.exec()
+    return self
+
+def _get_app():
+    # ported from ndv
+    import sys
+    from qtpy.QtWidgets import QApplication
+
+    is_ipython = False
+    if (app := QApplication.instance()) is None:
+        app = QApplication([])
+        app.setApplicationName("ndv")
+    elif (ipy := sys.modules.get("IPython")) and (shell := ipy.get_ipython()):
+        is_ipython = str(shell.active_eventloop).startswith("qt")
+
+    return app, not is_ipython

impy/arrays/_utils/_glcm.py

@@ -130,4 +130,4 @@ def check_glcm(self, bins, rescale_max):
         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/_structures.py

@@ -37,4 +37,4 @@ def ball_like_odd(radius, ndim):
     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/bases/metaarray.py

@@ -119,7 +119,7 @@ class MetaArray(AxesMixin, np.ndarray):
         return self.axes.tuple(super().shape)
     
     def __getitem__(self, key: SupportSlicing) -> Self:
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
 
         if isinstance(key, np.ndarray):
             key = self._broadcast(key)
@@ -133,7 +133,7 @@ class MetaArray(AxesMixin, np.ndarray):
         return out
     
     def __setitem__(self, key: SupportSlicing, value):
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
         
         if isinstance(key, MetaArray) and key.dtype == bool:
             key = axesop.add_axes(self.axes, self.shape, key, key.axes)
@@ -181,7 +181,7 @@ class MetaArray(AxesMixin, np.ndarray):
         if indexer is not None:
             kwargs.update(indexer)
 
-        key = slicer.solve_slicer(kwargs, self.axes)
+        key = slicer.solve_slicer(kwargs, self.axes, self.shape)
         out = super().__getitem__(key)  # get item as np.ndarray
         
         if isinstance(out, self.__class__):  # cannot set attribution to such as numpy.int32 

impy/arrays/imgarray.py

@@ -6,13 +6,13 @@ from functools import partial
 from scipy import ndimage as ndi
 from typing import TYPE_CHECKING, Literal, Sequence, Iterable, Callable, overload, Any
 
-from .labeledarray import LabeledArray
-from .label import Label
-from .phasearray import PhaseArray
-from .specials import PropArray
-from .tiled import TiledAccessor
+from impy.arrays.labeledarray import LabeledArray
+from impy.arrays.label import Label
+from impy.arrays.phasearray import PhaseArray
+from impy.arrays.specials import PropArray
+from impy.arrays.tiled import TiledAccessor
 
-from ._utils import _filters, _linalg, _deconv, _misc, _glcm, _docs, _transform, _structures, _corr
+from impy.arrays._utils import _filters, _linalg, _deconv, _misc, _glcm, _docs, _transform, _structures, _corr
 
 from impy.arrays.bases.metaarray import _NoValue
 from impy.utils.axesop import add_axes, switch_slice, complement_axes, find_first_appeared
@@ -217,6 +217,44 @@ 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", 
+        cval: float = 0, prefilter: bool | None = None, dims: Dims = None,
+        update: bool = False,
+    ) -> ImgArray:
+        """
+        2D stretching of an image from a point.
+
+        Parameters
+        ----------
+        translation : array-like
+            Translation in pixels. Must match the length of spatial dimensions.
+        {mode}{cval}{dims}{order}
+
+        Returns
+        -------
+        ImgArray
+            Stretched image.
+        """
+        if isinstance(cval, str) and hasattr(np, cval):
+            cval = getattr(np, cval)(self.value)
+        elif callable(cval):
+            cval = cval(self.value)
+
+        prefilter = prefilter or order > 1
+        mtx = _transform.compose_affine_matrix(translation=translation)
+
+        return self._apply_dask(
+            _transform.warp,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(matrix=mtx, order=order, mode=mode, cval=cval,
+                        prefilter=prefilter)
+        )
 
     @_docs.write_docs
     @dims_to_spatial_axes
@@ -2836,7 +2874,7 @@ class ImgArray(LabeledArray):
         if key is None:
             slices = (slice(None),) * ndim
         else:
-            slices = solve_slicer(key, Axes(dims))
+            slices = solve_slicer(key, Axes(dims), self.shape)
         dtype = np.complex128 if double_precision else np.complex64
 
         # Calculate exp(-ikx)
@@ -3957,8 +3995,8 @@ class ImgArray(LabeledArray):
     @check_input_and_output
     def drift_correction(
         self,
-        shift: Coords = None,
-        ref: ImgArray = None,
+        shift: Coords | None = None,
+        ref: ImgArray | Any | None = None,
         *,
         zero_ave: bool = True,
         along: AxisLike | None = None,
@@ -3977,8 +4015,10 @@ class ImgArray(LabeledArray):
         shift : DataFrame or (N, D) array, optional
             Translation vectors. If DataFrame, it must have columns named with all the symbols
             contained in ``dims``.
-        ref : ImgArray, optional
-            The reference n-D image to determine drift, if ``shift`` was not given.
+        ref : ImgArray or slicer, optional
+            The reference n-D image to determine drift, if ``shift`` was not given. This
+            parameter can be a slicer, which will be used to slice the image to make a
+            reference.
         zero_ave : bool, default is True
             If True, average shift will be zero.
         along : AxisLike, optional
@@ -4008,7 +4048,7 @@ class ImgArray(LabeledArray):
             if ref is None:
                 ref = self
             elif not isinstance(ref, ImgArray):
-                raise TypeError(f"'ref' must be an ImgArray object, but got {type(ref)}")
+                ref = self[ref]
             if ref.axes != [along] + dims:
                 from itertools import product
                 _c_axes = complement_axes([along] + dims, str(ref.axes))

impy/arrays/lazy.py

@@ -129,7 +129,7 @@ class LazyImgArray(AxesMixin):
         return xp.asnumpy(self.value.compute())
     
     def __getitem__(self, key):
-        key = slicer.solve_slicer(key, self.axes)
+        key = slicer.solve_slicer(key, self.axes, self.shape)
             
         new_axes = slice_axes(self.axes, key)
         out = self.__class__(
@@ -281,6 +281,12 @@ class LazyImgArray(AxesMixin):
         chunk_info = ", ".join([f"{s}({o})" for s, o in zip(self.chunksize, self.axes)])
         return chunk_info
     
+    def astype(self, dtype: DTypeLike, copy: bool = True) -> LazyImgArray:
+        """Convert the array to the specified data type."""
+        out = self.__class__(self.value.astype(dtype, copy=copy))
+        out._set_info(self)
+        return out
+    
     def _repr_dict_(self):
         return {
             "name": self.name,
@@ -555,9 +561,9 @@ class LazyImgArray(AxesMixin):
             dtype = self.dtype
         all_axes = str(self.axes)
         def _func(input: xp.ndarray, *args, **kwargs):
-            out = xp.empty(input.shape, input.dtype)
+            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)
+                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(
@@ -1143,10 +1149,11 @@ class LazyImgArray(AxesMixin):
     @same_dtype(asfloat=True)
     @check_input_and_output_lazy
     @dims_to_spatial_axes
-    def drift_correction(self, shift: Coords = None, ref: ImgArray = None, *, 
-                         zero_ave: bool = True, along: str = None, dims: Dims = 2, 
-                         update: bool = False, **affine_kwargs) -> LazyImgArray:
-        
+    def drift_correction(
+        self, shift: Coords | None = None, ref: ImgArray | Any | None = None, *, 
+        zero_ave: bool = True, along: str = None, dims: Dims = 2, 
+        update: bool = False, **affine_kwargs,
+    ) -> LazyImgArray:
         if along is None:
             along = find_first_appeared("tpzcia", include=self.axes, exclude=dims)
         elif len(along) != 1:
@@ -1165,8 +1172,8 @@ class LazyImgArray(AxesMixin):
                          UserWarning)
                     dims = _dims
             elif not isinstance(ref, self.__class__):
-                raise TypeError(f"'ref' must be LazyImgArray object, but got {type(ref)}")
-            elif ref.axes != along + dims:
+                ref = self[ref]
+            if ref.axes != along + dims:
                 raise ValueError(f"Arguments `along`({along}) + `dims`({dims}) do not match "
                                  f"axes of `ref`({ref.axes})")
 

impy/arrays/tiled.py

@@ -94,9 +94,12 @@ class TiledImage(Generic[_T]):
             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,
@@ -114,6 +117,7 @@ class TiledImage(Generic[_T]):
                 c_axes="",
                 depth=self.depth,
                 boundary=self.boundary, 
+                dtype=img.dtype,
                 args=args,
                 kwargs=kwargs,
             )

impy/core.py

@@ -121,8 +121,11 @@ def array(
             dtype = arr.dtype
     
     axes, name = _normalize_params(axes, name, like)
-        
-    _arr = np.array(arr, dtype=dtype, copy=copy)
+    
+    if copy:
+        _arr = np.array(arr, dtype=dtype)
+    else:
+        _arr = np.asarray(arr, dtype=dtype)
     
     # Automatically determine axes
     if axes is None:
@@ -567,7 +570,7 @@ def imread(
         scale_unit = {a: scale_unit for a in "zyx"}
         
     if is_memmap and axes is not None:
-        sl = solve_slicer(key, Axes(axes))
+        sl = solve_slicer(key, Axes(axes), img.shape)
         axes = "".join(a for a, k in zip(axes, sl) if not isinstance(k, int))
         img = np.asarray(img[sl], dtype=dtype)
     

impy/correlation.py

@@ -817,8 +817,8 @@ def manders_coloc(
     
     :math:`r = \frac{\sum_{i \in I_{ref}} I_i}{\sum_{i} I_i}`
     
-    This value is NOT independent of background intensity. You need to correctly subtract
-    background from self. This value is NOT interchangable between channels.
+    This value is NOT independent of background intensity. You need to correctly 
+    subtract background from self. This value is NOT interchangable between channels.
     
     Parameters
     ----------
@@ -832,13 +832,19 @@ def manders_coloc(
         Correlation coefficient(s).
     """        
     if img1.dtype != bool:
-        raise TypeError("`ref` must be a binary image.")
+        raise TypeError("`img1` must be a binary image.")
     if img0.shape != img1.shape:
         raise ValueError(f"Shape mismatch. `img0` has shape {img0.shape} but `img1` "
                          f"has shape {img1.shape}")
-    if img0.axes != img1.axes:
-        warn(f"Axes mismatch. `img0` has axes {img0.axes} but `img1` has axes {img1.axes}. "
-              "Result may be wrong due to this mismatch.", UserWarning)
+    if not isinstance(img1, ImgArray):
+        img1 = ip_asarray(img1, axes=img0.axes)
+    elif img0.axes != img1.axes:
+        warn(
+            f"Axes mismatch. `img0` has axes {img0.axes} but `img1` has axes "
+            f"{img1.axes}. Result may be wrong due to this mismatch.",
+            UserWarning,
+            stacklevel=2,
+        )
     img0 = img0.as_float()
     total = np.sum(img0, axis=dims)
     img0 = img0.copy()

impy/io.py

@@ -365,8 +365,9 @@ def _(path: str, memmap: bool = False) -> ImageData:
 @IO.mark_writer(".tif", ".tiff")
 def _(path: str, img: ImpyArray, lazy: bool = False):
     """The TIFF writer."""
+    from tifffile import imwrite, memmap
+
     if lazy:
-        from tifffile import memmap
         from dask import array as da
         kwargs = _get_ijmeta_from_img(img, update_lut=False)
         mmap = memmap(str(path), shape=img.shape, dtype=img.dtype, **kwargs)
@@ -375,7 +376,6 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         da.store(img_dask, writer)
         return
 
-    from tifffile import imwrite
     rest_axes = complement_axes(img.axes, "tzcyx")
     new_axes = ""
     for a in img.axes:
@@ -394,11 +394,11 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         img_new.set_scale(img)
         img = img_new
 
-        warnings.warn("Image axes changed", UserWarning, stacklevel=2)
+        warnings.warn(f"Image axes changed", UserWarning, stacklevel=2)
 
     img = img.sort_axes()
     if img.dtype == "bool":
-        img = img.astype(np.uint8)
+        img = img.astype(np.uint8)  # tif does not support bool
     imsave_kwargs = _get_ijmeta_from_img(img, update_lut=True)
     imwrite(path, img, **imsave_kwargs)
     return None

impy/utils/gauss.py

@@ -156,4 +156,4 @@ class GaussianBackground(DiagonalGaussian):
         self.sg = np.array(data.shape, dtype="float32")
         self.b, p95 = np.percentile(data, [5, 95])
         self.a = p95 - self.b
-        return None
+        return None

impy/utils/slicer.py

@@ -1,49 +1,79 @@
 from __future__ import annotations
-import re
+
+from abc import ABC, abstractmethod
 from functools import lru_cache
+import math
 from typing import Any, Mapping
-from .._types import Slices
-from ..axes import Slicer, Axes
+from impy._types import Slices
+from impy.axes import Slicer, Axes
 
-__all__ = ["str_to_slice", "axis_targeted_slicing", "solve_slicer"]
+__all__ = ["str_to_slice", "solve_slicer"]
 
-def _range_to_list(v: str) -> list[int]:
-    """
-    "1,3,5" -> [1,3,5]
-    "2,4:6,9" -> [2,4,5,6,9]
-    """
-    if ":" in v:
-        s, e = v.split(":")
-        return list(range(int(s), int(e)))
-    else:
-        return [int(v)]
+class _Slicer(ABC):
+    def str_to_slice(self, v: str) -> list[int] | slice | int:
+        v = v.replace(" ", "")
+        if "," in v:
+            sl = sum((self._range_to_list(v) for v in v.split(",")), [])
+        elif ":" in v:
+            sl = slice(*map(self._int_or_none, v.split(":")))
+        else:
+            sl = self._int(v)
+        return sl
+    
+    def _range_to_list(self, v: str) -> list[int]:    
+        if ":" in v:
+            s, e = v.split(":")
+            return list(range(self._int(s), self._int(e)))
+        else:
+            return [self._int(v)]
+
+    def _int_or_none(self, v: str) -> int | None:
+        if v:
+            return self._int(v)
+        else:
+            return None
+
+    @abstractmethod
+    def _int(self, v: str) -> int:
+        """Convert a string to an integer."""
 
-def _int_or_none(v: str) -> int | None:
-    if v:
-        return int(v)
-    else:
-        return None
     
 def str_to_slice(v: str) -> list[int] | slice | int:
-    v = re.sub(" ", "", v)
-    if "," in v:
-        sl = sum((_range_to_list(v) for v in v.split(",")), [])
-    elif ":" in v:
-        sl = slice(*map(_int_or_none, v.split(":")))
-    else:
-        sl = int(v)
-    return sl
+    return ConstSlicer().str_to_slice(v)
 
+class ConstSlicer(_Slicer):
+    def _int(self, v: str) -> int:
+        return int(v)
 
-@lru_cache
-def axis_targeted_slicing(axes: tuple[str, ...], string: str) -> Slices:
+class EvalSlicer(_Slicer):
+    def __init__(self, size: int):
+        self._size = size
+
+    def _int(self, v: str) -> int:
+        ns = {
+            "N": self._size,
+            "int": int,
+            "ceil": math.ceil,
+            "floor": math.floor,
+            "round": round,
+            "__builtins__": {},
+        }
+        out = eval(v, ns)
+        if not hasattr(out, "__index__"):
+            raise ValueError(f"Invalid index: {v!r}.")
+        return out.__index__()
+
+
+def axis_targeted_slicing(
+    axes: tuple[str, ...], 
+    string: str,
+    shape: tuple[int, ...] | None = None,
+) -> Slices:
     """
     Make a conventional slices from an axis-targeted slicing string.
 
     Parameters
     ----------
-    ndim : int
-        Number of dimension of the array which will be sliced.
     axes : str
         Axes of input ndarray.
     string : str
@@ -54,7 +84,14 @@ def axis_targeted_slicing(axes: tuple[str, ...], string: str) -> Slices:
     -------
     slices
     """    
-    keylist = re.sub(" ", "", string).split(";")
+    if "N" in string:
+        return axis_targeted_slicing_eval(axes, string, shape)
+    else:
+        return axis_targeted_slicing_const(axes, string)
+
+@lru_cache
+def axis_targeted_slicing_const(axes: tuple[str, ...], string: str) -> Slices:
+    keylist = string.replace(" ", "").split(";")
     dict_slicer: dict[str, Any] = {}
     
     for k in keylist:
@@ -68,9 +105,31 @@ def axis_targeted_slicing(axes: tuple[str, ...], string: str) -> Slices:
         else:
             dict_slicer[axis] = sl
     
-    return dict_to_slice(dict_slicer, axes)
+    return _dict_to_slice(dict_slicer, axes)
+
+def axis_targeted_slicing_eval(
+    axes: tuple[str, ...], 
+    string: str, 
+    shape: tuple[int, ...] | None = None,
+) -> Slices:
+    keylist = string.replace(" ", "").split(";")
+    dict_slicer: dict[str, Any] = {}
+    
+    for k in keylist:
+        if k.count("=") != 1:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        axis, sl_str = k.split("=")
+        try:
+            size = shape[axes.index(axis)]
+            sl = EvalSlicer(size).str_to_slice(sl_str)
+        except ValueError:
+            raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
+        else:
+            dict_slicer[axis] = sl
+    
+    return _dict_to_slice(dict_slicer, axes)
 
-def dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
+def _dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
     sl_list = [slice(None)] * len(axes)
     
     for k, v in sl.items():
@@ -79,11 +138,11 @@ def dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
     
     return tuple(sl_list)
 
-def solve_slicer(key: Any, axes: Axes) -> Slices:
+def solve_slicer(key: Any, axes: Axes, shape: tuple[int, ...] | None = None) -> Slices:
     if isinstance(key, str):
-        key = axis_targeted_slicing(tuple(axes), key)
+        key = axis_targeted_slicing(tuple(axes), key, shape)
     
     elif isinstance(key, (Mapping, Slicer)):
         key = axes.create_slice(key)
     
-    return key
+    return key

{impy_array-2.4.1.dist-info → impy_array-2.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: impy-array
-Version: 2.4.1
+Version: 2.4.3
 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>
@@ -120,8 +120,9 @@ or where to save the image. As a result, **your code will be very concise**:
 import impy as ip
 import numpy as np
 
-img = ip.imread("path/to/image")       # Read images with metadata.
+img = ip.imread("path/to/image.tif")   # Read images with metadata.
 img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
+img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
 img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
@@ -134,6 +135,7 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 - Tiff file (".tif", ".tiff")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 - Zarr file (".zarr")
+- ND2 file (".nd2")
 - Other image file (".png", ".jpg")
 
 ### Lazy loading
@@ -162,7 +164,10 @@ ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 
 ### Seamless interface between `napari`
 
-[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run
+[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional
+images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. 
+Since `ImgArray` is tagged with image metadata, you don't have to care about axes or 
+scales. Just run
 
 ```python
 ip.gui.add(img)

{impy_array-2.4.1.dist-info → impy_array-2.4.3.dist-info}/RECORD

@@ -1,41 +1,41 @@
-impy/__init__.py,sha256=Dd8i53lTgoq40fXeqOhduClsprYXWdeDZM_0Ug7i5Ys,1156
+impy/__init__.py,sha256=fAct8g-glCo45fXgbMEOELJGsVvtUkBZx5nXfOQMmm0,1156
 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=ADhMON5xTpjBG5MDOjUTthXzYSvm9zJNy8bL8RliI64,5843
 impy/binder.py,sha256=CTMb11g6uYDVVQV5Wtef865IO0G2V3vGXc8SiGYRD5k,9651
 impy/collections.py,sha256=2e55bLjZN7W4LFUCkyxekcDfLwZodMaU4JG5NQ3RS54,10946
-impy/core.py,sha256=q-9QZLKRqIKsI2knkxu5P4Tacq3FUIvFHjjUThZDuiM,25580
-impy/correlation.py,sha256=CoNboXiZjO1VYqA0rHe4Jp6gDYt6hyJtSgI3TWepxKk,28398
-impy/io.py,sha256=TFdGD3sGfmbkFI4FwfsemiTmk6cIgksbvhnFt7F24ac,22269
+impy/core.py,sha256=5FPiEksz7EpV8lKpNkPv0oZ9Yhs-bwIsnzQ9VFmYHHo,25650
+impy/correlation.py,sha256=aeQLfLAm8LnuKa4LtG_UWBamyi8SNMeDIs-lH5vYz9s,28555
+impy/io.py,sha256=SIGHJqCh6xfu8jDZ9BE0oWpVOoA5KAxgrI7u_v1ry5s,22272
 impy/random.py,sha256=TqPL8oFYGtZlr4phWyMSgP7KLqsXLH9LM3Fx1LxQWjA,6973
 impy/roi.py,sha256=p9ttjBl5SGHHXj0xg5UjPlg_V9cY3MnNZxFfYIjTYsg,14164
 impy/arrays/__init__.py,sha256=kbvvCRwdTck6b3gd3MBhD7L8Cp6XlmjX2HfSdPplhBo,377
-impy/arrays/_imshow.py,sha256=9MBwa6LwnuTcYbeJc5PwR_6VAdcn9K0JFx87BA6g-Po,6098
+impy/arrays/_imshow.py,sha256=6mJ_PDqmE4UZO9e9SUgyY_YrzQdR2QKlTG7KF_aC_tI,6949
 impy/arrays/axesmixin.py,sha256=9PK6kMZAfNVipTL65aF5-yR3qt2fy4ATl1OACXLYrAE,10596
 impy/arrays/big.py,sha256=0KPG_V7yKiVYLFwzGfHRxyFD2kysIyVppsq6hh7TFPg,2809
-impy/arrays/imgarray.py,sha256=oqFXASNXJ2neVy3HWp8uaPdncojgvLNsc5UvaW4tbWE,155622
+impy/arrays/imgarray.py,sha256=c1R0NG-SnC7i45JEnevfC3SvgzuFLoT8khT-1jIL_1E,157018
 impy/arrays/label.py,sha256=l0SZXcZxU8qwUgj0QZPZ32XsNaoBtenlrn6hNR03SPI,6406
 impy/arrays/labeledarray.py,sha256=4WBzorvLM9mmrkuytjMJb7ucqJqK62ioY6eTZlbNh3M,56540
-impy/arrays/lazy.py,sha256=r56r6_68BMopZoTG75L8JV3PA-vtR6l-jBzhDTaZLGY,55151
+impy/arrays/lazy.py,sha256=w3yeMokY62xAoqmfrr8_qh4LYDVnJdF0Jg4E3lZBHFg,55380
 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=eYbFOJ2sI9d6PqH83t1WdA8l2dmYb-1FMViGPl4_Lus,7565
+impy/arrays/tiled.py,sha256=4uGQKmZ0w2ZHlZNB1kl_4XP4hU1AftO21k6DgyJ1cUw,7767
 impy/arrays/_utils/__init__.py,sha256=M5HogfyUBvV8kp-X1ZthS8vDLUP7-O2f9Gvsc1ZXdT8,271
 impy/arrays/_utils/_corr.py,sha256=8RM_OeaDsrewhiYhf6wFkDYRfl1gQ8Sg2TTK4CT22K4,10031
 impy/arrays/_utils/_deconv.py,sha256=dCFWDPY6pkJxmqec5H0i1wtJECACvnz5vv1YIVLbnSY,2985
 impy/arrays/_utils/_docs.py,sha256=AT6tRxXcX433FCfPXhE9wsaeduy_Um44KOqrYHYTFZE,4968
 impy/arrays/_utils/_filters.py,sha256=aigQnaURbUnmOXGDxkWksISWQbKAUdwtS8kzbaMzgoQ,7226
-impy/arrays/_utils/_glcm.py,sha256=X499c4QMwdQAZas8rQbfdEpt5moosxNkTgyayTRJMvU,4149
+impy/arrays/_utils/_glcm.py,sha256=AoUP-p1MPtAzP0Eyt_DEE_wZYwezNICzdkXMBY-OEBo,4150
 impy/arrays/_utils/_linalg.py,sha256=06jnv-P6nwUjYVTHX2f9i-KDSYZ0bxwNfWWP8A8e_Vw,3233
 impy/arrays/_utils/_misc.py,sha256=jB16bZOYPEx_3JHGA-EIVziBjmaySPv66oyT_PZg_cI,2839
 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/_structures.py,sha256=GSwroP5CPP9MUuZHhrbJhO_Q9fc8u1hwBqiz-2koGJY,1300
+impy/arrays/_utils/_structures.py,sha256=K0gHjv9lF90wizAvFZQyHF02l2TC-texdYJTfB5I2H8,1301
 impy/arrays/_utils/_transform.py,sha256=fdee-qTWbdnQec-o9f2Z9HPjfsJVaVNn5sDPcNeVyLg,12682
 impy/arrays/bases/__init__.py,sha256=aHsAYta5CQkEDlbFShEtEGYN89N2qYedg99SM6Oo7wk,99
-impy/arrays/bases/metaarray.py,sha256=2ob-t2bZqOgMYdt0AN02p3eAGtcQPhehuOLtoDs442k,29832
+impy/arrays/bases/metaarray.py,sha256=wD9bDgqIgEqYkdyP_HlGY8vw_ETv7qsjkfG7A-sS83c,29868
 impy/arrays/bases/overload.py,sha256=ECLxRCumEUJb4KEu1K8k4vZWbufyPEPBj-Atzv4AosU,9359
 impy/axes/__init__.py,sha256=qzhWAJMT_mc-MXcuaMEDjVd_n0dFRmZxaphh6x_Wzb4,239
 impy/axes/_axes.py,sha256=lpTPzcs_hHslbxSUBGTjicIu4XLUs79zXPfDi5ZyGLI,12134
@@ -50,15 +50,15 @@ impy/lazy/random.py,sha256=2rwHRsHPOvi8tI9kTtGuZ5SzN0MA7yn-30bZSvHeLVc,7713
 impy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 impy/utils/axesop.py,sha256=c86XdNlUBFLrwHhAT2j0eELxopNe2QEVaNeOQhXr2do,3076
 impy/utils/deco.py,sha256=lItN0UdadZsjI9eW3fI402k7DNR9jcnD6ZgjdkYsDdg,5946
-impy/utils/gauss.py,sha256=735vYhSVrgZGiZeHYrwjVkRsQ-Zx5dYghOSrtfD3s4o,4712
+impy/utils/gauss.py,sha256=_jvmaUYSRB8KvX9Qp36rhNaNw9lllf68g_43wshpAMo,4713
 impy/utils/misc.py,sha256=zV_NeqEaiTW4Rki5fqWfspQjczRaoTJ5MxTOUx6qstY,622
-impy/utils/slicer.py,sha256=OR-PMILYBihY0jE38wIpS4QI30fk1c7D6LxaG_fDi_w,2423
+impy/utils/slicer.py,sha256=otDrizWdzoUjFUMlsha0zNFSS4TkgAmLPOAotaTVaUA,4316
 impy/utils/utilcls.py,sha256=3Td9G2ZkU4C0BiW2LH0sq7RBjdco_BtyxNr-s-seLhs,437
 impy/viewer/__init__.py,sha256=NTVonxd7HMfbRXHhjLBMG_07NjFia-O1QCv5IOKdbgw,286
 impy/viewer/utils.py,sha256=BUQ-hUN_j_hNON9F3B63670b-h6fIPxOB4fbAJnbSGg,12236
 impy/viewer/viewer.py,sha256=Sfq-obSLoHkBkIW0NDWCxEEaX7-YsC4ifAJ-nxpvJws,17632
-impy_array-2.4.1.dist-info/METADATA,sha256=5C3Nzq36x3irOWynCznvnNrSYu6lVEfDWtaw-ji0Y48,7526
-impy_array-2.4.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-impy_array-2.4.1.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
-impy_array-2.4.1.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
-impy_array-2.4.1.dist-info/RECORD,,
+impy_array-2.4.3.dist-info/METADATA,sha256=NHJ2pIQ5d456uKCt19xcYqwwE1iLZabtBAr20clV_go,7619
+impy_array-2.4.3.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+impy_array-2.4.3.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
+impy_array-2.4.3.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
+impy_array-2.4.3.dist-info/RECORD,,

{impy_array-2.4.1.dist-info → impy_array-2.4.3.dist-info}/WHEEL

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