impy-array 2.2.1__tar.gz → 2.2.2__tar.gz

impy_array-2.2.2/.gitignore

@@ -0,0 +1,130 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+.vscode/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

{impy-array-2.2.1 → impy_array-2.2.2}/PKG-INFO

@@ -1,141 +1,178 @@
-Metadata-Version: 2.1
-Name: impy-array
-Version: 2.2.1
-Summary: Speed up coding/extending image analysis in Python.
-Download-URL: https://github.com/hanjinliu/impy
-Author: Hanjin Liu
-Author-email: liuhanjin-sc@g.ecc.u-tokyo.ac.jp
-License: BSD 3-Clause
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: all
-Provides-Extra: zarr
-Provides-Extra: mrc
-License-File: LICENSE
-
-[![Downloads](https://pepy.tech/badge/impy-array/month)](https://pepy.tech/project/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 
-
-- image axes
-- scale of each axis
-- directory of the original image
-- and other image metadata
-
-## Documentation
-
-Documentation is available [here](https://hanjinliu.github.io/impy/).
-
-## Installation
-
-- use pip
-
-```
-pip install impy-array
-```
-
-- from source
-
-```
-git clone https://github.com/hanjinliu/impy
-```
-
-### Code as fast as you speak
-
-Almost all the functions, such as filtering, deconvolution, labeling, single molecule detection, and even those pure `numpy` functions, are aware of image metadata. They "know" which dimension corresponds to `"z"` axis, which axes they should iterate along or where to save the image. As a result, **your code will be very concise**:
-
-```python
-import impy as ip
-import numpy as np
-
-img = ip.imread("path/to/image")       # Read images with metadata.
-img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
-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!
-```
-
-### Supported file formats
-
-`impy` automatically chooses proper reader/writer according to the extension.
-
-- Tiff file (".tif", ".tiff")
-- MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
-- Zarr file (".zarr")
-- Other image file (".png", ".jpg")
-
-### 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
-with ip.use("cupy"):
-    img.gaussian_filter()  # <- GPU
-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 
-
-```python
-ip.gui.add(img)
-```
-
-### Extend your function for batch processing
-
-Already have a function for `numpy` and `scipy`? Decorate it with `@ip.bind`
-
-```python
-@ip.bind
-def imfilter(img, param=None):
-    # Your function here.
-    # Do something on a 2D or 3D image and return image, scalar or labels
-    return out
-```
-
-and it's ready for batch processing!
-
-```python
-img.imfilter(param=1.0)
-```
-
-### Commaind line usage
-
-`impy` also supports command line based image analysis. All method of `ImgArray` is available
-from commad line, such as
-
-```powershell
-impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
-```
-
-which is equivalent to
-
-```python
-import impy as ip
-img = ip.imread("path/to/image.tif")
-out = img.gaussian_filter(sigma=2.0)
-out.imsave("./output.tif")
-```
-
-For more complex procedure, it is possible to send image directly to `IPython`
-
-```
-impy path/to/image.tif -i
-```
-```python
-thr = img.gaussian_filter().threshold()
-```
-
-or to `napari`
-
-```
-impy path/to/image.tif -n
-```
+Metadata-Version: 2.1
+Name: impy-array
+Version: 2.2.2
+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>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2021, hanjinliu
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+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
+Provides-Extra: all
+Requires-Dist: mrcfile; extra == 'all'
+Requires-Dist: zarr; extra == 'all'
+Provides-Extra: mrc
+Requires-Dist: mrcfile; extra == 'mrc'
+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)
+[![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 
+
+- image axes
+- scale of each axis
+- directory of the original image
+- and other image metadata
+
+## Documentation
+
+Documentation is available [here](https://hanjinliu.github.io/impy/).
+
+## Installation
+
+- use pip
+
+```
+pip install impy-array
+```
+
+- from source
+
+```
+git clone https://github.com/hanjinliu/impy
+```
+
+### Code as fast as you speak
+
+Almost all the functions, such as filtering, deconvolution, labeling, single molecule detection, and even those pure `numpy` functions, are aware of image metadata. They "know" which dimension corresponds to `"z"` axis, which axes they should iterate along or where to save the image. As a result, **your code will be very concise**:
+
+```python
+import impy as ip
+import numpy as np
+
+img = ip.imread("path/to/image")       # Read images with metadata.
+img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
+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!
+```
+
+### Supported file formats
+
+`impy` automatically chooses proper reader/writer according to the extension.
+
+- Tiff file (".tif", ".tiff")
+- MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
+- Zarr file (".zarr")
+- Other image file (".png", ".jpg")
+
+### 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
+with ip.use("cupy"):
+    img.gaussian_filter()  # <- GPU
+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 
+
+```python
+ip.gui.add(img)
+```
+
+### Extend your function for batch processing
+
+Already have a function for `numpy` and `scipy`? Decorate it with `@ip.bind`
+
+```python
+@ip.bind
+def imfilter(img, param=None):
+    # Your function here.
+    # Do something on a 2D or 3D image and return image, scalar or labels
+    return out
+```
+
+and it's ready for batch processing!
+
+```python
+img.imfilter(param=1.0)
+```
+
+### Command line usage
+
+`impy` also supports command line based image analysis. All method of `ImgArray` is available
+from commad line, such as
+
+```powershell
+impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
+```
+
+which is equivalent to
+
+```python
+import impy as ip
+img = ip.imread("path/to/image.tif")
+out = img.gaussian_filter(sigma=2.0)
+out.imsave("./output.tif")
+```
+
+For more complex procedure, it is possible to send image directly to `IPython`
+
+```
+impy path/to/image.tif -i
+```
+```python
+thr = img.gaussian_filter().threshold()
+```

{impy-array-2.2.1 → impy_array-2.2.2}/README.md

@@ -92,7 +92,7 @@ and it's ready for batch processing!
 img.imfilter(param=1.0)
 ```
 
-### Commaind line usage
+### Command line usage
 
 `impy` also supports command line based image analysis. All method of `ImgArray` is available
 from commad line, such as
@@ -118,9 +118,3 @@ impy path/to/image.tif -i
 ```python
 thr = img.gaussian_filter().threshold()
 ```
-
-or to `napari`
-
-```
-impy path/to/image.tif -n
-```

{impy-array-2.2.1 → impy_array-2.2.2}/impy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.2.1"
+__version__ = "2.2.2"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 
@@ -15,19 +15,17 @@ from .arrays import ImgArray, LazyImgArray, BigImgArray, Label  # for typing
 from . import random, io
 from .axes import slicer
 
-r"""
-Inheritance
------------
+# Inheritance
+# -----------
+#
+# AxesMixin -----> LazyImgArray ------> BigImgArray
+#     |
+#     +-----> MetaArray --+--> LabeledArray --+--> ImgArray
+#     |                   |                   |
+# np.ndarray              +--> Label          +--> PhaseArray
+#                         |
+#                         +--> PropArray
 
-AxesMixin -----> LazyImgArray ------> BigImgArray
-    |
-    +-----> MetaArray --+--> LabeledArray --+--> ImgArray
-    |                   |                   |
-np.ndarray              +--> Label          +--> PhaseArray
-                        |
-                        +--> PropArray
-
-"""
 
 logging.getLogger("skimage").setLevel(logging.ERROR)
 logging.getLogger("tifffile").setLevel(logging.ERROR)

{impy-array-2.2.1 → impy_array-2.2.2}/impy/arrays/__init__.py

@@ -16,3 +16,13 @@ try:
 
 except Exception:
     pass
+
+__all__ = [
+    "ImgArray",
+    "LabeledArray",
+    "Label",
+    "PhaseArray",
+    "PropArray",
+    "LazyImgArray",
+    "BigImgArray",
+]

{impy-array-2.2.1 → impy_array-2.2.2}/impy/arrays/_utils/_deconv.py

@@ -1,7 +1,13 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 from functools import partial
 import numpy as np
-from ...array_api import xp
+from impy.array_api import xp
 
+if TYPE_CHECKING:
+    from impy.arrays import ImgArray
+    
 try:
     gradient = xp.gradient
 except AttributeError:
@@ -11,11 +17,7 @@ except AttributeError:
         out = numpy.gradient(a.get(), axis=axis)
         return xp.asarray(out)
 
-__all__ = ["wiener", 
-           "lucy",
-           "lucy_tv",
-           "check_psf",
-           ]
+__all__ = ["wiener", "lucy", "lucy_tv", "check_psf"]
 
 def wiener(obs, psf_ft, psf_ft_conj, lmd):
     obs = xp.asarray(obs)
@@ -67,20 +69,23 @@ def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
     return xp.fft.fftshift(est_new)
 
 
-def _safe_div(a, b, eps=1e-8):
+def _safe_div(a: np.ndarray, b: np.ndarray, eps: float = 1e-8):
     out = xp.zeros(a.shape, dtype=np.float32)
     mask = b > eps
-    out[mask] = a[mask]/b[mask]
+    out[mask] = a[mask] / b[mask]
     return out
 
 
-def check_psf(img, psf, dims):
+def check_psf(img_shape: tuple[int, ...], img_scale: tuple[float, ...], psf):
+    if callable(psf):
+        psf = psf(img_shape, img_scale)
     psf = xp.asarray(psf, dtype=np.float32)
     psf /= xp.sum(psf)
     
-    if img.sizesof(dims) != psf.shape:
-        raise ValueError("observation and PSF have different shape: "
-                        f"{img.sizesof(dims)} and {psf.shape}")
+    if img_shape != psf.shape:
+        raise ValueError(
+            f"observation and PSF have different shape: {img_shape} and {psf.shape}"
+        )
     psf_ft = xp.fft.rfftn(psf)
     psf_ft_conj = xp.conjugate(psf_ft)
-    return psf_ft, psf_ft_conj
+    return psf_ft, psf_ft_conj

{impy-array-2.2.1 → impy_array-2.2.2}/impy/arrays/_utils/_transform.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Iterable, NamedTuple, Sequence, TYPE_CHECKING
+import math
 import numpy as np
 
 from ._skimage import sktrans
@@ -307,8 +308,8 @@ def iradon(
     # Reconstruct image by interpolation
     reconstructed = np.zeros(output_shape, dtype=dtype)
     xpr, ypr = np.indices(output_shape)
-    xpr -= output_shape[0] // 2
-    ypr -= output_shape[1] // 2
+    xpr = xpr - output_shape[0] // 2
+    ypr = ypr - output_shape[1] // 2
     
     from scipy.interpolate import interp1d
     x = np.arange(img_shape) - img_shape // 2  # NOTE: use CPU!
@@ -322,12 +323,13 @@ def iradon(
 # This function is almost ported from `skimage.transform`.
 def get_fourier_filter(size: int, filter_name: str):
     n = xp.concatenate(
-        [xp.arange(1, size / 2 + 1, 2, dtype=int),
-         xp.arange(size / 2 - 1, 0, -2, dtype=int)]
+        [xp.arange(1, size // 2 + 1, 2, dtype=np.float32),
+         xp.arange(size // 2 - 1, 0, -2, dtype=np.float32)]
     )
     f = xp.zeros(size)
     f[0] = 0.25
     f[1::2] = -1 / (np.pi * n[:len(f[1::2])]) ** 2
+
     fourier_filter = 2 * xp.real(xp.fft.fft(f))  # ramp filter
     if filter_name == "ramp":
         pass

{impy-array-2.2.1 → impy_array-2.2.2}/impy/arrays/axesmixin.py

@@ -200,6 +200,9 @@ class AxesMixin:
                 {a: s for a, s in other.scale.items() if a in self.axes}  # type: ignore
             )
         
+        elif isinstance(other, (list, tuple)):
+            for a, s in zip(self.axes, other):
+                a.scale = s
         else:
             raise TypeError(
                 f"'other' must be str or axes supported object, but got {type(other)}"

{impy-array-2.2.1 → impy_array-2.2.2}/impy/arrays/bases/metaarray.py

@@ -27,7 +27,7 @@ SupportSlicing = Union[
     Mapping[str, SupportOneSlicing],
 ]
 
-class MetaArray(AxesMixin, np.ndarray):
+class MetaArray(AxesMixin, np.ndarray[Any, np.dtype[np.number]]):
     additional_props = ["_source", "_metadata", "_name"]
     NP_DISPATCH = {}
     _name: str
@@ -747,7 +747,7 @@ class MetaArray(AxesMixin, np.ndarray):
         except ImageAxesError:
             self.axes = None
         
-        return None
+        return self
     
     def _process_output(self, func, args, kwargs):
         # find the largest MetaArray. Largest because of broadcasting.