impy-array 2.4.7__tar.gz → 2.4.8__tar.gz

{impy_array-2.4.7 → impy_array-2.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: impy-array
-Version: 2.4.7
+Version: 2.4.8
 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>
@@ -131,6 +131,7 @@ img_prj.imsave("image_max.tif")        # Save in the same place. Don't spend tim
 `impy` automatically chooses the proper reader/writer according to the extension.
 
 - Tiff file (".tif", ".tiff")
+- LSM file (".lsm")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 - Zarr file (".zarr")
 - ND2 file (".nd2")

{impy_array-2.4.7 → impy_array-2.4.8}/README.md

@@ -58,6 +58,7 @@ img_prj.imsave("image_max.tif")        # Save in the same place. Don't spend tim
 `impy` automatically chooses the proper reader/writer according to the extension.
 
 - Tiff file (".tif", ".tiff")
+- LSM file (".lsm")
 - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 - Zarr file (".zarr")
 - ND2 file (".nd2")

{impy_array-2.4.7 → impy_array-2.4.8}/impy/__init__.py

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

{impy_array-2.4.7 → impy_array-2.4.8}/impy/_const.py

@@ -8,13 +8,13 @@ MAX_GB_LIMIT = memory.total / 2 * 1e-9
 
 class GlobalConstant(MutableMapping[str, Any]):
     _const: dict[str, Any]
-    
+
     def __init__(self, **kwargs):
         object.__setattr__(self, "_const", dict(**kwargs))
-    
+
     def __len__(self) -> int:
         return len(self._const)
-    
+
     def __iter__(self):
         raise StopIteration
 
@@ -47,15 +47,15 @@ class GlobalConstant(MutableMapping[str, Any]):
                 dask.config.set(scheduler=v)
         else:
             raise RuntimeError("Cannot set new keys.")
-        
+
         self._const[k] = v
-    
+
     __getattr__ = __getitem__
     __setattr__ = __setitem__
 
     def __delitem__(self, v):
         raise RuntimeError("Cannot delete any items.")
-    
+
     def __repr__(self):
         return (
             f"""
@@ -65,12 +65,12 @@ class GlobalConstant(MutableMapping[str, Any]):
                 SCHEDULER   : {self['SCHEDULER']}
             """
         )
-    
+
     def asdict(self) -> dict[str, Any]:
         return self._const.copy()
 
 Const = GlobalConstant(
-    MAX_GB = MAX_GB_LIMIT/2,
+    MAX_GB = MAX_GB_LIMIT * 0.8,
     ID_AXIS = "N",
     RESOURCE = "numpy",
     SCHEDULER = "threads",
@@ -80,12 +80,12 @@ class SetConst:
     n_ongoing = 0
     _locked_keys: set[str] = set()
     _old_dict: dict[str, Any] = dict()
-    
+
     def __init__(self, dict_: dict[str, Any] | None =None, **kwargs):
         dict_ = dict_ or {}
         dict_.update(kwargs)
         self._kwargs = dict_
-    
+
     def __enter__(self):
         self.__class__.n_ongoing += 1
         if self.__class__.n_ongoing == 1:

{impy_array-2.4.7 → impy_array-2.4.8}/impy/arrays/imgarray.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 import warnings
+from functools import partial
+from itertools import product
+from typing import TYPE_CHECKING, Literal, Sequence, Iterable, Callable, overload, Any
+
 import numpy as np
 from numpy.typing import DTypeLike
-from functools import partial
 from scipy import ndimage as ndi
-from typing import TYPE_CHECKING, Literal, Sequence, Iterable, Callable, overload, Any
 
 from impy.arrays.labeledarray import LabeledArray
 from impy.arrays.label import Label
@@ -3987,8 +3989,7 @@ class ImgArray(LabeledArray):
         upsample_factor: int = 10,
         max_shift: nDFloat | None = None,
     ) -> MarkerFrame:
-        """
-        Calculate yx-directional drift using the method equivalent to
+        """Calculate yx-directional drift using the method equivalent to
         ``skimage.registration.phase_cross_correlation``.
 
         Parameters
@@ -4063,9 +4064,10 @@ class ImgArray(LabeledArray):
         dims: Dims = 2,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Drift correction using iterative Affine translation. If translation vectors ``shift``
-        is not given, then it will be determined using ``track_drift`` method of ImgArray.
+        """Drift correction using iterative Affine translation.
+
+        If translation vectors  ``shift`` is not given, then it will be determined using
+        ``track_drift`` method of ImgArray.
 
         Parameters
         ----------
@@ -4092,7 +4094,7 @@ class ImgArray(LabeledArray):
         Examples
         --------
         Drift correction of multichannel image using the first channel as the reference.
-            >>> img.drift_correction(ref=img["c=0"])
+        >>> img.drift_correction(ref=img["c=0"])
         """
 
         if along is None:
@@ -4107,7 +4109,6 @@ class ImgArray(LabeledArray):
             elif not isinstance(ref, ImgArray):
                 ref = self[ref]
             if ref.axes != [along] + dims:
-                from itertools import product
                 _c_axes = complement_axes([along] + dims, str(ref.axes))
                 fmt = slicer.get_formatter(_c_axes)
                 out = np.empty_like(self)

{impy_array-2.4.7 → impy_array-2.4.8}/impy/arrays/labeledarray.py

@@ -3,7 +3,7 @@ import numpy as np
 from pathlib import Path
 import itertools
 from functools import partial
-from typing import TYPE_CHECKING, Any, Sequence, MutableMapping, Protocol
+from typing import TYPE_CHECKING, Any, Literal, Sequence, MutableMapping, Protocol
 from warnings import warn
 from scipy import ndimage as ndi
 
@@ -23,7 +23,7 @@ from impy.array_api import xp
 
 if TYPE_CHECKING:
     from typing_extensions import Self
-    from numpy.typing import ArrayLike, DTypeLike
+    from numpy.typing import ArrayLike, DTypeLike, NDArray
     from impy.frame import PathFrame
     from impy.roi import RoiList
 
@@ -401,10 +401,18 @@ class LabeledArray(MetaArray):
         out._set_info(self)
         return out
 
-    def as_float(self) -> Self:
-        if self.dtype == np.float32:
+    def as_float(self, *, depth: int = 32) -> Self:
+        if depth == 16:
+            dtype = np.float16
+        elif depth == 32:
+            dtype = np.float32
+        elif depth == 64:
+            dtype = np.float64
+        else:
+            raise ValueError(f"depth must be 16, 32, or 64, but got {depth}")
+        if self.dtype == dtype:
             return self
-        out = self.value.astype(np.float32).view(self.__class__)
+        out = self.value.astype(dtype).view(self.__class__)
         out._set_info(self)
         return out
 
@@ -417,8 +425,12 @@ class LabeledArray(MetaArray):
             return self.as_uint16()
         elif dtype == "uint8":
             return self.as_uint8()
+        elif dtype == "float16":
+            return self.as_float(depth=16)
         elif dtype == "float32":
-            return self.as_float()
+            return self.as_float(depth=32)
+        elif dtype == "float64":
+            return self.as_float(depth=64)
         elif dtype == "bool":
             return self.astype("bool")
         elif dtype == "float64":
@@ -576,6 +588,7 @@ class LabeledArray(MetaArray):
         *,
         order: int = 3,
         prefilter: bool | None = None,
+        how: Literal["pack", "equal"] = "pack",
     ) -> PropArray:
         """
         Measure line profile (kymograph) iteratively for every slice of image. This
@@ -590,7 +603,12 @@ class LabeledArray(MetaArray):
             `a = [[y0, x0], [y1, x1], ..., [yn, xn]]`
         b : array-like, optional
             Destination coordinate. If specified, `a` must be the source coordinate.
-        {order}
+        {order}{prefilter}
+        how : "pack" or "equal", default "pack"
+            How to sample points on the line. "pack" means that the points are sampled
+            at 1-px interval from the start point. "equal" means that the points are
+            sampled equally at the interval larger but neareset to 1-px so that the
+            points covers the entire line.
 
         Returns
         -------
@@ -616,7 +634,12 @@ class LabeledArray(MetaArray):
         a = np.asarray(a, dtype=np.float32)
         _, ndim = a.shape
         seg = SegmentedLine(a)
-        coords = seg.sample_points().T
+        if how == "pack":
+            coords = np.stack(seg.arange(), axis=0)
+        elif how == "equal":
+            coords = np.stack(seg.linspace(int(seg.length())), axis=0)
+        else:
+            raise ValueError(f"No option matches how={how}")
 
         if ndim == self.ndim:
             dims = self.axes
@@ -632,7 +655,11 @@ class LabeledArray(MetaArray):
                         axes=c_axes+[new_axis], propname="reslice")
 
         out.set_scale(self)
-        out.set_scale({new_axis: self.scale[dims[-1]] * seg.interv})
+        axis = self.axes[dims[-1]]
+        if how == "equal":
+            out.set_scale({new_axis: axis.scale * seg.interv}, unit=axis.unit)
+        else:
+            out.set_scale({new_axis: axis.scale}, unit=axis.unit)
         return out
 
     @_docs.write_docs
@@ -1576,31 +1603,61 @@ class SegmentedLine:
         dist = np.sqrt(np.sum(vec**2, axis=1))
         dist_sum = np.sum(dist)
         npoints = int(dist_sum)
-        interv = dist_sum / npoints
+        self.interv = dist_sum / npoints
 
-        self.length = dist_sum
         self.vec = vec
         self.dist = dist
         self.nodes = nodes
-        self.interv = interv
 
     def sample_points(self) -> np.ndarray:
         res = 0
         out = [self.nodes[0:1]]
         npoints = 1
+        interv = self.length() / int(self.length())
         for v, d, p in zip(self.vec, self.dist, self.nodes[:-1]):
             res0 = res
-            d_int, res = divmod(d + res, self.interv)
-            idx = self.interv*(np.arange(d_int) + 1) - res0
+            d_int, res = divmod(d + res, interv)
+            idx = interv * (np.arange(d_int) + 1) - res0
             xs = idx[:, np.newaxis] * v[np.newaxis]/d + p
             out.append(xs)
             npoints += xs.shape[0]
 
-        if npoints <= int(self.length):
+        if npoints <= int(self.length()):
             out.append(self.nodes[-1:])
 
         return np.concatenate(out, axis=0)
 
+    def length(self) -> np.float64:
+        return np.sum(self.lengths())
+
+    def lengths(self) -> NDArray[np.float64]:
+        return np.sqrt(np.sum(np.diff(self.nodes, axis=0) ** 2, axis=1))
+
+    def linspace(self, num: int) -> tuple[NDArray[np.float64], ...]:
+        """Return a tuple of x and y coordinates of np.linspace along the line."""
+        tnots = np.cumsum(
+            np.concatenate([[0], self.lengths()], dtype=np.float64)
+        )
+        teval = np.linspace(0, tnots[-1], num)
+        return tuple(
+            np.interp(teval, tnots, self.nodes[:, i])
+            for i in range(self.nodes.shape[1])
+        )
+
+    def arange(
+        self, step: float = 1.0
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        tnots = np.cumsum(
+            np.concatenate([[0], self.lengths()], dtype=np.float64)
+        )
+        length = tnots[-1]
+        num, rem = divmod(length, step)
+        teval = np.linspace(0, length - rem, int(num + 1))
+        return tuple(
+            np.interp(teval, tnots, self.nodes[:, i])
+            for i in range(self.nodes.shape[1])
+        )
+
 def _count_list_depth(x) -> int:
     n = 0
     out = x

{impy_array-2.4.7 → impy_array-2.4.8}/impy/arrays/lazy.py

@@ -1612,10 +1612,18 @@ class LazyImgArray(AxesMixin):
         out._set_info(self)
         return out
 
-    def as_float(self) -> LazyImgArray:
-        if self.dtype == np.float32:
+    def as_float(self,  *, depth: int = 32) -> LazyImgArray:
+        if depth == 16:
+            dtype = np.float16
+        elif depth == 32:
+            dtype = np.float32
+        elif depth == 64:
+            dtype = np.float64
+        else:
+            raise ValueError(f"depth must be 16, 32, or 64, but got {depth}")
+        if self.dtype == dtype:
             return self
-        out = self.value.astype(np.float32)
+        out = self.value.astype(dtype)
         out = self.__class__(out)
         out._set_info(self)
         return out
@@ -1628,12 +1636,12 @@ class LazyImgArray(AxesMixin):
             return self.as_uint16()
         elif dtype == "uint8":
             return self.as_uint8()
+        elif dtype == "float16":
+            return self.as_float(depth=16)
         elif dtype == "float32":
-            return self.as_float()
+            return self.as_float(depth=32)
         elif dtype == "float64":
-            warn("Data type float64 is not valid for images. It was converted to float32 instead",
-                 UserWarning)
-            return self.as_float()
+            return self.as_float(depth=64)
         elif dtype == "complex64":
             out = self.value.astype(np.complex64)
             out = self.__class__(out)

{impy_array-2.4.7 → impy_array-2.4.8}/impy/core.py

@@ -99,8 +99,7 @@ def array(
     axes: str = None,
     like: MetaArray | None = None,
 ) -> ImgArray:
-    """
-    make an ImgArray object, like ``np.array(x)``
+    """Make an ImgArray object, like ``np.array(x)``
 
     Parameters
     ----------
@@ -116,12 +115,7 @@ def array(
 
     """
     if isinstance(arr, np.ndarray) and dtype is None:
-        if arr.dtype in (np.uint8, np.uint16, np.float32):
-            dtype = arr.dtype
-        elif arr.dtype.kind == "f":
-            dtype = np.float32
-        else:
-            dtype = arr.dtype
+        dtype = arr.dtype
 
     axes, name = _normalize_params(axes, name, like)
 
@@ -150,8 +144,7 @@ def asarray(
     axes: str | None = None,
     like: MetaArray | None = None,
 ) -> ImgArray:
-    """
-    make an ImgArray object, like ``np.asarray(x)``
+    """Make an ImgArray object, like ``np.asarray(x)``
 
     Parameters
     ----------
@@ -296,9 +289,8 @@ def _inject_numpy_function(func: Callable[_P, Any | None]) -> Callable[_P, ImgAr
         return asarray(npfunc(*args, **kwargs), name=name, axes=axes, like=like)
 
     _func.__doc__ = (
-        f"""
-        impy version of numpy.{func.__name__}. This function has additional parameters ``axes``
-        and ``name``. Original docstring follows.
+        f"""impy version of numpy.{func.__name__}. This function has additional
+        parameters ``axes`` and ``name``. Original docstring follows.
 
         Additional Parameters
         ---------------------
@@ -396,7 +388,7 @@ def gaussian_kernel(
     """
     if np.isscalar(sigma):
         sigma = (sigma,)*len(shape)
-    g = gauss.GaussianParticle([(np.array(shape)-1)/2, sigma, peak, 0])
+    g = gauss.GaussianParticle([(np.array(shape) - 1) / 2, sigma, peak, 0])
     ker = g.generate(shape)
     ker = array(ker, name=name or "Gaussian-Kernel", axes=axes)
     if axes is None and ker.ndim == 3:
@@ -551,12 +543,12 @@ def imread(
         return _imread_stack(path, dtype=dtype, key=key, squeeze=squeeze)
     elif "*" in path:
         return _imread_glob(path, dtype=dtype, key=key, squeeze=squeeze)
-    elif not os.path.exists(path):
+    elif not Path(path).exists():
         raise FileNotFoundError(f"No such file or directory: {path}")
 
     # read tif metadata
     if not is_memmap:
-        size = os.path.getsize(path) / 2**30
+        size = Path(path).stat().st_size / 2**30
         if size > Const["MAX_GB"]:
             raise MemoryError(f"Too large {size:.2f} GB")
 

{impy_array-2.4.7 → impy_array-2.4.8}/impy/io/_mrc.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 import warnings
 import os
@@ -59,7 +60,13 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
 
     if img.dtype == "bool":
         img = img.astype(np.int8)
-
+    elif img.dtype == "float64":
+        warnings.warn(
+            "MRC format does not support float64. Converting to float32.",
+            UserWarning,
+            stacklevel=2,
+        )
+        img = img.astype(np.float32)
     if lazy:
         from dask import array as da
 
@@ -75,9 +82,10 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
     # 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 os.path.exists(path):
+            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
@@ -98,13 +106,12 @@ _MRC_MODE = {
 }
 
 def _parse_mrcfile(mrc: MrcObject) -> ImageMetadata:
-    ndim = len(mrc.voxel_size.item())
-    if ndim == 3:
-        axes = "zyx"
-    elif ndim == 2:
+    if mrc.is_single_image():
         axes = "yx"
+    elif mrc.is_volume_stack():
+        axes = "tzyx"
     else:
-        raise RuntimeError(f"ndim = {ndim} not supported")
+        axes = "zyx"
 
     scale = dict.fromkeys(axes, 1.0)
     for a in axes:

{impy_array-2.4.7 → impy_array-2.4.8}/impy/io/_tiff.py

@@ -14,7 +14,7 @@ from impy.utils.axesop import complement_axes
 if TYPE_CHECKING:
     from tifffile import TiffFile
 
-@IO.mark_reader(".tif", ".tiff")
+@IO.mark_reader(".tif", ".tiff", ".lsm")
 def _(path: str, memmap: bool = False) -> ImageData:
     """The tif file reader."""
     from tifffile import TiffFile
@@ -28,7 +28,7 @@ def _(path: str, memmap: bool = False) -> ImageData:
 
     return ImageData.from_metadata(image, meta)
 
-@IO.mark_header_reader(".tif", ".tiff")
+@IO.mark_header_reader(".tif", ".tiff", ".lsm")
 def _(path: str) -> ImageMetadata:
     """The tif header reader."""
     from tifffile import TiffFile
@@ -39,7 +39,7 @@ def _(path: str) -> ImageMetadata:
     return meta
 
 
-@IO.mark_writer(".tif", ".tiff")
+@IO.mark_writer(".tif", ".tiff", ".lsm")
 def _(path: str, img: ImpyArray, lazy: bool = False):
     """The TIFF writer."""
     from tifffile import imwrite, memmap
@@ -103,7 +103,7 @@ def _parse_tifffile(tif: TiffFile) -> ImageMetadata:
     tags = {v.name: v.value for v in pagetag.values()}
 
     labels = ijmeta.get("Labels")
-    scale = dict()
+    scale: dict[str, float] = {}
     dz = ijmeta.get("spacing", 1.0)
     scale_unit: dict[str, float] = {}
     try:
@@ -133,9 +133,9 @@ def _parse_tifffile(tif: TiffFile) -> ImageMetadata:
     _unit = ijmeta.pop("unit", None)
     for k in scale.keys():
         scale_unit[k] = _unit
-    if tif.is_ome:
+    if ome_meta := tif.ome_metadata:
         try:
-            xml = xml2dict(tif.ome_metadata)
+            xml = xml2dict(ome_meta)
             meta_data: dict[str, Any] = xml["OME"]["Image"]
             if isinstance(meta_data, list):
                 meta_data = meta_data[0]
@@ -156,6 +156,14 @@ def _parse_tifffile(tif: TiffFile) -> ImageMetadata:
 
         except Exception:
             pass
+    if lsm_meta := tif.lsm_metadata:
+        scale_unit = "μm"
+        if voxel_size_x := lsm_meta.get("VoxelSizeX"):
+            scale["x"] = voxel_size_x * 1e6
+        if voxel_size_y := lsm_meta.get("VoxelSizeY"):
+            scale["y"] = voxel_size_y * 1e6
+        if voxel_size_z := lsm_meta.get("VoxelSizeZ"):
+            scale["z"] = voxel_size_z * 1e6
 
     return ImageMetadata(
         axes=axes,
@@ -188,7 +196,7 @@ def _get_ijmeta_from_img(img: ImpyArray, update_lut=True):
         info = {}
     metadata["Info"] = str(info)
     scale_unit = img.scale_unit
-    if scale_unit[0] in ("μ", "\xb5", "\xc2"):
+    if scale_unit and scale_unit[0] in ("μ", "\xb5", "\xc2"):
         scale_unit = "\\u00B5" + scale_unit[1:]
     metadata["unit"] = scale_unit
 

{impy_array-2.4.7 → impy_array-2.4.8}/impy/lazy/core.py

@@ -108,8 +108,7 @@ def array(
     axes: str = None,
     like: MetaArray | None = None,
 ) -> LazyImgArray:
-    """
-    make an LazyImgArray object, like ``np.array(x)``
+    """Make an LazyImgArray object, like ``np.array(x)``
 
     Parameters
     ----------
@@ -144,12 +143,7 @@ def array(
         arr = da.asarray(arr)
 
     if isinstance(arr, np.ndarray) and dtype is None:
-        if arr.dtype in (np.uint8, np.uint16, np.float32):
-            dtype = arr.dtype
-        elif arr.dtype.kind == "f":
-            dtype = np.float32
-        else:
-            dtype = arr.dtype
+        dtype = arr.dtype
 
     axes, name = _normalize_params(axes, name, like)
 
@@ -172,8 +166,7 @@ def asarray(
     like: MetaArray | None = None,
     chunks="auto",
 ) -> LazyImgArray:
-    """
-    make an LazyImgArray object, like ``np.asarray(x)``
+    """Make an LazyImgArray object, like ``np.asarray(x)``
 
     Parameters
     ----------

{impy_array-2.4.7 → impy_array-2.4.8}/impy/random.py

@@ -127,7 +127,7 @@ class ImageGenerator:
     def standard_normal(
         self,
         size: int | tuple[int, ...] | None = None,
-        dtype = None,
+        dtype=np.float32,
         *,
         axes: AxesLike | None = None,
         name: str | None = None,
@@ -142,7 +142,7 @@ class ImageGenerator:
     def standard_exponential(
         self,
         size: int | tuple[int, ...] | None = None,
-        dtype = None,
+        dtype=np.float32,
         method: Literal["zig", "inv"] = None,
         *,
         axes: AxesLike | None = None,
@@ -159,7 +159,7 @@ class ImageGenerator:
     def random(
         self,
         size: int | tuple[int, ...] | None = None,
-        dtype = None,
+        dtype=np.float32,
         *,
         axes: AxesLike | None = None,
         name: str | None = None,
@@ -184,7 +184,7 @@ class ImageGenerator:
     ) -> ImgArray:
         size, name, axes = _normalize_like(size, name, axes, like)
 
-        arr = self._rng.normal(loc=loc, scale=scale, size=size)
+        arr = self._rng.normal(loc=loc, scale=scale, size=size).astype(np.float32)
         if np.isscalar(arr):
             return arr
         return asarray(xp.asnumpy(arr), axes=axes, name=name)

{impy_array-2.4.7 → impy_array-2.4.8}/impy/utils/gauss.py

@@ -19,7 +19,10 @@ def diagonal_gaussian(r, *params):
     ndim = len(params[:-2])//2
     mu = params[:ndim]
     sg = params[ndim:-2]
-    z_value = np.array([(x0 - mu0)/sg0 for x0, mu0, sg0 in zip(r, mu, sg)])
+    z_value = np.array(
+        [(x0 - mu0) / sg0 for x0, mu0, sg0 in zip(r, mu, sg)],
+        dtype=np.float32
+    )
     return a * np.exp(-np.sum(z_value**2, axis=0) / 2) + b
 
 class Gaussian: