impy-array 2.5.0__py3-none-any.whl → 2.5.2__py3-none-any.whl

impy/__init__.py

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

impy/arrays/imgarray.py

@@ -2675,7 +2675,7 @@ class ImgArray(LabeledArray):
         out = pd.concat(out, axis=0)
 
         out = MarkerFrame(out.reindex(columns=list(coords._axes)),
-                            columns=str(coords._axes), dtype=np.float32).as_standard_type()
+                            columns=str(coords._axes), dtype=np.float32)
         out.set_scale(coords.scale)
 
         return out
@@ -3801,7 +3801,7 @@ class ImgArray(LabeledArray):
 
     def regionprops(
         self,
-        properties: Iterable[str] | str = ("mean_intensity",),
+        properties: Iterable[str] | str = ("intensity_mean",),
         *,
         extra_properties: Iterable[Callable] | None = None,
     ) -> DataDict[str, PropArray]:
@@ -4111,8 +4111,6 @@ class ImgArray(LabeledArray):
 
         if along is None:
             along = find_first_appeared("tpzcia", include=self.axes)
-        elif len(along) != 1:
-            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:
@@ -4122,7 +4120,7 @@ class ImgArray(LabeledArray):
         c_axes = complement_axes(along, self.axes)
         last_img = None
         img_fft = self.fft(shift=False, dims=c_axes)
-        for i, (_, img) in enumerate(img_fft.iter(along)):
+        for i, (_, img) in enumerate(img_fft.iter([along])):
             img = xp.asarray(img)
             if last_img is not None:
                 result[i] = xp.asnumpy(
@@ -4198,8 +4196,6 @@ class ImgArray(LabeledArray):
 
         if along is None:
             along = find_first_appeared("tpzcia", include=self.axes, exclude=dims)
-        elif len(along) != 1:
-            raise ValueError("`along` must be single character.")
 
         if shift is None:
             # determine 'ref'

impy/arrays/labeledarray.py

@@ -302,16 +302,6 @@ class LabeledArray(MetaArray):
                 ext = ".tif"
             save_path = save_path.parent / (save_path.name + ext)
 
-        if not Path(save_path).is_absolute():
-            if self.source is None:
-                raise ValueError(
-                    "Image directory path is unknown. Set by \n"
-                    " >>> img.source = \"...\"\n"
-                    "or specify absolute path like\n"
-                    " >>> img.imsave(\"/path/to/XXX.tif\")"
-                )
-            save_path = self.source.parent / save_path
-
         if not overwrite and save_path.exists():
             raise FileExistsError(f"File {save_path!r} already exists.")
         if self.metadata is None:

impy/arrays/lazy.py

@@ -352,16 +352,6 @@ class LazyImgArray(AxesMixin):
                 ext = ".tif"
             save_path = save_path.parent / (save_path.name + ext)
 
-        if not Path(save_path).is_absolute():
-            if self.source is None:
-                raise ValueError(
-                    "Image directory path is unknown. Set by \n"
-                    " >>> img.source = \"...\"\n"
-                    "or specify absolute path like\n"
-                    " >>> img.imsave(\"/path/to/XXX.tif\")"
-                    )
-            save_path = self.source.parent / save_path
-
         if not overwrite and save_path.exists():
             raise FileExistsError(f"File {save_path!r} already exists.")
         if dtype is None:
@@ -776,12 +766,13 @@ class LazyImgArray(AxesMixin):
         sigma: nDFloat = 1.0,
         *,
         dims: Dims = None,
+        fourier: bool = False,
         update: bool = False
     ) -> LazyImgArray:
         c_axes = complement_axes(dims, self.axes)
         depth = _ceilint(sigma*4)
         return self._apply_map_overlap(
-            xp.ndi.gaussian_filter,
+            _filters.gaussian_filter_fourier if fourier else _filters.gaussian_filter,
             c_axes=c_axes,
             depth=depth,
             kwargs=dict(sigma=sigma),
@@ -795,13 +786,14 @@ class LazyImgArray(AxesMixin):
         low_sigma: nDFloat = 1.0,
         high_sigma: nDFloat = 2.0,
         *,
+        fourier: bool = False,
         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,
+            _filters.dog_filter_fourier if fourier else _filters.dog_filter,
             c_axes=c_axes,
             depth=depth,
             kwargs=dict(low_sigma=low_sigma, high_sigma=high_sigma),
@@ -1317,8 +1309,6 @@ class LazyImgArray(AxesMixin):
     def track_drift(self, along: str = None, upsample_factor: int = 10) -> DaskArray:
         if along is None:
             along = find_first_appeared("tpzc<i", include=self.axes)
-        elif len(along) != 1:
-            raise ValueError("`along` must be single character.")
 
         dims = complement_axes(along, self.axes)
         chunks = switch_slice(dims, self.axes, ifin=self.shape, ifnot=1)
@@ -1370,8 +1360,6 @@ class LazyImgArray(AxesMixin):
     ) -> LazyImgArray:
         if along is None:
             along = find_first_appeared("tpzcia", include=self.axes, exclude=dims)
-        elif len(along) != 1:
-            raise ValueError("`along` must be single character.")
 
         from impy.frame import MarkerFrame
 
@@ -1387,7 +1375,7 @@ class LazyImgArray(AxesMixin):
                     dims = _dims
             elif not isinstance(ref, self.__class__):
                 ref = self[ref]
-            if ref.axes != along + dims:
+            if ref.axes != [along] + dims:
                 raise ValueError(f"Arguments `along`({along}) + `dims`({dims}) do not match "
                                  f"axes of `ref`({ref.axes})")
 

impy/arrays/specials.py

@@ -20,23 +20,23 @@ SCALAR_PROP = (
 class PropArray(MetaArray):
     additional_props = ["_source", "_metadata", "_name", "propname"]
     propname: str
-    def __new__(cls, obj, *, name=None, axes=None, source=None, 
+    def __new__(cls, obj, *, name=None, axes=None, source=None,
                 metadata=None, propname=None, dtype=None):
         if propname is None:
             propname = "User_Defined"
-        
+
         if dtype is None and propname in SCALAR_PROP:
             dtype = np.float32
         elif dtype is None:
             dtype = object
         else:
             dtype = dtype
-            
+
         self = super().__new__(cls, obj, name, axes, source, metadata, dtype=dtype)
         self.propname = propname
-        
+
         return self
-    
+
     def _repr_dict_(self):
         return {
             "name": self.name,
@@ -44,7 +44,7 @@ class PropArray(MetaArray):
             "dtype": self.dtype,
             "source": self.source,
             "property name": self.propname}
-    
+
     def plot(self, along=None, cmap="jet", cmap_range=(0, 1)):
         """
         Plot all the results with x-axis defined by `along`.
@@ -57,7 +57,7 @@ class PropArray(MetaArray):
             Colormap of each graph.
         cmap_range : tuple, default is (0, 1)
             Range of float for colormap iteration.
-        """        
+        """
         import matplotlib.pyplot as plt
         if self.dtype == object:
             raise TypeError(f"Cannot call plot_profile for {self.propname} "
@@ -67,21 +67,21 @@ class PropArray(MetaArray):
                 along = find_first_appeared("tzp<yxc", include=self.axes)
             except ValueError:
                 along = self.axes[-1]
-        
+
         iteraxes = self.axes.drop(along)
         cmap = plt.get_cmap(cmap)
         positions = np.linspace(*cmap_range, self.size//self.sizeof(along), endpoint=False)
         x = np.arange(self.sizeof(along))*self.scale[along]
         for i, (sl, y) in enumerate(self.iter(iteraxes)):
             plt.plot(x, y, color=cmap(positions[i]))
-        
+
         plt.title(f"{self.propname}")
         plt.xlabel(along)
         plt.show()
-        
+
         return self
-    
-    def hist(self, along: str = "N", bins: int = None, cmap: str = "jet", 
+
+    def hist(self, along: str = "N", bins: int = None, cmap: str = "jet",
              cmap_range: tuple[float, float] = (0., 1.)) -> PropArray:
         """
         Plot histogram.
@@ -96,31 +96,31 @@ class PropArray(MetaArray):
             Colormap of each graph.
         cmap_range : tuple, default is (0, 1)
             Range of float for colormap iteration.
-        
+
         Returns
         -------
         self
-        """        
+        """
         import matplotlib.pyplot as plt
 
         if self.dtype == object:
             raise TypeError(f"Cannot call plot_profile for {self.propname} "
                             "because dtype == object.")
-        
+
         if along is None:
             along = find_first_appeared("pxyzt<c", include=self.axes)
-            
+
         iteraxes = self.axes.drop(along)
         cmap = plt.get_cmap(cmap)
         positions = np.linspace(*cmap_range, self.size//self.sizeof(along), endpoint=False)
         for i, (sl, y) in enumerate(self.iter(iteraxes)):
             plt.hist(y, color=cmap(positions[i]), bins=bins, alpha=0.5)
-        
+
         plt.title(f"{self.propname}")
         plt.show()
-        
+
         return self
-    
+
     def curve_fit(self, f: Callable, p0 = None, dims = "t", return_fit: bool = True) -> DataDict[str, PropArray]:
         """
         Run scipy.optimize.curve_fit for each dimesion.
@@ -130,12 +130,12 @@ class PropArray(MetaArray):
         f : callable
             Model function.
         p0 : array or callable, optional
-            Initial parameter. Callable object that estimate initial paramter can also 
+            Initial parameter. Callable object that estimate initial paramter can also
             be passed here.
         dims : str, by default "t"
             Along which axes fitting algorithms are conducted.
         return_fit : bool, by default True
-            If fitting trajectories are returned. If the input array is large, this will 
+            If fitting trajectories are returned. If the input array is large, this will
             save much memory.
 
         Returns
@@ -144,23 +144,23 @@ class PropArray(MetaArray):
             params : Fitting parameters
             covs : Covariances
             fit : fitting trajectories (if return_fit==True)
-        """        
+        """
         from scipy import optimize as opt
 
         c_axes = complement_axes(dims, all_axes=self.axes)
-        
+
         if len(dims)!=1:
             raise NotImplementedError("Only 1-dimensional fitting is implemented.")
-        
+
         n_params = len(signature(f).parameters)-1
-        
+
         params = np.empty(self.sizesof(c_axes) + (n_params,), dtype=np.float32)
         errs = np.empty(self.sizesof(c_axes) + (n_params,), dtype=np.float32)
         if return_fit:
             fit = np.empty(self.sizesof(c_axes) + (self.sizeof(dims),), dtype=self.dtype)
-            
+
         xdata = np.arange(self.sizeof(dims))*self.scale[dims]
-        
+
         for sl, data in self.iter(c_axes, exclude=dims):
             p0_ = p0 if not callable(p0) else p0(data)
             result = opt.curve_fit(f, xdata, data, p0_)
@@ -168,22 +168,22 @@ class PropArray(MetaArray):
             errs[sl] = np.sqrt(np.diag(cov))
             if return_fit:
                 fit[sl] = f(xdata, *(result[0]))
-        
+
         # set infos
         params = params.view(self.__class__)
         errs = errs.view(self.__class__)
         params._set_info(self, new_axes=self.axes.drop(dims).extend("m"))
         errs._set_info(self, new_axes=self.axes.drop(dims).extend("m"))
-        
+
         if return_fit:
             fit = fit.view(self.__class__)
             fit._set_info(self, new_axes=self.axes.drop(dims).extend(dims))
-        
+
         if return_fit:
             return DataDict(params=params, errs=errs, fit=fit)
         else:
             return DataDict(params=params, errs=errs)
-    
+
     def as_frame(self, colname: str = "f") -> AxesFrame:
         """
         N-dimensional data to DataFrame. The intensity data is stored in the `colname` column.
@@ -197,7 +197,7 @@ class PropArray(MetaArray):
         -------
         AxesFrame
             DataFrame with PropArray data.
-        """        
+        """
         from ..frame import AxesFrame
         if colname in self.axes:
             raise ImageAxesError(f"Axis {colname} already exists.")
@@ -210,4 +210,3 @@ class PropArray(MetaArray):
         df = AxesFrame(data_dict, columns=new_axes)
         df.set_scale(self)
         return df
-        

impy/core.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from contextlib import suppress
 import os
 from pathlib import Path
 import re
@@ -489,12 +490,12 @@ def broadcast_arrays(*arrays: MetaArray) -> list[MetaArray]:
     out = [a.broadcast_to(shape, axes) for a in arrays]
     return out
 
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 #   Imread functions
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 
 def imread(
-    path: str,
+    path: str | Path,
     dtype: DTypeLike = None,
     key: AxesTargetedSlicer | None = None,
     *,
@@ -502,6 +503,7 @@ def imread(
     squeeze: bool = False,
 ) -> ImgArray:
     """Load image(s) from a path.
+
     You can read list of images from directories with wildcards or ``"$"`` in ``path``.
 
     Parameters
@@ -535,12 +537,30 @@ def imread(
         Wall time: 3.01 ms
 
     """
-    path = str(Path(path).expanduser())
+    if str(path).startswith("~"):
+        path = str(Path(path).expanduser())
+    else:
+        path = str(path)
+
+    # if a directory of a ome.tiff is given, read the first image (which will eventually
+    # read all the positions) and use the directory name as source/name.
+    if (_fp := Path(path)).is_dir() and _fp.suffix != ".zarr":
+        _first_tif = next(_fp.glob("*.ome.tif"), None)
+        if _first_tif is None:
+            raise ValueError(
+                "If a directory is given to imread, only directory of ome.tif is "
+                "supported. Please use wildcard like `path/to/dir/*.tif` to read "
+                "images in a directory."
+            )
+        out = imread(_first_tif, dtype=dtype, key=key, name=_fp.name, squeeze=squeeze)
+        out.source = _fp
+        return out
+
     is_memmap = (key is not None)
 
     if "$" in path:
         return _imread_stack(path, dtype=dtype, key=key, squeeze=squeeze)
-    elif "*" in path:
+    elif "*" in path or "?" in path or "[" in path:
         return _imread_glob(path, dtype=dtype, key=key, squeeze=squeeze)
     elif not Path(path).exists():
         raise FileNotFoundError(f"No such file or directory: {path}")
@@ -575,7 +595,8 @@ def imread(
             # In case the image is in yxc-order. This sometimes happens.
             self: ImgArray = np.moveaxis(self, -1, -3)
         if labels is not None:
-            self.set_axis_label(c=labels)
+            with suppress(ValueError):
+                self.set_axis_label(c=labels)
 
     if dtype is None:
         dtype = self.dtype
@@ -619,8 +640,9 @@ def _imread_glob(path: str, squeeze: bool = False, **kwargs) -> ImgArray:
     out: ImgArray = np.stack(imgs, axis="p")
     if squeeze:
         out = np.squeeze(out)
+    sep = "*" if "*" in path else "?"
     try:
-        base = os.path.split(path.split("*")[0])[0]
+        base = os.path.split(path.split(sep)[0])[0]
         out.source = base
     except Exception:
         pass

impy/frame/frames.py

@@ -18,11 +18,11 @@ else:
 
 class AxesFrame(pd.DataFrame):
     _metadata = ["_axes"]
-    
+
     @property
     def _constructor(self):
         return AxesFrame
-    
+
     def __init__(self, data=None, columns=None, **kwargs):
         if isinstance(columns, (str, Axes)):
             kwargs["columns"] = [a for a in columns]
@@ -32,17 +32,17 @@ class AxesFrame(pd.DataFrame):
                 columns = str(data._axes)
         else:
             kwargs["columns"] = columns
-        
+
         super().__init__(data, **kwargs)
         self._axes = Axes(self.columns)
-    
+
     def _get_coords_cols(self):
         return [a for a in self.columns if len(a) == 1]
-    
+
     def get_coords(self):
         return self[self.columns[self.columns.isin([a for a in self.columns if len(a) == 1])]]
-    
-    
+
+
     def __getitem__(self, k):
         # sl_tuple = solve_slicer(key, self.axes)
         # drops: list[int] = []
@@ -56,7 +56,7 @@ class AxesFrame(pd.DataFrame):
         #             binary = np.logical_and(binary, (arr - s0) % step == 0)
         #         elif step < 0:
         #             raise NotImplementedError
-                
+
         #     else:
         #         binary = arr == sl
         #         drops.append(i)
@@ -72,9 +72,9 @@ class AxesFrame(pd.DataFrame):
                 for each in k.split(";"):
                     self = self.__getitem__(each.strip())
                 return self
-            
+
             elif "=" in k:
-                axis, sl = [a.strip() for a in k.split("=")]
+                axis, sl = (a.strip() for a in k.split("="))
                 sl = str_to_slice(sl)
                 if isinstance(sl, int):
                     out = self[self[axis]==sl]
@@ -87,19 +87,19 @@ class AxesFrame(pd.DataFrame):
             elif "" == k:
                 return self
             else:
-                out = super().__getitem__(k)                
+                out = super().__getitem__(k)
         else:
             out = super().__getitem__(k)
-            
+
         if isinstance(out, AxesFrame):
             out._axes = Axes(out._get_coords_cols())
             out.set_scale(self)
         return out
-    
+
     @property
     def col_axes(self):
         return self._axes
-    
+
     @col_axes.setter
     def col_axes(self, value):
         naxes = self.shape[1]
@@ -113,11 +113,11 @@ class AxesFrame(pd.DataFrame):
                     f"array (ndim={naxes}) and axes ({value})"
                 )
             self._axes = axes
-    
+
     @property
     def scale(self):
         return self._axes.scale
-    
+
     def set_scale(self, other=None, **kwargs) -> None:
         """
         Set scales of each axis.
@@ -127,7 +127,7 @@ class AxesFrame(pd.DataFrame):
         other : dict, AxesFrame or MetaArray, optional
             New scales. If dict, it should be like {"x": 0.1, "y": 0.1}. If MetaArray, only
             scales of common axes are copied.
-        kwargs : 
+        kwargs :
             This enables function call like set_scale(x=0.1, y=0.1).
 
         """
@@ -142,40 +142,29 @@ class AxesFrame(pd.DataFrame):
             # check if all the keys are contained in axes.
             for a, val in other.items():
                 if a not in self._axes:
-                    raise ImageAxesError(f"Image does not have axis {a}.")    
+                    raise ImageAxesError(f"Image does not have axis {a}.")
                 elif not np.isscalar(val):
                     raise TypeError(f"Cannot set non-numeric value as scales.")
-            
+
             for k, v in other.items():
                 self.col_axes[k].scale = v
-            
+
         elif hasattr(other, "scale"):
             self.set_scale({a: s for a, s in other.scale.items() if a in self._axes})
-            
+
         elif kwargs:
             self.set_scale(dict(kwargs))
-            
+
         else:
             raise TypeError(f"'other' must be str or MetaArray, but got {type(other)}")
-        
+
         return None
-    
-    def as_standard_type(self) -> AxesFrame:
-        """
-        t or c -> uint16
-        p -> uint32
-        z, y, x -> float32
-        """
-        dtype = lambda a: np.uint16 if a in ["t", "c"] else (np.uint32 if a == Const["ID_AXIS"] else np.float32)
-        out = self.__class__(self.astype({a: dtype(a) for a in self.col_axes}))
-        out._axes = self._axes
-        return out
-        
-    
+
+
     def split(self, axis="c") -> list[AxesFrame]:
         """
         Split DataFrame according to its indices. For example, if self is an DataFrame with columns
-        "t", "c", "y", "x" and it is split along "c" axis, then output is a list of DataFrame with 
+        "t", "c", "y", "x" and it is split along "c" axis, then output is a list of DataFrame with
         columns "t", "y", "x".
 
         Parameters
@@ -204,7 +193,7 @@ class AxesFrame(pd.DataFrame):
         ----------
         axes : str
             Along which axes to iterate.
-            
+
         Yields
         -------
         tuple and AxesFrame
@@ -214,10 +203,10 @@ class AxesFrame(pd.DataFrame):
         outsl = [slice(None)] * len(self.col_axes)
         cols = [a for a in self.col_axes if a not in axes]
         groupkeys = [a for a in axes]
-        
+
         if len(groupkeys) == 0:
             yield (slice(None),), self
-        
+
         else:
             if len(groupkeys) == 1:
                 groupkeys = groupkeys[0]
@@ -227,21 +216,21 @@ class AxesFrame(pd.DataFrame):
                     sl = (sl,)
                 [outsl.__setitem__(i, s) for i, s in zip(indices, sl)]
                 yield tuple(outsl), af
-    
+
     def sort(self):
         ids = self._axes.argsort()
         return self[[self._axes[i] for i in ids]]
-    
+
     def proj(self, axis=None):
         if axis is None:
             axis = complement_axes("yx", self._axes)
         cols = [a for a in self.col_axes if a not in axis]
         return self[cols]
-        
+
 def tp_no_verbose(func):
     """
     Temporary suppress logging in trackpy.
-    """    
+    """
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         tp.quiet(suppress=True)
@@ -277,19 +266,19 @@ class MarkerFrame(AxesFrame):
         -------
         TrackFrame
             Result of particle tracking.
-        """        
-            
+        """
+
         linked = tp.link(pd.DataFrame(self), search_range=search_range, t_column="t", memory=memory, **kwargs)
-        
+
         linked.rename(columns = {"particle":Const["ID_AXIS"]}, inplace=True)
         linked = linked.reindex(columns=[a for a in Const["ID_AXIS"]+str(self.col_axes)])
-        
+
         track = TrackFrame(linked, columns="".join(linked.columns.tolist()))
         track.set_scale(self)
         if min_dwell > 0:
             out = track.filter_stubs(min_dwell)
         else:
-            out = track.as_standard_type()
+            out = track
         out.index = np.arange(len(out))
         return out
 
@@ -298,7 +287,7 @@ class TrackFrame(AxesFrame):
         df = pd.DataFrame(self, copy=True, dtype=np.float32)
         df.rename(columns = {"t":"frame", Const["ID_AXIS"]:"particle"}, inplace=True)
         return df
-        
+
     @tp_no_verbose
     def track_drift(self, smoothing=0):
         df = self._renamed_df()
@@ -307,25 +296,25 @@ class TrackFrame(AxesFrame):
         ori = pd.DataFrame({"y":[0.], "x":[0.]}, dtype=np.float32)
         shift = pd.concat([ori, shift], axis=0)
         return MarkerFrame(shift)
-    
+
     @tp_no_verbose
     def msd(self, max_lagt:int=100, detail:bool=False):
         df = self._renamed_df()
-        return tp.motion.msd(df, self.scale["x"], self.scale["t"], 
+        return tp.motion.msd(df, self.scale["x"], self.scale["t"],
                              max_lagtime=max_lagt, detail=detail)
-    
+
     @tp_no_verbose
     def imsd(self, max_lagt=100):
         df = self._renamed_df()
-        return tp.motion.imsd(df, self.scale["x"], self.scale["t"], 
+        return tp.motion.imsd(df, self.scale["x"], self.scale["t"],
                              max_lagtime=max_lagt)
-    
+
     @tp_no_verbose
     def emsd(self, max_lagt=100, detail=False):
         df = self._renamed_df()
-        return tp.motion.emsd(df, self.scale["x"], self.scale["t"], 
+        return tp.motion.emsd(df, self.scale["x"], self.scale["t"],
                              max_lagtime=max_lagt, detail=detail)
-    
+
     @tp_no_verbose
     def filter_stubs(self, min_dwell=3):
         df = self._renamed_df()
@@ -334,8 +323,8 @@ class TrackFrame(AxesFrame):
         df = df.astype({"t":np.uint16, Const["ID_AXIS"]:np.uint32})
         out = TrackFrame(df, columns=self.col_axes)
         out.set_scale(self)
-        return out.as_standard_type()
-    
+        return out
+
     def as_path(self):
         df = self[[a for a in self._axes if a != "t"]]
         return PathFrame(df, columns=df._axes)
@@ -346,4 +335,4 @@ class PathFrame(AxesFrame):
             dims = [a for a in "zyx" if a in self._axes]
         path_len = lambda df: np.sum(np.sqrt(sum(np.diff(df[a])**2 for a in dims)))
         c_axes = complement_axes(dims, self._axes)
-        return self.groupby(list(c_axes)).apply(path_len)
+        return self.groupby(list(c_axes)).apply(path_len)

impy/lazy/core.py

@@ -278,7 +278,7 @@ def imread(
             if k in "zyx":
                 self.axes[k].unit = spatial_scale_unit.get(k)
 
-    return self.sort_axes()
+    return self
 
 
 def _imread_glob(path: str, squeeze: bool = False, **kwargs) -> LazyImgArray:

impy/viewer/utils.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
     from napari.layers import Shapes
 
 
-def iter_layer(viewer:"napari.Viewer", layer_type: str):
+def iter_layer(viewer:napari.Viewer, layer_type: str):
     """
     Iterate over layers and yield only certain type of layers.
 
@@ -29,31 +29,31 @@ def iter_layer(viewer:"napari.Viewer", layer_type: str):
     -------
     napari.layers
         Layers specified by layer_type
-    """      
+    """
     from napari import layers
     if isinstance(layer_type, str):
         layer_type = [layer_type]
     layer_type = tuple(getattr(layers, t) for t in layer_type)
-    
+
     for layer in viewer.layers:
         if isinstance(layer, layer_type):
             yield layer
 
-def iter_selected_layer(viewer: "napari.Viewer", layer_type: str | list[str]):
+def iter_selected_layer(viewer: napari.Viewer, layer_type: str | list[str]):
     """Iterate over selected layers and yield only certain type of layers."""
-    
+
     from napari import layers
     if isinstance(layer_type, str):
         layer_type = [layer_type]
     layer_type = tuple(getattr(layers, t) for t in layer_type)
-    
+
     for layer in viewer.layers.selection:
         if isinstance(layer, layer_type):
             yield layer
 
-def front_image(viewer:"napari.Viewer"):
-    """From list of image layers return the most front visible image."""        
-    
+def front_image(viewer:napari.Viewer):
+    """From list of image layers return the most front visible image."""
+
     front = None
     for img in iter_layer(viewer, "Image"):
         if img.visible:
@@ -62,7 +62,7 @@ def front_image(viewer:"napari.Viewer"):
         raise ValueError("There is no visible image layer.")
     return front
 
-def to_labels(layer: "Shapes", labels_shape: tuple[int, ...], zoom_factor: float = 1.):
+def to_labels(layer: Shapes, labels_shape: tuple[int, ...], zoom_factor: float = 1.):
     """Convert a Shapes layer to labels, with given zoom factor."""
     return layer._data_view.to_labels(
         labels_shape=labels_shape, zoom_factor=zoom_factor
@@ -79,9 +79,9 @@ def make_world_scale(obj):
             scale.append(1)
     return scale
 
-def viewer_imread(viewer: "napari.Viewer", path: str):    
+def viewer_imread(viewer: napari.Viewer, path: str):
     """Read an image into the viewer."""
-    
+
     if "*" in path or os.path.getsize(path)/2**30 < Const["MAX_GB"]:
         img = imread(path)
     else:
@@ -89,9 +89,9 @@ def viewer_imread(viewer: "napari.Viewer", path: str):
     layer = add_labeledarray(viewer, img)
     return layer
 
-def add_labeledarray(viewer: "napari.Viewer", img: LabeledArray, **kwargs):
+def add_labeledarray(viewer: napari.Viewer, img: LabeledArray, **kwargs):
     """Add a LabeledArray to the viewer."""
-    
+
     if not img.axes.is_sorted() and img.ndim > 2:
         msg = (
             f"Input image has axes that are not correctly sorted: {img.axes}. "
@@ -99,15 +99,15 @@ def add_labeledarray(viewer: "napari.Viewer", img: LabeledArray, **kwargs):
         )
         warnings.warn(msg, UserWarning)
     chn_ax = img.axisof("c") if "c" in img.axes else None
-        
+
     if isinstance(img, PhaseArray) and not "colormap" in kwargs.keys():
         kwargs["colormap"] = "hsv"
         kwargs["contrast_limits"] = img.border
     elif img.dtype.kind == "c" and not "colormap" in kwargs.keys():
         kwargs["colormap"] = "plasma"
-    
+
     scale = make_world_scale(img)
-    
+
     if "name" in kwargs:
         name = kwargs.pop("name")
     else:
@@ -116,20 +116,20 @@ def add_labeledarray(viewer: "napari.Viewer", img: LabeledArray, **kwargs):
             name = [f"[C{i}]{name}" for i in range(img.shape.c)]
         else:
             name = [name]
-    
+
     if img.dtype.kind == "c":
         input = ComplexArrayView(img)
     else:
         input = img
-        
+
     layer = viewer.add_image(
         input,
         channel_axis=chn_ax,
-        scale=scale, 
+        scale=scale,
         name=name if len(name) > 1 else name[0],
         **kwargs
     )
-    
+
     if viewer.scale_bar.unit:
         if viewer.scale_bar.unit != img.scale_unit:
             msg = (
@@ -139,7 +139,7 @@ def add_labeledarray(viewer: "napari.Viewer", img: LabeledArray, **kwargs):
             warnings.warn(msg)
     else:
         viewer.scale_bar.unit = img.scale_unit
-        
+
     new_axes = [str(a) for a in img.axes if a != "c"]
     # add axis labels to slide bars and image orientation.
     if len(new_axes) >= len(viewer.dims.axis_labels):
@@ -147,10 +147,10 @@ def add_labeledarray(viewer: "napari.Viewer", img: LabeledArray, **kwargs):
     return layer
 
 def add_labels(
-    viewer: "napari.Viewer",
+    viewer: napari.Viewer,
     labels: Label,
     opacity: float = 0.3,
-    name: str | list[str] | None = None, 
+    name: str | list[str] | None = None,
     **kwargs
 ):
     scale = make_world_scale(labels)
@@ -159,7 +159,7 @@ def add_labels(
         lbls = labels.split("c")
     else:
         lbls = [labels]
-    
+
     # prepare name list
     if isinstance(name, list):
         names = [f"[L]{n}" for n in name]
@@ -167,19 +167,19 @@ def add_labels(
         names = [f"[L]{name}"] * len(lbls)
     else:
         names = [labels.name]
-        
+
     kw = dict(opacity=opacity, scale=scale)
     kw.update(kwargs)
-    
+
     out_layers = []
     for lbl, name in zip(lbls, names):
         layer = viewer.add_labels(lbl.value, name=name, **kw)
         out_layers.append(layer)
     return out_layers
 
-def add_dask(viewer: "napari.Viewer", img: LazyImgArray, **kwargs):
+def add_dask(viewer: napari.Viewer, img: LazyImgArray, **kwargs):
     chn_ax = img.axisof("c") if "c" in img.axes else None
-                
+
     scale = make_world_scale(img)
     name = img.name
 
@@ -188,7 +188,7 @@ def add_dask(viewer: "napari.Viewer", img: LazyImgArray, **kwargs):
     else:
         name = ["[Lazy]" + name]
 
-    layer = viewer.add_image(img, channel_axis=chn_ax, scale=scale, 
+    layer = viewer.add_image(img, channel_axis=chn_ax, scale=scale,
                              name=name if len(name)>1 else name[0], **kwargs)
     viewer.scale_bar.unit = img.scale_unit
     new_axes = [str(a) for a in img.axes if a != "c"]
@@ -197,19 +197,19 @@ def add_dask(viewer: "napari.Viewer", img: LazyImgArray, **kwargs):
         viewer.dims.axis_labels = new_axes
     return layer
 
-def add_points(viewer:"napari.Viewer", points: AxesFrame, **kwargs):
+def add_points(viewer:napari.Viewer, points: AxesFrame, **kwargs):
     from ..frame import MarkerFrame
     if isinstance(points, MarkerFrame):
         scale = make_world_scale(points)
         points = points.get_coords()
     else:
         scale=None
-    
+
     if "c" in points._axes:
         pnts = points.split("c")
     else:
         pnts = [points]
-        
+
     for each in pnts:
         metadata = {"axes": str(each._axes), "scale": each.scale}
         kw = dict(
@@ -219,30 +219,30 @@ def add_points(viewer:"napari.Viewer", points: AxesFrame, **kwargs):
         )
         kw.update(kwargs)
         viewer.add_points(each.values, scale=scale, **kw)
-        
+
     return None
 
-def add_tracks(viewer:"napari.Viewer", track: "TrackFrame", **kwargs):
+def add_tracks(viewer:napari.Viewer, track: TrackFrame, **kwargs):
     if "c" in track._axes:
         track_list = track.split("c")
     else:
         track_list = [track]
-        
+
     scale = make_world_scale(
         track[[a for a in track._axes if a != Const["ID_AXIS"]]]
     )
     for tr in track_list:
         metadata = {"axes": str(tr._axes), "scale": tr.scale}
         viewer.add_tracks(tr, scale=scale, metadata=metadata, **kwargs)
-    
+
     return None
 
-def add_paths(viewer: "napari.Viewer", paths: PathFrame, **kwargs):
+def add_paths(viewer: napari.Viewer, paths: PathFrame, **kwargs):
     if "c" in paths._axes:
         path_list = paths.split("c")
     else:
         path_list = [paths]
-        
+
     scale = make_world_scale(
         paths[[a for a in paths._axes if a != Const["ID_AXIS"]]]
     )
@@ -253,19 +253,19 @@ def add_paths(viewer: "napari.Viewer", paths: PathFrame, **kwargs):
         metadata = {"axes": str(path._axes), "scale": path.scale}
         paths = [single_path.values for single_path in path.split(Const["ID_AXIS"])]
         viewer.add_shapes(paths, scale=scale, metadata=metadata, **kw)
-    
+
     return None
 
-def add_rois(viewer: "napari.Viewer", rois: Iterable[Roi], **kwargs):
+def add_rois(viewer: napari.Viewer, rois: Iterable[Roi], **kwargs):
     from ..roi import LineRoi, PointRoi, PolygonRoi, PolyLineRoi, RectangleRoi
-    
+
     _map = {
         LineRoi: "line",
         PolygonRoi: "polygon",
         PolyLineRoi: "path",
         RectangleRoi: "rectangle",
     }
-    
+
     shapes = []
     shape_types = []
     for roi in rois:
@@ -274,16 +274,16 @@ def add_rois(viewer: "napari.Viewer", rois: Iterable[Roi], **kwargs):
         else:
             shape_types.append(_map[type(roi)])
             shapes.append(np.array(roi))
-    
+
     viewer.add_shapes(shapes, shape_type=shape_types, **kwargs)
-    
+
     return None
 
-def get_viewer_scale(viewer: "napari.Viewer"):
+def get_viewer_scale(viewer: napari.Viewer):
     """Get the scale of the viewer."""
     return {a: r[2] for a, r in zip(viewer.dims.axis_labels, viewer.dims.range)}
 
-def layer_to_impy_object(viewer: "napari.Viewer", layer):
+def layer_to_impy_object(viewer: napari.Viewer, layer):
     """
     Convert layer to real data.
 
@@ -295,7 +295,7 @@ def layer_to_impy_object(viewer: "napari.Viewer", layer):
     Returns
     -------
     ImgArray, Label, MarkerFrame or TrackFrame, or Shape features.
-    """ 
+    """
     data = layer.data
     axes = "".join(viewer.dims.axis_labels)
     scale = get_viewer_scale(viewer)
@@ -321,21 +321,21 @@ def layer_to_impy_object(viewer: "napari.Viewer", layer):
         ndim = data.shape[1]
         axes = axes[-ndim:]
         df = MarkerFrame(data, columns=layer.metadata.get("axes", axes))
-        df.set_scale(layer.metadata.get("scale", 
+        df.set_scale(layer.metadata.get("scale",
                                         {k: v for k, v in scale.items() if k in axes}))
-        return df.as_standard_type()
+        return df
     elif isinstance(layer, Tracks):
         from ..frame import TrackFrame
         ndim = data.shape[1]
         axes = axes[-ndim:]
         df = TrackFrame(data, columns=layer.metadata.get("axes", axes))
-        df.set_scale(layer.metadata.get("scale", 
+        df.set_scale(layer.metadata.get("scale",
                                         {k: v for k, v in scale.items() if k in axes}))
-        return df.as_standard_type()
+        return df
     else:
         raise NotImplementedError(type(layer))
 
-def get_a_selected_layer(viewer:"napari.Viewer"):
+def get_a_selected_layer(viewer:napari.Viewer):
     selected = list(viewer.layers.selection)
     if len(selected) == 0:
         raise ValueError("No layer is selected.")
@@ -352,34 +352,34 @@ class ComplexArrayView:
         if data.dtype.kind != "c":
             raise TypeError("Input was not a complex array.")
         self._data = data
-    
+
     def __array__(self, dtype=None, copy=False) -> np.ndarray:
         return np.abs(self._data)
-    
+
     @property
     def data_raw(self) -> _A:
         """Return the raw data."""
         return self._data
-    
+
     @property
     def shape(self) -> tuple:
         """Shape of array."""
         return self._data.shape
-    
+
     @property
     def ndim(self) -> int:
         """Number of dimensions of array."""
         return self._data.ndim
-    
+
     @property
     def dtype(self) -> np.dtype:
         """Data type of array."""
         return self._data.dtype
-    
+
     @property
     def nbytes(self) -> int:
         """Bytes of array."""
         return self._data.nbytes
-    
+
     def __getitem__(self, key):
-        return self.__class__(self._data[key])
+        return self.__class__(self._data[key])

{impy_array-2.5.0.dist-info → impy_array-2.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: impy-array
-Version: 2.5.0
+Version: 2.5.2
 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.5.0.dist-info → impy_array-2.5.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
-impy/__init__.py,sha256=HIf0has95uJ0K2gmcvEEzYy1YhiTmA5FYy4sk5y4AL0,1638
+impy/__init__.py,sha256=aibzVT5sn4GqWH_rElWQlVWdtgap0hDKqlCnALbn1P8,1638
 impy/__main__.py,sha256=BAQkQ4X8EFo42pbNx__EqpZ5KL4MTfTUWsVbJIQF0O0,4974
 impy/_const.py,sha256=uNHxxY5ltZuOsJWpwlBWFmUM0QfMgIk5WODqlHuBomo,3700
 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=d7TsgpVcPQi_CqATgFa_QZ1ojTKxTWEfSlpE_UKOQ9A,25610
+impy/core.py,sha256=ntvPvL48PvX_tlxb7_KXMF8HGV8q-7Hh_wlIuMljxb4,26527
 impy/correlation.py,sha256=Yw1T_0eL9FmsMcnCysc49oRJQMn8ho5z9bAzNg5i59Y,28232
 impy/random.py,sha256=MQl0ViN6A7xDtM8BS4gbv1atgPKsrmp0TXzV1OtsDlU,7004
 impy/roi.py,sha256=p9ttjBl5SGHHXj0xg5UjPlg_V9cY3MnNZxFfYIjTYsg,14164
@@ -13,12 +13,12 @@ impy/arrays/__init__.py,sha256=IHpTBIJysomS64rOZsv960YBmM1vc4M-asTSs1OJBWg,454
 impy/arrays/_imshow.py,sha256=6mJ_PDqmE4UZO9e9SUgyY_YrzQdR2QKlTG7KF_aC_tI,6949
 impy/arrays/axesmixin.py,sha256=NwiPldNbD3rYpvuydviJMEoH88-joHdfQuuXLE6Rs7c,10454
 impy/arrays/big.py,sha256=tHNijyPgyIfTltLP3hQwZdHOpSX3IwG5DHPamajZ8Kg,2745
-impy/arrays/imgarray.py,sha256=rpwu9uGMKAO3raw1qli5FBvDer0TFWL_X2Z8a3eU5nQ,161974
+impy/arrays/imgarray.py,sha256=qAZ_ZtK4rFisXta1W5jrF7b71ivoLLT6NbzY-MIHVWA,161761
 impy/arrays/label.py,sha256=l0SZXcZxU8qwUgj0QZPZ32XsNaoBtenlrn6hNR03SPI,6406
-impy/arrays/labeledarray.py,sha256=GRjgZ5IfXIq-Iwj9cEYazo7oPNiBveRekUnKcSts91I,59455
-impy/arrays/lazy.py,sha256=y3IXPs6mRE2I8yiOnMsjO0gqi2EFjrNxHMOExUF_xM0,61450
+impy/arrays/labeledarray.py,sha256=9fT0bVqyByYG1ifyQzzC1y8KdEUx_hrfNI7Vex_EAvs,59026
+impy/arrays/lazy.py,sha256=lRRRN25WE9v2TwOl37Dny6OuyPv-be8dsBJ6vqHnkQY,60982
 impy/arrays/phasearray.py,sha256=IojWaNs5sEujn6Lhgqe00H0xF-4CZEFWt5cVW6U_DWQ,13981
-impy/arrays/specials.py,sha256=4sNg_zeJUce_rwnasPoyL2eZ0-gx_4Z-KwitmLB4a5k,7896
+impy/arrays/specials.py,sha256=M2EmpYNChc4FoAAZvkRq8OKq2zLAd6TWqKIF_lfpCqg,7666
 impy/arrays/tiled.py,sha256=T44sS6v1Ovln1z1g61Eg8irgZR1Jmpb6BCY3nS6TmDE,9400
 impy/arrays/_utils/__init__.py,sha256=M5HogfyUBvV8kp-X1ZthS8vDLUP7-O2f9Gvsc1ZXdT8,271
 impy/arrays/_utils/_corr.py,sha256=ThGQV3KSv8ir8BTWDoV83ysalPB2p--LmSCv-J9qq2w,10047
@@ -42,7 +42,7 @@ impy/axes/_axes_tuple.py,sha256=hkgTr_n36gFcnnffmSp3z4oJ_52MxT1JnaszdJ3JnrY,1522
 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
+impy/frame/frames.py,sha256=RGFbRd5h7fSI-t1b2lt2GCF_Y9N8dkIFvkH6E63qFJ4,11720
 impy/io/__init__.py,sha256=Xz7SeHkDDbLm3Z9gqav3iByLsmsBoLjol4nDtEq-WeY,315
 impy/io/_czi.py,sha256=0FQsrzL9ygaB6IHITceAmLsOxkLFKwlQFKSLQCmJbyY,1667
 impy/io/_mrc.py,sha256=i3_GHxBdM8f0NYnqU7Oklw6wM7boYcLzWwBTU7V3Y2U,3936
@@ -53,7 +53,7 @@ impy/io/_tiff.py,sha256=kfRB6H-fKBk-lrv_y6tY2fNbG_BEcPm2Ja41-0EtZ_8,6528
 impy/io/_utils.py,sha256=WHAiuCC1_tdsZ07HLM8jKjptKnQGevG7eXdnuJd069o,3723
 impy/io/_zarr.py,sha256=Nfr5VJ3DzKN5d7nYoq_ZG9AG2GIDWHYJ33LpG9SwGcs,1336
 impy/lazy/__init__.py,sha256=hRjpE2zCy5qDAr_27imwRM9J0C7q-a_b5wfC3ux8ZLE,59
-impy/lazy/core.py,sha256=RNGavMvPW6_Yfi-L0WDIWfRZKo1My8Fw8Qo1e0pQA1k,9682
+impy/lazy/core.py,sha256=LQMHl8cKBiGc972PFRP3jJungv8MtBn6B24bI4aFQWs,9670
 impy/lazy/random.py,sha256=2rwHRsHPOvi8tI9kTtGuZ5SzN0MA7yn-30bZSvHeLVc,7713
 impy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 impy/utils/axesop.py,sha256=c86XdNlUBFLrwHhAT2j0eELxopNe2QEVaNeOQhXr2do,3076
@@ -63,10 +63,10 @@ impy/utils/misc.py,sha256=zV_NeqEaiTW4Rki5fqWfspQjczRaoTJ5MxTOUx6qstY,622
 impy/utils/slicer.py,sha256=otDrizWdzoUjFUMlsha0zNFSS4TkgAmLPOAotaTVaUA,4316
 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/utils.py,sha256=Giv1Q50gXDHQZoJyrGJEBUKCKfOQLkRB6fC5NE2rzg0,11971
 impy/viewer/viewer.py,sha256=Sfq-obSLoHkBkIW0NDWCxEEaX7-YsC4ifAJ-nxpvJws,17632
-impy_array-2.5.0.dist-info/METADATA,sha256=Mezd4xl2BG99x3NrWc1O2uXn86erZm2PV5xcCElQs5E,7567
-impy_array-2.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-impy_array-2.5.0.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
-impy_array-2.5.0.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
-impy_array-2.5.0.dist-info/RECORD,,
+impy_array-2.5.2.dist-info/METADATA,sha256=_HvcusR2hwLfWqpdpTaYv7x3Zhi73k5kDb6zaKECFeY,7567
+impy_array-2.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+impy_array-2.5.2.dist-info/entry_points.txt,sha256=reyrgy4odXvi1CcPOIIyRYBmsNGG2tO7ZkFOdG5CBkU,44
+impy_array-2.5.2.dist-info/licenses/LICENSE,sha256=rpxKafH9r42sxLLYYB5VbZBHOdtYeLuYJjVU1LBwrxk,1546
+impy_array-2.5.2.dist-info/RECORD,,