impy-array 2.3.2__tar.gz → 2.4.0__tar.gz

{impy_array-2.3.2 → impy_array-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: impy-array
-Version: 2.3.2
+Version: 2.4.0
 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>
@@ -43,28 +43,42 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
 Requires-Dist: dask>=2021.6.0
-Requires-Dist: napari>=0.4.17
 Requires-Dist: numpy>=1.22
 Requires-Dist: pandas>=1.3
 Requires-Dist: scikit-image>=0.20.0
 Requires-Dist: scipy>=1.7
 Provides-Extra: all
 Requires-Dist: mrcfile; extra == 'all'
+Requires-Dist: napari>=0.4.17; extra == 'all'
+Requires-Dist: roifile; extra == 'all'
+Requires-Dist: tifffile; extra == 'all'
 Requires-Dist: zarr; extra == 'all'
 Provides-Extra: mrc
 Requires-Dist: mrcfile; extra == 'mrc'
+Provides-Extra: napari
+Requires-Dist: napari>=0.4.17; extra == 'napari'
+Provides-Extra: testing
+Requires-Dist: dask-image; extra == 'testing'
+Requires-Dist: mrcfile; extra == 'testing'
+Requires-Dist: pytest; extra == 'testing'
+Requires-Dist: roifile; extra == 'testing'
+Requires-Dist: tifffile; extra == 'testing'
+Requires-Dist: zarr; extra == 'testing'
+Provides-Extra: tiff
+Requires-Dist: tifffile; extra == 'tiff'
 Provides-Extra: zarr
 Requires-Dist: zarr; extra == 'zarr'
 Description-Content-Type: text/markdown
 
-[![Downloads](https://pepy.tech/badge/impy-array/month)](https://pepy.tech/project/impy-array)
+[![BSD 3-Clause License](https://img.shields.io/pypi/l/impy-array.svg?color=green)](https://github.com/hanjinliu/impy/blob/main/LICENSE)
+[![Python package index download statistics](https://img.shields.io/pypi/dm/impy-array.svg)](https://pypistats.org/packages/impy-array)
 [![PyPI version](https://badge.fury.io/py/impy-array.svg)](https://badge.fury.io/py/impy-array)
 
 # A numpy extension for efficient and powerful image analysis workflow
 
 `impy` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and so on.
 
-The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as 
+The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as
 
 - image axes
 - scale of each axis
@@ -79,8 +93,12 @@ Documentation is available [here](https://hanjinliu.github.io/impy/).
 
 - use pip
 
-```
+``` sh
 pip install impy-array
+pip install impy-array[tiff]    # with supports for reading/writing .tif files
+pip install impy-array[mrc]     # with supports for reading/writing .mrc files
+pip install impy-array[napari]  # viewer support
+pip install impy-array[all]     # install everything
 ```
 
 - from source
@@ -104,7 +122,7 @@ img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image a
 img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
 ```
 
-### Supported file formats
+### Supports many file formats
 
 `impy` automatically chooses proper reader/writer according to the extension.
 
@@ -113,10 +131,22 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 - Zarr file (".zarr")
 - Other image file (".png", ".jpg")
 
+### Lazy loading
+
+With the `lazy` submodule, you can easily make image processing workflows for large
+images.
+
+```python
+import impy as ip
+
+img = ip.lazy.imread("path/to/very-large-image.tif")
+out = img.gaussian_filter()
+out.imsave("image_filtered.tif")
+```
+
 ### Switch between CPU and GPU
 
 `impy` can internally switches the functions between `numpy` and `cupy`.
-You can use GPU for calculation very easily.
 
 ```python
 img.gaussian_filter()  # <- CPU
@@ -127,7 +157,7 @@ ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 
 ### Seamless interface between `napari`
 
-[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run 
+[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run
 
 ```python
 ip.gui.add(img)
@@ -156,7 +186,7 @@ img.imfilter(param=1.0)
 `impy` also supports command line based image analysis. All method of `ImgArray` is available
 from commad line, such as
 
-```powershell
+```shell
 impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
 ```
 

{impy_array-2.3.2 → impy_array-2.4.0}/README.md

@@ -1,11 +1,12 @@
-[![Downloads](https://pepy.tech/badge/impy-array/month)](https://pepy.tech/project/impy-array)
+[![BSD 3-Clause License](https://img.shields.io/pypi/l/impy-array.svg?color=green)](https://github.com/hanjinliu/impy/blob/main/LICENSE)
+[![Python package index download statistics](https://img.shields.io/pypi/dm/impy-array.svg)](https://pypistats.org/packages/impy-array)
 [![PyPI version](https://badge.fury.io/py/impy-array.svg)](https://badge.fury.io/py/impy-array)
 
 # A numpy extension for efficient and powerful image analysis workflow
 
 `impy` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and so on.
 
-The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as 
+The core array, `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as
 
 - image axes
 - scale of each axis
@@ -20,8 +21,12 @@ Documentation is available [here](https://hanjinliu.github.io/impy/).
 
 - use pip
 
-```
+``` sh
 pip install impy-array
+pip install impy-array[tiff]    # with supports for reading/writing .tif files
+pip install impy-array[mrc]     # with supports for reading/writing .mrc files
+pip install impy-array[napari]  # viewer support
+pip install impy-array[all]     # install everything
 ```
 
 - from source
@@ -45,7 +50,7 @@ img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image a
 img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
 ```
 
-### Supported file formats
+### Supports many file formats
 
 `impy` automatically chooses proper reader/writer according to the extension.
 
@@ -54,10 +59,22 @@ img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend tim
 - Zarr file (".zarr")
 - Other image file (".png", ".jpg")
 
+### Lazy loading
+
+With the `lazy` submodule, you can easily make image processing workflows for large
+images.
+
+```python
+import impy as ip
+
+img = ip.lazy.imread("path/to/very-large-image.tif")
+out = img.gaussian_filter()
+out.imsave("image_filtered.tif")
+```
+
 ### Switch between CPU and GPU
 
 `impy` can internally switches the functions between `numpy` and `cupy`.
-You can use GPU for calculation very easily.
 
 ```python
 img.gaussian_filter()  # <- CPU
@@ -68,7 +85,7 @@ ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 
 ### Seamless interface between `napari`
 
-[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run 
+[napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`. Since `ImgArray` is tagged with image metadata, you don't have to care about axes or scales. Just run
 
 ```python
 ip.gui.add(img)
@@ -97,7 +114,7 @@ img.imfilter(param=1.0)
 `impy` also supports command line based image analysis. All method of `ImgArray` is available
 from commad line, such as
 
-```powershell
+```shell
 impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
 ```
 

{impy_array-2.3.2 → impy_array-2.4.0}/impy/__init__.py

@@ -1,19 +1,19 @@
-__version__ = "2.3.2"
+__version__ = "2.4.0"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 
 import logging
 
-from ._const import Const, SetConst, use
+from ._const import Const, SetConst, use  # noqa
 
-from .collections import DataList, DataDict
-from .core import *
-from .binder import bind
-from .viewer import gui
-from .correlation import *
-from .arrays import ImgArray, LazyImgArray, BigImgArray, Label  # for typing
-from . import random, io, lazy
-from .axes import slicer
+from .collections import DataList, DataDict  # noqa
+from .core import *  # noqa
+from .binder import bind  # noqa
+from .viewer import gui  # noqa
+from .correlation import *  # noqa
+from .arrays import ImgArray, LazyImgArray, BigImgArray, Label  # noqa
+from . import random, io, lazy  # noqa
+from .axes import slicer  # noqa
 
 # Inheritance
 # -----------
@@ -34,7 +34,7 @@ logging.getLogger("tifffile").setLevel(logging.ERROR)
 del logging
 
 # dtypes
-from numpy import (
+from numpy import (  # noqa
     uint8, uint16, uint32, uint64,
     int8, int16, int32, int64,
     float16, float32, float64,

{impy_array-2.3.2 → impy_array-2.4.0}/impy/arrays/_utils/_deconv.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
 from functools import partial
 import numpy as np
 from impy.array_api import xp
 
-if TYPE_CHECKING:
-    from impy.arrays import ImgArray
-    
 try:
     gradient = xp.gradient
 except AttributeError:
@@ -17,18 +13,18 @@ except AttributeError:
         out = numpy.gradient(a.get(), axis=axis)
         return xp.asarray(out)
 
-__all__ = ["wiener", "lucy", "lucy_tv", "check_psf"]
+__all__ = ["wiener", "richardson_lucy", "richardson_lucy_tv", "check_psf"]
 
 def wiener(obs, psf_ft, psf_ft_conj, lmd):
     obs = xp.asarray(obs)
     fft = xp.fft.rfftn
     ifft = partial(xp.fft.irfftn, s=obs.shape)
-    
+
     img_ft = fft(obs)
-    
+
     estimated = xp.real(ifft(img_ft*psf_ft_conj / (psf_ft*psf_ft_conj + lmd)))
     return xp.fft.fftshift(estimated)
-    
+
 def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
     # Identical to the algorithm in Deconvolution.jl of Julia.
     obs = xp.asarray(obs)
@@ -36,12 +32,12 @@ def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
     ifft = partial(xp.fft.irfftn, s=obs.shape)
     conv = factor = xp.empty(obs.shape, dtype=xp.float32) # placeholder
     estimated = xp.real(ifft(fft(obs) * psf_ft))   # initialization
-    
+
     for _ in range(niter):
         conv[:] = ifft(fft(estimated) * psf_ft).real
         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
         estimated *= factor
-        
+
     return xp.fft.fftshift(estimated)
 
 def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
@@ -51,21 +47,21 @@ def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
     est_old = ifft(fft(obs) * psf_ft).real
     est_new = xp.empty(obs.shape, dtype=xp.float32)
     conv = factor = norm = gg = xp.empty(obs.shape, dtype=np.float32) # placeholder
-    
+
     for _ in range(max_iter):
         conv[:] = ifft(fft(est_old) * psf_ft).real
         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
         est_new[:] = est_old * factor
         grad = gradient(est_old)
         norm[:] = xp.sqrt(sum(g**2 for g in grad))
-        gg[:] = sum(gradient(_safe_div(grad[i], norm, eps=1e-8), axis=i) 
+        gg[:] = sum(gradient(_safe_div(grad[i], norm, eps=1e-8), axis=i)
                     for i in range(obs.ndim))
         est_new /= (1 - lmd * gg)
         gain = xp.sum(xp.abs(est_new - est_old))/xp.sum(xp.abs(est_old))
         if gain < tol:
             break
         est_old[:] = est_new
-        
+
     return xp.fft.fftshift(est_new)
 
 
@@ -81,7 +77,7 @@ def check_psf(img_shape: tuple[int, ...], img_scale: tuple[float, ...], psf):
         psf = psf(img_shape, img_scale)
     psf = xp.asarray(psf, dtype=np.float32)
     psf /= xp.sum(psf)
-    
+
     if img_shape != psf.shape:
         raise ValueError(
             f"observation and PSF have different shape: {img_shape} and {psf.shape}"

{impy_array-2.3.2 → impy_array-2.4.0}/impy/arrays/_utils/_filters.py

@@ -4,16 +4,16 @@ from ._linalg import hessian_eigval
 from impy.array_api import xp, cupy_dispatcher
 from scipy import ndimage as scipy_ndi
 
-               
+
 __all__ = ["binary_erosion",
-    "erosion"
+    "erosion",
     "binary_dilation",
     "dilation",
     "binary_opening",
     "opening",
     "binary_closing",
     "closing",
-    "gaussian_filter", 
+    "gaussian_filter",
     "gaussian_filter_fourier",
     "median_filter",
     "convolve",
@@ -124,7 +124,7 @@ def coef_filter(data, selem, mode="reflect", cval=0.0):
     x2 = convolve(data**2, selem, mode=mode, cval=cval)
     out = _safe_sqrt(xp.asnumpy(x2 - x1**2), fill=0)/xp.asnumpy(x1)
     return out
-    
+
 def dog_filter(img, low_sigma, high_sigma, mode="reflect", cval=0.0):
     filt_l = gaussian_filter(img, low_sigma, mode=mode, cval=cval)
     filt_h = gaussian_filter(img, high_sigma, mode=mode, cval=cval)
@@ -164,23 +164,23 @@ def population(img, selem):
 # See skimage/feature/template.py
 def ncc_filter(img: np.ndarray, template: np.ndarray, bg=0, mode="constant"):
     from scipy.signal import fftconvolve
-    from skimage import feature
+    from skimage.feature import template as skimage_template
     ndim = template.ndim
-    _win_sum = feature.template._window_sum_2d if ndim == 2 else feature.template._window_sum_3d
+    _win_sum = skimage_template._window_sum_2d if ndim == 2 else skimage_template._window_sum_3d
     pad_width = [(w, w) for w in template.shape]
     padimg = np.pad(img, pad_width=pad_width, mode=mode, constant_values=bg)
-    
+
     corr = fftconvolve(padimg, template[(slice(None,None,-1),)*ndim], mode="valid")[(slice(1,-1,None),)*ndim]
-    
+
     win_sum1 = _win_sum(padimg, template.shape)
     win_sum2 = _win_sum(padimg**2, template.shape)
-    
+
     template_mean = np.mean(template)
     template_volume = np.prod(template.shape)
     template_ssd = np.sum((template - template_mean)**2)
-    
+
     var = (win_sum2 - win_sum1**2/template_volume) * template_ssd
-    
+
     # zero division happens when perfectly matched
     response = np.ones_like(corr)
     mask = var > np.finfo(np.float32).eps
@@ -192,7 +192,7 @@ def ncc_filter(img: np.ndarray, template: np.ndarray, bg=0, mode="constant"):
         slices.append(slice(d0, d1))
     out = response[tuple(slices)]
     return out
-    
+
 def _safe_sqrt(a: np.ndarray, fill=0):
     out = np.full(a.shape, fill, dtype=np.float32)
     out = np.zeros_like(a)

{impy_array-2.3.2 → impy_array-2.4.0}/impy/arrays/_utils/_glcm.py

@@ -1,6 +1,6 @@
 import numpy as np
-from ...collections import DataDict
 import scipy
+from impy.collections import DataDict
 
 __all__ = ["glcm_props_", "check_glcm"]
 
@@ -15,7 +15,7 @@ def asm_(glcm, ref, nei):
 
 def idm_(glcm, ref, nei):
     return np.sum(glcm/(1+(ref-nei)**2), axis=(0,1))
-    
+
 def energy_(glcm, ref, nei):
     return np.sqrt(np.sum(glcm**2, axis=(0,1)))
 
@@ -29,11 +29,11 @@ def entropy_(glcm, ref, nei):
 def correlation_(glcm, ref, nei):
     diffy = ref - np.sum(glcm * ref, axis=(0,1))
     diffx = nei - np.sum(glcm * nei, axis=(0,1))
-    
+
     stdy = np.sqrt(np.sum(glcm*diffy**2, axis=(0,1)))
     stdx = np.sqrt(np.sum(glcm*diffx**2, axis=(0,1)))
     cov = np.sum(glcm*diffx*diffy, axis=(0,1))
-    
+
     out = np.empty(glcm.shape[2:], dtype=np.float32)
     mask_0 = np.logical_or(stdx<1e-15, stdy<1e-15)
     mask_1 = ~mask_0
@@ -73,7 +73,7 @@ propdict = {"contrast": contrast_,
 def glcm_props_(data, distances, angles, levels, radius, properties):
     outshape = (len(distances), len(angles)) + \
         (data.shape[0]-2*radius, data.shape[1]-2*radius)
-        
+
     propout = DataDict()
     for prop in properties:
         if isinstance(prop, str):
@@ -82,13 +82,13 @@ def glcm_props_(data, distances, angles, levels, radius, properties):
             propout[prop.__name__] = np.empty(outshape, dtype=np.float32)
     # placeholder
     glcm = np.empty((levels, levels, len(distances), len(angles)), dtype=np.float32)
-    
+
     ref, nei = np.indices((levels, levels), dtype=np.float32)
     ref = ref[:, :, np.newaxis, np.newaxis]
     nei = nei[:, :, np.newaxis, np.newaxis]
-    
+
     from ._process_numba import _calc_glcm
-    
+
     for x in range(outshape[3]):
         for y in range(outshape[2]):
             # calc glcm
@@ -101,7 +101,7 @@ def glcm_props_(data, distances, angles, levels, radius, properties):
                 else:
                     # only callable
                     propout[prop.__name__][:,:,y,x] = prop(glcm, ref, nei)
-    
+
     return propout
 
 def check_glcm(self, bins, rescale_max):
@@ -112,22 +112,22 @@ def check_glcm(self, bins, rescale_max):
             bins = 256
     elif bins > 256:
         raise ValueError("`bins` must be smaller than 256.")
-    
+
     if self.dtype == np.uint16:
         self = self.as_uint8()
     elif self.dtype == np.uint8:
         pass
     else:
         raise TypeError(f"Cannot calculate comatrix of {self.dtype} image.")
-        
+
     imax = np.iinfo(self.dtype).max
-    
+
     if rescale_max:
         scale = int(imax/self.max())
         self *= scale
-    
+
     if (imax+1) % bins != 0 or bins > imax+1:
         raise ValueError(f"`bins` must be a divisor of {imax+1} (max value of {self.dtype}).")
     self = self // ((imax+1) // bins)
-    
-    return self, bins, rescale_max
+
+    return self, bins, rescale_max

{impy_array-2.3.2 → impy_array-2.4.0}/impy/arrays/_utils/_misc.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import numpy as np
-from ...array_api import xp
+from impy.array_api import xp
 
 def adjust_bin(
     img: np.ndarray,
@@ -44,12 +44,12 @@ def make_rotated_axis(src, dst):
 def make_pad(pad_width, dims, all_axes, **kwargs):
     """More flexible padding than `np.pad`."""
     pad_width_ = []
-        
+
     # for consistency with scipy-format
     if "cval" in kwargs.keys():
         kwargs["constant_values"] = kwargs["cval"]
         kwargs.pop("cval")
-        
+
     if hasattr(pad_width, "__iter__") and len(pad_width) == len(dims):
         pad_iter = iter(pad_width)
         for a in all_axes:
@@ -57,7 +57,7 @@ def make_pad(pad_width, dims, all_axes, **kwargs):
                 pad_width_.append(next(pad_iter))
             else:
                 pad_width_.append((0, 0))
-        
+
     elif isinstance(pad_width, int):
         for a in all_axes:
             if a in dims:
@@ -66,7 +66,7 @@ def make_pad(pad_width, dims, all_axes, **kwargs):
                 pad_width_.append((0, 0))
     else:
         raise TypeError(f"pad_width must be iterable or int, but got {type(pad_width)}")
-    
+
     return pad_width_
 
 def dft(img: xp.ndarray, exps: list[xp.ndarray] = None):

{impy_array-2.3.2 → impy_array-2.4.0}/impy/arrays/_utils/_structures.py

@@ -1,5 +1,5 @@
 import numpy as np
-from ...array_api import xp
+from impy.array_api import xp
 
 def circle(radius, shape, dtype="bool"):
     x = xp.arange(-(shape[0] - 1) / 2, (shape[0] - 1) / 2 + 1)
@@ -10,7 +10,7 @@ def circle(radius, shape, dtype="bool"):
 def ball_like(radius, ndim:int):
     half_int = int(2*radius)/2
     L = xp.arange(-half_int, half_int + 1)
-    
+
     if ndim == 1:
         return xp.ones(int(radius)*2+1, dtype=np.uint8)
     elif ndim == 2:
@@ -32,9 +32,9 @@ def ball_like_odd(radius, ndim):
      [1, 1, 1, 1],
      [0, 1, 1, 0]]
     This is not suitable for specify().
-    """    
+    """
     xc = int(radius)
     l = xc*2 + 1
     coords = xp.indices((l,)*ndim)
     s = xp.sum((a-xc)**2 for a in coords)
-    return xp.array(s <= radius*radius, dtype=bool)
+    return xp.array(s <= radius*radius, dtype=bool)