impy-array 2.4.3__tar.gz → 2.4.4__tar.gz

{impy_array-2.4.3 → impy_array-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: impy-array
-Version: 2.4.3
+Version: 2.4.4
 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>
@@ -74,13 +74,10 @@ Description-Content-Type: text/markdown
 [![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
 
-`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:
+`impy` is an all-in-one multi-dimensional image analysis library. The core array,
+`ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as:
 
 - image axes
 - scale of each axis
@@ -125,7 +122,7 @@ img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
 img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
-img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
+img_prj.imsave("image_max.tif")        # Save in the same place. Don't spend time on searching for the directory!
 ```
 
 ### Supports many file formats
@@ -165,8 +162,8 @@ 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 
+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
@@ -214,6 +211,7 @@ For more complex procedures, it is possible to send images directly to `IPython`
 ```
 impy path/to/image.tif -i
 ```
+
 ```python
 thr = img.gaussian_filter().threshold()
 ```

{impy_array-2.4.3 → impy_array-2.4.4}/README.md

@@ -2,13 +2,10 @@
 [![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
 
-`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:
+`impy` is an all-in-one multi-dimensional image analysis library. The core array,
+`ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as:
 
 - image axes
 - scale of each axis
@@ -53,7 +50,7 @@ img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
 img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
-img_prj.imsave(f"Max-{img.name}")      # Save in the same place. Don't spend time on searching for the directory!
+img_prj.imsave("image_max.tif")        # Save in the same place. Don't spend time on searching for the directory!
 ```
 
 ### Supports many file formats
@@ -93,8 +90,8 @@ 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 
+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
@@ -142,6 +139,7 @@ For more complex procedures, it is possible to send images directly to `IPython`
 ```
 impy path/to/image.tif -i
 ```
+
 ```python
 thr = img.gaussian_filter().threshold()
 ```

{impy_array-2.4.3 → impy_array-2.4.4}/impy/__init__.py

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

{impy_array-2.4.3 → impy_array-2.4.4}/impy/array_api.py

@@ -1,11 +1,5 @@
-
 from functools import wraps
 import numpy as np
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from scipy import ndimage as scipy_ndi, fft as scipy_fft
-    from types import ModuleType
 
 def cupy_dispatcher(function):
     @wraps(function)
@@ -16,24 +10,21 @@ def cupy_dispatcher(function):
         return xp.asnumpy(out)
     return func
 
-# CUDA <= ver.8 does not have gradient    
+# CUDA <= ver.8 does not have gradient
 def _gradient(a, axis=None):
     out = np.gradient(a.get(), axis=axis)
     return xp.asarray(out)
 
-class XP:    
+class XP:
     def __init__(self):
         self.state = ""
         self._reset_namespace()
         self.setNumpy()
-    
-    def __getattr__(self, key: str):
-        return getattr(self._module, key)
-    
+
     def _reset_namespace(self):
         self._signal = None
         self._fft = None
-    
+
     @property
     def signal(self):
         if self._signal is not None:
@@ -47,7 +38,7 @@ class XP:
         else:
             raise ValueError(self.state)
         return self._signal
-    
+
     @property
     def fft(self):
         if self._fft is not None:
@@ -61,13 +52,13 @@ class XP:
         else:
             raise ValueError(self.state)
         return self._fft
-    
+
     def setNumpy(self) -> None:
         from scipy import ndimage as scipy_ndi
 
         if self.state == "numpy":
             return
-        
+
         self._reset_namespace()
         self._module = np
         self.linalg = np.linalg
@@ -117,11 +108,12 @@ class XP:
         self.argmin = np.argmin
         self.pad = np.pad
         self.isnan = np.isnan
-        
+        self.eye = np.eye
+
         self.state = "numpy"
         from ._const import Const
         Const["SCHEDULER"] = "threads"
-    
+
     def setCupy(self) -> None:
         if self.state == "cupy":
             return
@@ -131,10 +123,10 @@ class XP:
             if dtype is None:
                 return out
             return out.astype(dtype)
-        
+
         from cupyx.scipy import ndimage as cp_ndi
         from cupy import linalg as cp_linalg
-        
+
         self._reset_namespace()
         self._module = cp
         self.linalg = cp_linalg
@@ -187,10 +179,10 @@ class XP:
         self.argmin = cp.argmin
         self.pad = cp.pad
         self.isnan = cp.isnan
+        self.eye = cp.eye
         self.state = "cupy"
-        
+
         from ._const import Const
         Const["SCHEDULER"] = "single-threaded"
 
 xp = XP()
-    

impy_array-2.4.4/impy/arrays/__init__.py

@@ -0,0 +1,17 @@
+from impy.arrays.imgarray import ImgArray
+from impy.arrays.labeledarray import LabeledArray
+from impy.arrays.label import Label
+from impy.arrays.phasearray import PhaseArray
+from impy.arrays.specials import PropArray
+from impy.arrays.lazy import LazyImgArray
+from impy.arrays.big import BigImgArray
+
+__all__ = [
+    "ImgArray",
+    "LabeledArray",
+    "Label",
+    "PhaseArray",
+    "PropArray",
+    "LazyImgArray",
+    "BigImgArray",
+]

{impy_array-2.4.3 → impy_array-2.4.4}/impy/arrays/_utils/_corr.py

@@ -10,8 +10,8 @@ from ...array_api import xp
 # TODO: if max_shifts is small, DFT should be used in place of FFT
 
 def _pcc_and_power_spec(
-    f0: xp.ndarray, 
-    f1: xp.ndarray, 
+    f0: np.ndarray,
+    f1: np.ndarray,
     max_shifts: tuple[float, ...] | None = None,
 ):
     product = f0 * f1.conj()
@@ -23,20 +23,20 @@ def _pcc_and_power_spec(
     return power, product
 
 def draw_pcc_landscape(
-    f0: xp.ndarray, 
-    f1: xp.ndarray, 
+    f0: np.ndarray,
+    f1: np.ndarray,
     max_shifts: tuple[float, ...] | None = None,
 ):
     power = _pcc_and_power_spec(f0, f1, max_shifts)[0]
     return xp.fft.fftshift(power)
 
 def subpixel_pcc(
-    f0: xp.ndarray, 
-    f1: xp.ndarray, 
+    f0: np.ndarray,
+    f1: np.ndarray,
     upsample_factor: int,
     max_shifts: tuple[float, ...] | None = None,
 ):
-    power, product = _pcc_and_power_spec(f0, f1, max_shifts)    
+    power, product = _pcc_and_power_spec(f0, f1, max_shifts)
     maxima = xp.unravel_index(xp.argmax(power), power.shape)
     midpoints = xp.array([np.fix(axis_size / 2) for axis_size in power.shape])
 
@@ -58,13 +58,13 @@ def subpixel_pcc(
                                            ).conj()
         # Locate maximum and map back to original pixel grid
         power = abs2(cross_correlation)
-        
+
         if max_shifts is not None:
             max_shifts = xp.asarray(max_shifts)
             _upsampled_left_shifts = (shifts + max_shifts) * upsample_factor
             _upsampled_right_shifts = (max_shifts - shifts) * upsample_factor
             power = crop_by_max_shifts(power, _upsampled_left_shifts, _upsampled_right_shifts)
-            
+
         maxima = xp.unravel_index(xp.argmax(power), power.shape)
         maxima = xp.asarray(maxima, dtype=np.float32) - dftshift
         shifts = shifts + maxima / upsample_factor
@@ -74,11 +74,11 @@ def subpixel_pcc(
     return shifts, pcc
 
 def _upsampled_dft(
-    data: xp.ndarray, 
-    upsampled_region_size: np.ndarray, 
-    upsample_factor: int, 
-    axis_offsets: xp.ndarray
-) -> xp.ndarray:
+    data: np.ndarray,
+    upsampled_region_size: np.ndarray,
+    upsample_factor: int,
+    axis_offsets: np.ndarray
+) -> np.ndarray:
     # if people pass in an integer, expand it to a list of equal-sized sections
     upsampled_region_size = [upsampled_region_size,] * data.ndim
 
@@ -92,14 +92,14 @@ def _upsampled_dft(
         data = xp.tensordot(kernel, data, axes=(1, -1))
     return data
 
-def abs2(a: xp.ndarray) -> xp.ndarray:
+def abs2(a: np.ndarray) -> np.ndarray:
     return a.real**2 + a.imag**2
 
-def crop_by_max_shifts(power: xp.ndarray, left, right):
+def crop_by_max_shifts(power: np.ndarray, left, right):
     shifted_power = xp.fft.fftshift(power)
     centers = tuple(s//2 for s in power.shape)
     slices = tuple(
-        slice(max(c - int(shiftl), 0), min(c + int(shiftr) + 1, s), None) 
+        slice(max(c - int(shiftl), 0), min(c + int(shiftr) + 1, s), None)
         for c, shiftl, shiftr, s in zip(centers, left, right, power.shape)
     )
     return xp.fft.ifftshift(shifted_power[slices])
@@ -107,8 +107,8 @@ def crop_by_max_shifts(power: xp.ndarray, left, right):
 # Normalized cross correlation
 
 def _draw_ncc_landscape_no_crop(
-    img0: xp.ndarray, 
-    img1: xp.ndarray, 
+    img0: np.ndarray,
+    img1: np.ndarray,
     max_shifts: tuple[float, ...] | None = None,
 ):
     ndim = img1.ndim
@@ -116,30 +116,30 @@ def _draw_ncc_landscape_no_crop(
         max_shifts = tuple(max_shifts)
     pad_width, sl = _get_padding_params(img0.shape, img1.shape, max_shifts)
     padimg = xp.pad(img0[sl], pad_width=pad_width, mode="constant", constant_values=0)
-    
+
     corr = xp.signal.fftconvolve(
         padimg, img1[(slice(None, None, -1),)*ndim], mode="valid"
     )[(slice(1, -1, None),)*ndim]
-    
+
     _win_sum = _window_sum_2d if ndim == 2 else _window_sum_3d
     win_sum1 = _win_sum(padimg, img1.shape)
     win_sum2 = _win_sum(padimg**2, img1.shape)
-    
+
     template_mean = xp.mean(img1)
     template_volume = xp.prod(xp.array(img1.shape))
     template_ssd = xp.sum((img1 - template_mean)**2)
-    
+
     var = (win_sum2 - win_sum1**2 / template_volume) * template_ssd
-    
+
     # zero division happens when perfectly matched
     response = xp.zeros_like(corr)
     mask = var > 0
     response[mask] = (corr - win_sum1 * template_mean)[mask] / _safe_sqrt(var, fill=np.inf)[mask]
     return response
-    
+
 def draw_ncc_landscape(
-    img0: xp.ndarray, 
-    img1: xp.ndarray, 
+    img0: np.ndarray,
+    img1: np.ndarray,
     max_shifts: tuple[float, ...] | None = None,
 ):
     response = _draw_ncc_landscape_no_crop(img0, img1, max_shifts)
@@ -149,12 +149,12 @@ def draw_ncc_landscape(
         pad_width_eff = tuple((s - int(m) * 2 - 1)//2 for m, s in zip(max_shifts, response.shape))
     sl_res = tuple(slice(w, -w, None) for w in pad_width_eff)
     response_center = response[sl_res]
-    
+
     return response_center
 
 def subpixel_ncc(
-    img0: xp.ndarray, 
-    img1: xp.ndarray, 
+    img0: np.ndarray,
+    img1: np.ndarray,
     upsample_factor: int,
     max_shifts: tuple[float, ...] | None = None,
 ):
@@ -167,7 +167,7 @@ def subpixel_ncc(
     response_center = response[sl_res]
     maxima = xp.unravel_index(xp.argmax(response_center), response_center.shape)
     midpoints = xp.asarray(response_center.shape) // 2
-    
+
     if upsample_factor > 1:
         coords = _create_mesh(upsample_factor, maxima, max_shifts, midpoints, pad_width_eff, xp.state)
         local_response = xp.ndi.map_coordinates(
@@ -179,7 +179,7 @@ def subpixel_ncc(
     else:
         zncc = response[maxima]
         shifts = xp.array(maxima) - midpoints
-        
+
     return xp.asarray(shifts, dtype=np.float32), zncc
 
 # Identical to skimage.feature.template, but compatible between numpy and cupy.
@@ -202,7 +202,7 @@ def _window_sum_3d(image, window_shape):
 
     return window_sum
 
-def _safe_sqrt(a: xp.ndarray, fill=0):
+def _safe_sqrt(a: np.ndarray, fill=0):
     out = xp.full(a.shape, fill, dtype=np.float32)
     out = xp.zeros_like(a)
     mask = a > 0
@@ -211,7 +211,7 @@ def _safe_sqrt(a: xp.ndarray, fill=0):
 
 @lru_cache(maxsize=12)
 def _get_padding_params(
-    shape0: tuple[int, ...], 
+    shape0: tuple[int, ...],
     shape1: tuple[int, ...],
     max_shifts: tuple[int, ...] | None,
 ) -> tuple[list[tuple[int, ...]], list[slice] | slice]:
@@ -230,13 +230,13 @@ def _get_padding_params(
                 pad_width.append((0,) * 2)
                 sl.append(slice(-w_int, w_int, None))
         sl = tuple(sl)
-    
+
     return pad_width, sl
 
 
 def _create_mesh(
     upsample_factor: int,
-    maxima: tuple[int, ...], 
+    maxima: tuple[int, ...],
     max_shifts: tuple[int, ...] | None,
     midpoints: tuple[int, ...],
     pad_width_eff: tuple[int, ...],
@@ -256,7 +256,7 @@ def _create_mesh(
         local_shifts = ([-upsample_factor, upsample_factor],) * len(maxima)
     mesh = xp.meshgrid(
         *[xp.arange(s0, s1+1)/upsample_factor + m + w
-          for (s0, s1), m, w in zip(local_shifts, maxima, pad_width_eff)], 
+          for (s0, s1), m, w in zip(local_shifts, maxima, pad_width_eff)],
         indexing="ij",
     )
     return xp.stack(mesh, axis=0)

{impy_array-2.4.3 → impy_array-2.4.4}/impy/arrays/_utils/_deconv.py

@@ -4,15 +4,6 @@ from functools import partial
 import numpy as np
 from impy.array_api import xp
 
-try:
-    gradient = xp.gradient
-except AttributeError:
-    # CUDA <= ver.8 does not have gradient
-    import numpy
-    def gradient(a, axis=None):
-        out = numpy.gradient(a.get(), axis=axis)
-        return xp.asarray(out)
-
 __all__ = ["wiener", "richardson_lucy", "richardson_lucy_tv", "check_psf"]
 
 def wiener(obs, psf_ft, psf_ft_conj, lmd):
@@ -30,7 +21,7 @@ def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
     obs = xp.asarray(obs)
     fft = xp.fft.rfftn
     ifft = partial(xp.fft.irfftn, s=obs.shape)
-    conv = factor = xp.empty(obs.shape, dtype=xp.float32) # placeholder
+    conv = factor = xp.empty(obs.shape, dtype=np.float32) # placeholder
     estimated = xp.real(ifft(fft(obs) * psf_ft))   # initialization
 
     for _ in range(niter):
@@ -45,16 +36,16 @@ def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
     fft = xp.fft.rfftn
     ifft = partial(xp.fft.irfftn, s=obs.shape)
     est_old = ifft(fft(obs) * psf_ft).real
-    est_new = xp.empty(obs.shape, dtype=xp.float32)
+    est_new = xp.empty(obs.shape, dtype=np.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)
+        grad = xp.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(xp.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))

{impy_array-2.4.3 → impy_array-2.4.4}/impy/arrays/_utils/_misc.py

@@ -69,7 +69,7 @@ def make_pad(pad_width, dims, all_axes, **kwargs):
 
     return pad_width_
 
-def dft(img: xp.ndarray, exps: list[xp.ndarray] = None):
+def dft(img: np.ndarray, exps: list[np.ndarray] = None):
     """Discrete Fourier Transform."""
     img = xp.asarray(img)
     for ker in reversed(exps):
@@ -77,7 +77,7 @@ def dft(img: xp.ndarray, exps: list[xp.ndarray] = None):
         img = xp.tensordot(xp.asarray(ker), img, axes=(1, -1))
     return img
 
-def inpaint_mean(img: xp.ndarray, mask: xp.ndarray):
+def inpaint_mean(img: np.ndarray, mask: np.ndarray):
     """Inpaint missing values with mean of surrounding pixels."""
     img = xp.asarray(img)
     mask = xp.asarray(mask)

{impy_array-2.4.3 → impy_array-2.4.4}/impy/arrays/_utils/_transform.py

@@ -343,9 +343,9 @@ def get_fourier_filter(size: int, filter_name: str):
         cosine_filter = xp.fft.fftshift(xp.sin(freq))
         fourier_filter *= cosine_filter
     elif filter_name == "hamming":
-        fourier_filter *= xp.fft.fftshift(xp.hamming(size))
+        fourier_filter *= xp.fft.fftshift(xp._module.hamming(size))
     elif filter_name == "hann":
-        fourier_filter *= xp.fft.fftshift(xp.hanning(size))
+        fourier_filter *= xp.fft.fftshift(xp._module.hanning(size))
     elif filter_name is None:
         fourier_filter[:] = 1
     else: