impy-array 2.5.0__tar.gz → 2.5.2__tar.gz

{impy_array-2.5.0 → impy_array-2.5.2}/PKG-INFO

@@ -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 → impy_array-2.5.2}/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_array-2.5.0 → impy_array-2.5.2}/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_array-2.5.0 → impy_array-2.5.2}/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.0 → impy_array-2.5.2}/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_array-2.5.0 → impy_array-2.5.2}/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.0 → impy_array-2.5.2}/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