impy-array 2.5.1__tar.gz → 2.5.3__tar.gz

{impy_array-2.5.1 → impy_array-2.5.3}/PKG-INFO

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

{impy_array-2.5.1 → impy_array-2.5.3}/impy/__init__.py

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

{impy_array-2.5.1 → impy_array-2.5.3}/impy/array_api.py

@@ -97,7 +97,7 @@ class XP:
         self.angle = np.angle
         self.abs = np.abs
         self.mod = np.mod
-        self.fix = np.fix
+        self.trunc = np.trunc
         self.round = np.round
         self.gradient = np.gradient
         self.tensordot = np.tensordot
@@ -165,7 +165,7 @@ class XP:
         self.angle = cp.angle
         self.abs = cp.abs
         self.mod = cp.mod
-        self.fix = cp.fix
+        self.trunc = cp.trunc
         self.round = cp.round
         try:
             self.gradient = cp.gradient

{impy_array-2.5.1 → impy_array-2.5.3}/impy/arrays/_utils/_corr.py

@@ -38,16 +38,16 @@ def subpixel_pcc(
 ):
     power, product = _pcc_and_power_spec(f0, f1, max_shifts)
     maxima = xp.unravel_index(xp.argmax(power), power.shape)
-    midpoints = xp.array([np.fix(axis_size / 2) for axis_size in power.shape])
+    midpoints = xp.array([np.trunc(axis_size / 2) for axis_size in power.shape])
 
     shifts = xp.asarray(maxima, dtype=np.float32)
     shifts[shifts > midpoints] -= xp.array(power.shape)[shifts > midpoints]
     # Initial shift estimate in upsampled grid
-    shifts = xp.fix(shifts * upsample_factor) / upsample_factor
+    shifts = xp.trunc(shifts * upsample_factor) / upsample_factor
     if upsample_factor > 1:
         upsampled_region_size = np.ceil(upsample_factor * 1.5)
         # Center of output array at dftshift + 1
-        dftshift = xp.fix(upsampled_region_size / 2.0)
+        dftshift = xp.trunc(upsampled_region_size / 2.0)
         upsample_factor = xp.array(upsample_factor, dtype=np.float32)
         # Matrix multiply DFT around the current shift estimate
         sample_region_offset = dftshift - shifts*upsample_factor

{impy_array-2.5.1 → impy_array-2.5.3}/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]:

{impy_array-2.5.1 → impy_array-2.5.3}/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_array-2.5.1 → impy_array-2.5.3}/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:

{impy_array-2.5.1 → impy_array-2.5.3}/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_array-2.5.1 → impy_array-2.5.3}/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_array-2.5.1 → impy_array-2.5.3}/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)