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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: impy-array
-Version: 2.4.6
+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.6 → 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.6 → impy_array-2.4.8}/impy/__init__.py

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

{impy_array-2.4.6 → 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.6 → impy_array-2.4.8}/impy/arrays/_utils/_corr.py

@@ -34,7 +34,7 @@ def subpixel_pcc(
     f0: np.ndarray,
     f1: np.ndarray,
     upsample_factor: int,
-    max_shifts: tuple[float, ...] | None = None,
+    max_shifts: float | tuple[float, ...] | None = None,
 ):
     power, product = _pcc_and_power_spec(f0, f1, max_shifts)
     maxima = xp.unravel_index(xp.argmax(power), power.shape)
@@ -60,6 +60,8 @@ def subpixel_pcc(
         power = abs2(cross_correlation)
 
         if max_shifts is not None:
+            if np.isscalar(max_shifts):
+                max_shifts = (max_shifts,) * f0.ndim
             max_shifts = xp.asarray(max_shifts)
             _upsampled_left_shifts = (shifts + max_shifts) * upsample_factor
             _upsampled_right_shifts = (max_shifts - shifts) * upsample_factor

{impy_array-2.4.6 → impy_array-2.4.8}/impy/arrays/_utils/_skimage.py

@@ -6,8 +6,19 @@ from functools import reduce, lru_cache
 
 # same as the function in skimage.filters._fft_based (available in scikit-image >= 0.19)
 @lru_cache(maxsize=4)
-def _get_ND_butterworth_filter(shape: tuple[int, ...], cutoff: float, order: int, 
-                               high_pass: bool, real: bool):
+def _get_ND_butterworth_filter(
+    shape: tuple[int, ...],
+    cutoff: float,
+    order: int,
+    high_pass: bool,
+    real: bool,
+):
+    if cutoff == 0:
+        if high_pass:
+            wfilt = np.ones(shape, dtype=np.float32)
+        else:
+            wfilt = np.zeros(shape, dtype=np.float32)
+        return wfilt
     ranges = []
     for d, fc in zip(shape, cutoff):
         axis = np.arange(-(d - 1) // 2, (d - 1) // 2 + 1, dtype=np.float32) / (d*fc)
@@ -19,4 +30,4 @@ def _get_ND_butterworth_filter(shape: tuple[int, ...], cutoff: float, order: int
     wfilt = 1 / (1 + q2**order)
     if high_pass:
         wfilt = 1 - wfilt
-    return wfilt
+    return wfilt

{impy_array-2.4.6 → 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
@@ -247,12 +249,11 @@ class ImgArray(LabeledArray):
             cval = cval(self.value)
 
         prefilter = prefilter or order > 1
-        mtx = _transform.compose_affine_matrix(translation=translation)
 
         return self._apply_dask(
-            _transform.warp,
+            _transform.shift,
             c_axes=complement_axes(dims, self.axes),
-            kwargs=dict(matrix=mtx, order=order, mode=mode, cval=cval,
+            kwargs=dict(shift=translation, order=order, mode=mode, cval=cval,
                         prefilter=prefilter)
         )
 
@@ -3986,9 +3987,9 @@ class ImgArray(LabeledArray):
         along: AxisLike | None = None,
         show_drift: bool = False,
         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
@@ -3999,6 +4000,8 @@ class ImgArray(LabeledArray):
             If True, plot the result.
         upsample_factor : int, default is 10
             Up-sampling factor when calculating phase cross correlation.
+        max_shift : tuple of float, optional
+            Maximum shift in spatial directions.
 
         Returns
         -------
@@ -4013,7 +4016,9 @@ class ImgArray(LabeledArray):
             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:
+            if np.isscalar(max_shift):
+                max_shift = np.full(self.ndim - 1, max_shift)
         result = np.zeros((self.sizeof(along), self.ndim-1), dtype=np.float32)
         c_axes = complement_axes(along, self.axes)
         last_img = None
@@ -4022,7 +4027,12 @@ class ImgArray(LabeledArray):
             img = xp.asarray(img)
             if last_img is not None:
                 result[i] = xp.asnumpy(
-                    _corr.subpixel_pcc(last_img, img, upsample_factor=upsample_factor)[0]
+                    _corr.subpixel_pcc(
+                        last_img,
+                        img,
+                        max_shifts=max_shift,
+                        upsample_factor=upsample_factor,
+                    )[0]
                 )
                 last_img = img
             else:
@@ -4047,15 +4057,17 @@ class ImgArray(LabeledArray):
         *,
         zero_ave: bool = True,
         along: AxisLike | None = None,
+        max_shift: nDFloat | None = None,
         order: int = 1,
         mode: str = "constant",
         cval: float = 0,
         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
         ----------
@@ -4082,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:
@@ -4097,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)
@@ -4109,7 +4120,7 @@ class ImgArray(LabeledArray):
                     )
                 return out
 
-            shift = ref.track_drift(along=along).values
+            shift = ref.track_drift(along=along, max_shift=max_shift).values
 
         else:
             shift = np.asarray(shift, dtype=np.float32)

{impy_array-2.4.6 → 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