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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: impy-array
-Version: 2.4.10
+Version: 2.5.1
 Summary: Speed up coding/extending image analysis in Python.
 Project-URL: Download, https://github.com/hanjinliu/impy
 Author-email: Hanjin Liu <liuhanjin-sc@g.ecc.u-tokyo.ac.jp>

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

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

{impy_array-2.4.10 → impy_array-2.5.1}/impy/arrays/_utils/_misc.py

@@ -93,3 +93,17 @@ def inpaint_mean(img: np.ndarray, mask: np.ndarray):
         border = expanded_i ^ mask_i
         out[mask_i] = xp.mean(img[border])
     return out
+
+
+def fft_crop(freq: np.ndarray, new_shape: tuple[int, ...]) -> np.ndarray:
+    """Crop the Fourier transformed array to the new_shape."""
+    cur_freq = freq
+    for i, (n, s) in enumerate(zip(new_shape, freq.shape)):
+        if i != len(new_shape) - 1:
+            # rfftn non last axis
+            left = n // 2
+            right = s - left
+            cur_freq = np.concatenate([cur_freq[:left], cur_freq[right:]], axis=i)
+        else:
+            cur_freq = cur_freq[..., :n]
+    return cur_freq

{impy_array-2.4.10 → impy_array-2.5.1}/impy/arrays/axesmixin.py

@@ -24,28 +24,28 @@ if TYPE_CHECKING:
 
 class AxesMixin:
     """Abstract class with shape, ndim and axes are defined."""
-    
+
     _INHERIT = object()
     _axes: Axes
     ndim: int
     shape: tuple[int, ...]
     dtype: np.dtype
     value: Any
-    
+
     @property
     def shape_info(self) -> str:
         shape_info = ", ".join([f"{s}({o})" for s, o in zip(self.shape, self.axes)])
         return shape_info
-    
+
     @property
     def spatial_shape(self) -> tuple[int, ...]:
         return tuple(self.sizeof(a) for a in "zyx" if a in self.axes)
-    
+
     @property
     def axes(self) -> Axes:
         """Axes of the array."""
         return self._axes
-    
+
     @axes.setter
     def axes(self, value: Iterable[AxisLike] | None):
         if value is None:
@@ -58,7 +58,7 @@ class AxesMixin:
                     f"array (ndim={self.ndim}) and axes ({value})"
                 )
             self._axes = axes
-    
+
     @property
     def metadata(self) -> dict[str, Any]:
         raise NotImplementedError()
@@ -66,16 +66,16 @@ class AxesMixin:
     @property
     def scale(self) -> ScaleView:
         return self.axes.scale
-    
+
     @scale.setter
     def scale(self, value: dict):
         if not isinstance(value, dict):
             raise TypeError(f"Cannot set scale using {type(value)}.")
         return self.set_scale(value)
-    
+
     @property
     def scale_unit(self) -> str:
-        units = set(a.unit for a in self.axes if str(a) in "zyx")
+        units = {a.unit for a in self.axes if str(a) in "zyx"}
         if len(units) == 0:
             return self.axes[-1].unit
         elif len(units) == 1:
@@ -83,21 +83,21 @@ class AxesMixin:
         else:
             warn(f"Inconsistent spatial unit: {units}.")
             return list(units)[-1]
-    
+
     @scale_unit.setter
     def scale_unit(self, unit) -> None:
         unit = str(unit)
         for a in self.axes:
             if str(a) in ["z", "y", "x"]:
                 a.unit = unit
-    
+
     def _repr_dict_(self) -> dict[str, Any]:
         raise NotImplementedError()
-        
+
     def __repr__(self) -> str:
         info = "\n".join(f"{k:^16}: {v}" for k, v in self._repr_dict_().items())
         return f"{self.__class__.__name__} of\n{info}\n"
-    
+
     def _repr_html_(self) -> str:
         strs = []
         for k, v in self._repr_dict_().items():
@@ -128,23 +128,22 @@ class AxesMixin:
             return symbol
         else:
             return self.axes.find(symbol)
-    
-    
+
+
     def sizeof(self, axis: AxisLike) -> int:
         return getattr(self.shape, str(axis))
-    
+
     def sizesof(self, axes: str) -> tuple[int, ...]:
         return tuple(self.sizeof(a) for a in axes)
-    
+
     def set_axes(self, axes) -> Self:
-        """
-        Set axes of the array and return the updated one.
+        """Set axes of the array and return the updated one.
 
         Parameters
         ----------
         axes : AxesLike
             New axes.
-        
+
         Returns
         -------
         Self
@@ -164,10 +163,10 @@ class AxesMixin:
             scales of common axes are copied.
         unit : str, optional
             Scale unit if needs update.
-        kwargs : 
+        kwargs :
             This enables function call like set_scale(x=0.1, y=0.1).
-        """        
-        
+        """
+
         if isinstance(other, MutableMapping):
             # voxel-scale can be set with one keyword.
             if "zyx" in other:
@@ -186,21 +185,23 @@ class AxesMixin:
             # 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.axes[k].scale = v
-            
+
         elif kwargs:
             self.set_scale(dict(kwargs))
-        
+
         elif hasattr(other, "scale"):
             self.set_scale(
                 {a: s for a, s in other.scale.items() if a in self.axes}  # type: ignore
             )
-        
+            if unit is None and hasattr(other, "scale_unit"):
+                unit = other.scale_unit
+
         elif isinstance(other, (list, tuple)):
             for a, s in zip(self.axes, other):
                 a.scale = s
@@ -208,27 +209,26 @@ class AxesMixin:
             raise TypeError(
                 f"'other' must be str or axes supported object, but got {type(other)}"
             )
-        
+
         if unit is not None:
             self.scale_unit = unit
-        
+
         return self
-    
+
     def set_axis_label(
         self,
         _dict: MutableMapping[str, Iterable[Any]] = None,
         /,
         **kwargs
     ) -> Self:
-        """
-        Set labels to an axis (axes).
+        """Set labels to an axis (axes).
 
         Parameters
         ----------
         _dict : mapping, optional
             Mapping from axis to its labels. Labels must have the same length as its
             dimensionality.
-            
+
         Examples
         --------
         >>> img.set_axis_label(c=["Blue", "Green", "Red"])
@@ -242,31 +242,32 @@ class AxesMixin:
         for k, v in _dict.items():
             self.axes[self.axes.find(k)].labels = v
         return self
-    
+
     @overload
     def iter(
         self,
         axes: AxesLike,
-        israw: Literal[False] = False, 
+        israw: Literal[False] = False,
         exclude: Dims = "",
     ) -> Iterator[tuple[Slices, np.ndarray]]:
         ...
-    
+
     @overload
     def iter(
         self,
         axes: AxesLike,
-        israw: Literal[True] = False, 
+        israw: Literal[True] = False,
         exclude: Dims = "",
     ) -> Iterator[tuple[Slices, Self]]:
         ...
-    
+
     def iter(self, axes, israw = False, exclude = ""):
-        """
-        Iteration along axes. If axes="tzc", then equivalent to following pseudo code:
-        
+        """Iteration along axes.
+
+        If axes="tzc", then equivalent to following pseudo code:
+
             .. code-block::
-            
+
                 for t in all_t:
                     for z in all_z:
                         for c in all_c:
@@ -279,19 +280,19 @@ class AxesMixin:
         israw : bool, default is False
             If True, MetaArray will be returned. If False, np.ndarray will be returned.
         exclude : str, optional
-            Which axes will be excluded in output. For example, self.axes="tcyx" and 
-            exclude="c" then the axes of output will be "tyx" and slice is also correctly 
+            Which axes will be excluded in output. For example, self.axes="tcyx" and
+            exclude="c" then the axes of output will be "tyx" and slice is also correctly
             arranged.
-            
+
         Yields
         -------
         slice and (np.ndarray or AxesMixin)
             slice and a subimage=self[sl]
-        """     
+        """
         iterlist = switch_slice(
-            axes=axes, 
+            axes=axes,
             all_axes=self.axes,
-            ifin=[range(s) for s in self.shape], 
+            ifin=[range(s) for s in self.shape],
             ifnot=[(slice(None),)] * self.ndim
         )
         exclude = list(exclude)
@@ -302,11 +303,11 @@ class AxesMixin:
             if len(exclude) == 0:
                 outsl = sl
             else:
-                outsl = tuple(s for i, s in enumerate(sl) 
+                outsl = tuple(s for i, s in enumerate(sl)
                               if self.axes[i] not in exclude)
             yield outsl, selfview[sl]
             c += 1
-            
+
         # if iterlist = []
         if c == 0:
             outsl = (slice(None),) * (self.ndim - len(exclude))
@@ -342,4 +343,4 @@ def _getitem(self: NamedTuple, key: slice) -> tuple[int, ...]:
 def _getitem(self: NamedTuple, key, /):
     if isinstance(key, (str, Axis)):
         return self._asdict()[key]
-    return tuple.__getitem__(self, key)
+    return tuple.__getitem__(self, key)

{impy_array-2.4.10 → impy_array-2.5.1}/impy/arrays/bases/metaarray.py

@@ -170,8 +170,7 @@ class MetaArray(AxesMixin, np.ndarray):
         return self[tuple(slices)]
 
     def isel(self, indexer=None, /, **kwargs: dict[str, Any]) -> Self:
-        """
-        A index based indexing method, mimicking ``xarray.isel``.
+        """A index based indexing method, mimicking ``xarray.isel``.
 
         Example
         -------
@@ -259,9 +258,7 @@ class MetaArray(AxesMixin, np.ndarray):
 
     @classmethod
     def implements(cls, numpy_function):
-        """
-        Add functions to NP_DISPATCH so that numpy functions can be overloaded.
-        """
+        """Add functions to NP_DISPATCH so that numpy functions can be overloaded."""
         def decorator(func):
             cls.NP_DISPATCH[numpy_function] = func
             func.__name__ = numpy_function.__name__

{impy_array-2.4.10 → impy_array-2.5.1}/impy/arrays/imgarray.py

@@ -340,7 +340,7 @@ class ImgArray(LabeledArray):
     def binning(
         self,
         binsize: int = 2,
-        method = "mean",
+        method: str | Callable[[np.ndarray], Any] = "mean",
         *,
         check_edges: bool = True,
         dims: Dims = None
@@ -390,6 +390,54 @@ class ImgArray(LabeledArray):
         )
         return out
 
+    @_docs.write_docs
+    @dims_to_spatial_axes
+    @same_dtype
+    def fourier_crop(
+        self,
+        binsize: float = 2,
+        dims: Dims = None,
+    ) -> ImgArray:
+        """Crop image in Fourier space.
+
+        Parameters
+        ----------
+        binsize : float, default is 2
+            Crop factor. If 2, the output image will have half the shape of the input
+            image.
+        {dims}
+
+        Returns
+        -------
+        ImgArray
+            Cropped image.
+        """
+        if binsize == 1:
+            return self
+        if binsize < 1:
+            raise ValueError("`binsize` must be 1 or larger.")
+        new_shape = list(self.shape)
+        new_scale = dict(self.scale)
+        for i, a in enumerate(self.axes):
+            if a in dims:
+                new_shape[i] = int(self.shape[i] / binsize)
+                new_scale[a] = self.scale[a] * binsize
+        spatial_axes = [self.axisof(a) for a in dims]
+        input = xp.asarray(self.value)
+
+        out = xp.fft.irfftn(
+            _misc.fft_crop(xp.fft.rfftn(input, axes=spatial_axes), new_shape),
+            s=new_shape,
+            axes=spatial_axes,
+        )
+        out = xp.asnumpy(out)
+
+        out_img = out.view(self.__class__)
+        out_img._set_info(self)
+        out_img.axes = self.axes.copy()  # _set_info does not pass copy so new axes must be defined here.
+        out_img.set_scale(new_scale)
+        return out_img
+
     @_docs.write_docs
     @dims_to_spatial_axes
     def radial_profile(
@@ -4063,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:
@@ -4074,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(
@@ -4150,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.4.10 → impy_array-2.5.1}/impy/arrays/labeledarray.py

@@ -273,8 +273,7 @@ class LabeledArray(MetaArray):
         dtype: DTypeLike = None,
         overwrite: bool = True,
     ) -> None:
-        """
-        Save image at the same directory as the original image by default.
+        """Save image at the same directory as the original image by default.
 
         For tif file format, if the image contains wrong axes for ImageJ (= except for tzcyx),
         then it will converted automatically if possible. For mrc file format, only zyx and yx is
@@ -290,7 +289,7 @@ class LabeledArray(MetaArray):
             Whether to overwrite the file if it already exists.
 
         """
-        save_path = Path(save_path)
+        save_path = Path(save_path).expanduser()
         if self.ndim < 2:
             raise ValueError("Cannot save <2D array as an image.")
 
@@ -310,7 +309,7 @@ class LabeledArray(MetaArray):
                     " >>> 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():

{impy_array-2.4.10 → impy_array-2.5.1}/impy/arrays/lazy.py

@@ -339,7 +339,7 @@ class LazyImgArray(AxesMixin):
 
     @_docs.copy_docs(LabeledArray.imsave)
     def imsave(self, save_path: str | Path, *, dtype = None, overwrite: bool = True):
-        save_path = Path(save_path)
+        save_path = Path(save_path).expanduser()
         if self.ndim < 2:
             raise ValueError("Cannot save <2D array as an image.")
 
@@ -776,12 +776,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 +796,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 +1319,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 +1370,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 +1385,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.4.10 → impy_array-2.5.1}/impy/core.py

@@ -501,9 +501,8 @@ def imread(
     name: str | None = None,
     squeeze: bool = False,
 ) -> ImgArray:
-    """
-    Load image(s) from a path. You can read list of images from directories with
-    wildcards or ``"$"`` in ``path``.
+    """Load image(s) from a path.
+    You can read list of images from directories with wildcards or ``"$"`` in ``path``.
 
     Parameters
     ----------
@@ -536,7 +535,7 @@ def imread(
         Wall time: 3.01 ms
 
     """
-    path = str(path)
+    path = str(Path(path).expanduser())
     is_memmap = (key is not None)
 
     if "$" in path:
@@ -593,11 +592,10 @@ def imread(
                 if k in "zyx":
                     self.axes[k].unit = scale_unit[k]
 
-    return self.sort_axes().as_img_type(dtype) # arrange in tzcyx-order
+    return self.as_img_type(dtype) # arrange in tzcyx-order
 
 def _imread_glob(path: str, squeeze: bool = False, **kwargs) -> ImgArray:
-    """
-    Read images recursively from a directory, and stack them into one ImgArray.
+    """Read images recursively from a directory, and stack them into one ImgArray.
 
     Parameters
     ----------

{impy_array-2.4.10 → impy_array-2.5.1}/impy/io/_mrc.py

@@ -7,12 +7,10 @@ import numpy as np
 from impy.io._registry import IO
 from impy.io._utils import rechunk_to_ones, MemmapArrayWriter, ImpyArray, ImageData, ImageMetadata
 
-from impy.axes import ImageAxesError
-
 if TYPE_CHECKING:
     from mrcfile.mrcobject import MrcObject
 
-@IO.mark_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz")
+@IO.mark_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz", ".mrcs")
 def _(path: str, memmap: bool = False) -> ImageData:
     """The MRC format reader"""
     import mrcfile
@@ -29,7 +27,7 @@ def _(path: str, memmap: bool = False) -> ImageData:
     return ImageData.from_metadata(image, meta)
 
 
-@IO.mark_header_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz")
+@IO.mark_header_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz", ".mrcs")
 def _(path: str) -> ImageData:
     """The MRC header reader"""
     import mrcfile
@@ -39,12 +37,14 @@ def _(path: str) -> ImageData:
 
     return meta
 
-@IO.mark_writer(".mrc", ".rec", ".st", ".map")
+@IO.mark_writer(".mrc", ".rec", ".st", ".map", ".mrcs")
 def _(path: str, img: ImpyArray, lazy: bool = False):
     """The MRC writer."""
 
     import mrcfile
 
+    input_axes = [str(a) for a in img.axes]
+
     if img.scale_unit == "nm":
         voxel_size = tuple(np.array(img.scale)[::-1] * 10)
     elif img.scale_unit in ("ang", "Å", "angstrom"):
@@ -56,6 +56,8 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         voxel_size = (1.0, 1.0, 1.0)
     if len(voxel_size) == 2:
         voxel_size = (1.0,) + voxel_size
+    elif len(voxel_size) > 3:
+        voxel_size = voxel_size[:3]
 
     if img.dtype == "bool":
         img = img.astype(np.int8)
@@ -79,20 +81,16 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
         return None
 
     # get voxel_size
-    if img.axes not in ("zyx", "yx"):
-        raise ImageAxesError(
-            f"Can only save zyx- or yx- image as a mrc file, but image has {img.axes} "
-            "axes."
-        )
     if Path(path).exists():
-        with mrcfile.open(path, mode="r+") as mrc:
-            mrc.set_data(img.value)
-            mrc.voxel_size = voxel_size
-
+        ctx_mgr = mrcfile.open(path, mode="r+")
     else:
-        with mrcfile.new(path) as mrc:
-            mrc.set_data(img.value)
-            mrc.voxel_size = voxel_size
+        ctx_mgr = mrcfile.new(path)
+    with ctx_mgr as mrc:
+        mrc.set_data(img.value)
+        mrc.voxel_size = voxel_size
+        if input_axes == ["t", "y", "x"]:
+            mrc.set_image_stack()
+
     return None
 
 _MRC_MODE = {
@@ -115,7 +113,11 @@ def _parse_mrcfile(mrc: MrcObject) -> ImageMetadata:
     metadata = {}
     scale = dict.fromkeys(axes, 1.0)
     for a in axes:
-        scale[a] = mrc.voxel_size[a] / 10
+        if a in "zyx":
+            this_scale = mrc.voxel_size[a] / 10
+            if this_scale == 0:
+                this_scale = 1.0
+            scale[a] = this_scale
     try:
         orig_x, orig_y, orig_z = mrc.header["origin"].item()
     except Exception:

{impy_array-2.4.10 → impy_array-2.5.1}/impy/lazy/core.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from pathlib import Path
 import re
 import glob
 from typing import TYPE_CHECKING, Any, Callable, Sequence
@@ -244,7 +245,7 @@ def imread(
     -------
     LazyImgArray
     """
-    path = str(path)
+    path = str(Path(path).expanduser())
     if "*" in path:
         return _imread_glob(path, chunks=chunks, squeeze=squeeze)
     if not os.path.exists(path):
@@ -277,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: