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

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

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

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

{impy_array-2.4.8 → impy_array-2.4.10}/impy/arrays/_utils/_filters.py

@@ -52,6 +52,8 @@ binary_closing = get_func("binary_closing")
 closing = get_func("grey_closing")
 gaussian_filter = get_func("gaussian_filter")
 median_filter = get_func("median_filter")
+min_filter = get_func("minimum_filter")
+max_filter = get_func("maximum_filter")
 spline_filter = get_func("spline_filter")
 convolve = get_func("convolve")
 white_tophat = get_func("white_tophat")
@@ -69,6 +71,8 @@ if TYPE_CHECKING:
     closing = scipy_ndi.grey_closing
     gaussian_filter = scipy_ndi.gaussian_filter
     median_filter = scipy_ndi.median_filter
+    min_filter = scipy_ndi.minimum_filter
+    max_filter = scipy_ndi.maximum_filter
     spline_filter = scipy_ndi.spline_filter
     convolve = scipy_ndi.convolve
     white_tophat = scipy_ndi.white_tophat
@@ -151,7 +155,8 @@ def gabor_filter(img: np.ndarray, ker: np.ndarray, mode="reflect", cval=0.0):
 
 def skeletonize(img, selem):
     from skimage import morphology
-    skl = morphology.skeletonize_3d(img)
+
+    skl = morphology.skeletonize(img)
     if selem is not None:
         skl = morphology.binary_dilation(skl, selem)
     return skl

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

@@ -708,8 +708,7 @@ class ImgArray(LabeledArray):
     @dims_to_spatial_axes
     @check_input_and_output
     def structure_tensor_eig(self, sigma: nDFloat = 1, *, dims: Dims = None)-> tuple[ImgArray, ImgArray]:
-        """
-        Calculate structure tensor's eigenvalues and eigenvectors.
+        """Calculate structure tensor's eigenvalues and eigenvectors.
 
         Parameters
         ----------
@@ -749,8 +748,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False
     ) -> ImgArray:
-        """
-        Sobel filter. This filter is useful for edge detection.
+        """Edge detection such as Sobel filter.
 
         Parameters
         ----------
@@ -785,8 +783,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Butterworth low-pass filter.
+        """Butterworth low-pass filter.
 
         Parameters
         ----------
@@ -831,9 +828,10 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False
     ) -> ImgArray:
-        """
-        Butterworth low-pass filter in real space. Butterworth kernel is created first using inverse
-        Fourier transform of weight function.
+        """Butterworth low-pass filter in real space.
+
+        Butterworth kernel is created first using inverse Fourier transform of weight
+        function.
 
         Parameters
         ----------
@@ -876,8 +874,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False
     ) -> ImgArray:
-        """
-        Butterworth high-pass filter.
+        """Butterworth high-pass filter.
 
         Parameters
         ----------
@@ -918,8 +915,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False
     ):
-        """
-        Butterworth band-pass filter.
+        """Butterworth band-pass filter.
 
         Parameters
         ----------
@@ -963,8 +959,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        General linear convolution by running kernel filtering.
+        """General linear convolution by running kernel filtering.
 
         Parameters
         ----------
@@ -998,8 +993,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Morphological erosion.
+        """Morphological erosion.
 
         If input is binary image, the running function will automatically switched to
         ``binary_erosion`` to speed up calculation.
@@ -1039,8 +1033,9 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Morphological dilation. If input is binary image, the running function will automatically switched to
+        """Morphological dilation.
+
+        If input is binary image, the running function will automatically switched to
         ``binary_dilation`` to speed up calculation.
 
         Parameters
@@ -1078,8 +1073,9 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Morphological opening. If input is binary image, the running function will automatically switched to
+        """Morphological opening.
+
+        If input is binary image, the running function will automatically switched to
         ``binary_opening`` to speed up calculation.
 
         Parameters
@@ -1117,8 +1113,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Morphological closing.
+        """Morphological closing.
 
         If input is binary image, the running function will automatically switched to
         ``binary_closing`` to speed up calculation.
@@ -1158,8 +1153,7 @@ class ImgArray(LabeledArray):
         dims: Dims = None,
         update: bool = False,
     ) -> ImgArray:
-        """
-        Tophat morphological image processing. This is useful for background subtraction.
+        """Tophat morphological image processing. This is useful for background subtraction.
 
         Parameters
         ----------
@@ -1190,8 +1184,7 @@ class ImgArray(LabeledArray):
         *,
         dims: Dims = None
     ) -> ImgArray:
-        """
-        Smoothen binary mask image at its edges. This is useful to make a "soft mask".
+        """Smoothen binary mask image at its edges. This is useful to make a "soft mask".
 
         This method applies erosion/dilation to a binary image and then smooth its edges by Gaussian.
         The total value is always larger after Gaussian smoothing.
@@ -1243,8 +1236,7 @@ class ImgArray(LabeledArray):
         cval: float = 0.0,
         dims: Dims = None,
         update: bool = False) -> ImgArray:
-        """
-        Mean filter. Kernel is filled with same values.
+        """Mean filter. Kernel is filled with same values.
 
         Parameters
         ----------
@@ -1264,6 +1256,65 @@ class ImgArray(LabeledArray):
             kwargs=dict(mode=mode, cval=cval),
         )
 
+
+    @_docs.write_docs
+    @dims_to_spatial_axes
+    @check_input_and_output
+    def min_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0.0,
+        dims: Dims = None,
+    ) -> ImgArray:
+        """Minimum filter.
+
+        Parameters
+        ----------
+        {radius}{mode}{cval}{dims}
+
+        Returns
+        -------
+        ImgArray
+            Filtered image
+        """
+        disk = _structures.ball_like(radius, len(dims))
+        return self.as_float()._apply_dask(
+            _filters.min_filter,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(footprint=disk, mode=mode, cval=cval),
+        )
+
+    @_docs.write_docs
+    @dims_to_spatial_axes
+    @check_input_and_output
+    def max_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0.0,
+        dims: Dims = None,
+    ) -> ImgArray:
+        """Maximum filter.
+
+        Parameters
+        ----------
+        {radius}{mode}{cval}{dims}
+
+        Returns
+        -------
+        ImgArray
+            Filtered image
+        """
+        disk = _structures.ball_like(radius, len(dims))
+        return self.as_float()._apply_dask(
+            _filters.max_filter,
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(footprint=disk, mode=mode, cval=cval),
+        )
+
     @_docs.write_docs
     @dims_to_spatial_axes
     @check_input_and_output

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

@@ -890,6 +890,47 @@ class LazyImgArray(AxesMixin):
             kwargs=dict(footprint=disk, mode=mode, cval=cval),
         )
 
+    @_docs.copy_docs(ImgArray.min_filter)
+    @dims_to_spatial_axes
+    @same_dtype
+    @check_input_and_output_lazy
+    def min_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        disk = _structures.ball_like(radius, len(dims))
+        return self._apply_map_overlap(
+            xp.ndi.minimum_filter,
+            depth=_ceilint(radius),
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(footprint=disk, mode=mode, cval=cval),
+        )
+
+    @_docs.copy_docs(ImgArray.max_filter)
+    @dims_to_spatial_axes
+    @same_dtype
+    @check_input_and_output_lazy
+    def max_filter(
+        self,
+        radius: float = 1,
+        *,
+        mode: PaddingMode = "reflect",
+        cval: float = 0,
+        dims: Dims = None,
+        update: bool = False
+    ) -> LazyImgArray:
+        disk = _structures.ball_like(radius, len(dims))
+        return self._apply_map_overlap(
+            xp.ndi.maximum_filter,
+            depth=_ceilint(radius),
+            c_axes=complement_axes(dims, self.axes),
+            kwargs=dict(footprint=disk, mode=mode, cval=cval),
+        )
 
     @_docs.copy_docs(ImgArray.std_filter)
     @dims_to_spatial_axes

{impy_array-2.4.8 → impy_array-2.4.10}/impy/io/__init__.py

@@ -1,7 +1,7 @@
 from ._registry import imread, imread_dask, imsave, mark_reader, mark_writer, read_header
-from . import _tiff, _mrc, _npy, _zarr, _nd2
+from . import _tiff, _mrc, _npy, _zarr, _nd2, _czi
 
-del _tiff, _mrc, _npy, _zarr, _nd2
+del _tiff, _mrc, _npy, _zarr, _nd2, _czi
 
 __all__ = [
     "imread",

impy_array-2.4.10/impy/io/_czi.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+import numpy as np
+from impy.io._registry import IO
+from impy.io._utils import ImageData, ImageMetadata
+
+if TYPE_CHECKING:
+    from czifile import CziFile
+
+@IO.mark_reader(".czi")
+def _(path: str, memmap: bool = False) -> ImageData:
+    """The CZI format reader"""
+    import czifile
+
+    if memmap:
+        raise NotImplementedError("CZI reader does not support memmap mode yet.")
+    else:
+        out = None
+    with czifile.CziFile(path) as czi:
+        data = np.squeeze(czi.asarray(out=out))
+        meta = _parse_czi_meta(czi)
+
+    return ImageData.from_metadata(data, meta)
+
+def _parse_czi_meta(czi: CziFile) -> ImageMetadata:
+    """Parse metadata from a CZI file."""
+    axes_all: str = czi.axes
+    shape = czi.shape
+    axes = "".join(a.lower() for s, a in zip(shape, axes_all) if s > 1)
+    try:
+        img_meta = czi.metadata(raw=False)["ImageDocument"]["Metadata"]
+        scale = {}
+        for item in img_meta["Scaling"]["Items"]["Distance"]:
+            a = item["Id"].lower()
+            if a in axes:
+                scale[a] = item.get("Value", 1e-6) * 1e6  # as micron
+        try:
+            labels = [item["ImageChannelName"] for item in img_meta["Experiment"]["ExperimentBlocks"]["AcquisitionBlock"]["MultiTrackSetup"]["TrackSetup"]["Detectors"]["Detector"]]
+        except Exception:
+            labels = None
+    except KeyError:
+        scale = None
+        labels = None
+
+    return ImageMetadata(
+        axes=axes,
+        scale=scale,
+        unit="μm",
+        metadata=img_meta,
+        labels=labels,
+    )

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

@@ -3,7 +3,6 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING
 import warnings
-import os
 import numpy as np
 from impy.io._registry import IO
 from impy.io._utils import rechunk_to_ones, MemmapArrayWriter, ImpyArray, ImageData, ImageMetadata
@@ -113,14 +112,23 @@ def _parse_mrcfile(mrc: MrcObject) -> ImageMetadata:
     else:
         axes = "zyx"
 
+    metadata = {}
     scale = dict.fromkeys(axes, 1.0)
     for a in axes:
         scale[a] = mrc.voxel_size[a] / 10
+    try:
+        orig_x, orig_y, orig_z = mrc.header["origin"].item()
+    except Exception:
+        pass
+    else:
+        metadata["origin_nm"] = np.array([orig_z, orig_y, orig_x], dtype=np.float32) / 10
+
+    metadata["labels"] = mrc.get_labels()
 
     return ImageMetadata(
         axes=axes,
         scale=scale,
         unit={a: "nm" for a in axes},
-        metadata={},
+        metadata=metadata,
         labels=None,
     )

{impy_array-2.4.8 → impy_array-2.4.10}/impy/io/_utils.py

@@ -40,7 +40,7 @@ class MemmapArrayWriter:
         chunksize: tuple[int, ...],
     ):
         self._path = path
-        self._offset = offset
+        self._offset = int(offset)
         self._shape = shape  # original shape
         self._chunksize = chunksize  # chunk size
         # shape = (33, 160, 1000, 1000)
@@ -56,7 +56,9 @@ class MemmapArrayWriter:
         # efficient: shape = (10, 100, 150) and sl = (3:5, 0:100, 0:150)
         # sl = (0:1, 16:32, 0:1000, 0:1000)
 
-        offset = np.sum([sl[i].start * arr.strides[i] for i in range(self._border + 1)])
+        # if input array is e.g. flipped, we need to make it contiguous
+        arr = np.ascontiguousarray(arr)
+        offset = sum(int(sl[i].start * arr.strides[i]) for i in range(self._border + 1))
         arr_ravel = arr.ravel()
         mmap = np.memmap(
             self._path,

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

@@ -184,10 +184,10 @@ class ImageGenerator:
     ) -> ImgArray:
         size, name, axes = _normalize_like(size, name, axes, like)
 
-        arr = self._rng.normal(loc=loc, scale=scale, size=size).astype(np.float32)
+        arr = self._rng.normal(loc=loc, scale=scale, size=size)
         if np.isscalar(arr):
             return arr
-        return asarray(xp.asnumpy(arr), axes=axes, name=name)
+        return asarray(xp.asnumpy(arr), axes=axes, name=name).astype(np.float32)
 
     def poisson(
         self,