├── .gitignore
├── .gitmodules
├── .pre-commit-config.yaml
├── LICENSE
├── README.md
├── docs
    ├── .buildinfo
    ├── .doctrees
    │   ├── api.doctree
    │   ├── apidoc
    │   │   ├── impy.arrays.bases.doctree
    │   │   ├── impy.arrays.doctree
    │   │   ├── impy.axes.doctree
    │   │   ├── impy.doctree
    │   │   ├── impy.frame.doctree
    │   │   ├── impy.lazy.doctree
    │   │   ├── impy.utils.doctree
    │   │   ├── impy.viewer.doctree
    │   │   └── modules.doctree
    │   ├── environment.pickle
    │   ├── gallary
    │   │   └── regionprops.doctree
    │   ├── gallery
    │   │   ├── drift_correction.doctree
    │   │   ├── filters.doctree
    │   │   ├── index.doctree
    │   │   └── regionprops.doctree
    │   ├── index.doctree
    │   ├── tutoral_axes.doctree
    │   ├── tutorial.doctree
    │   ├── tutorial_axes.doctree
    │   └── tutorial_cmd.doctree
    ├── .nojekyll
    ├── _modules
    │   ├── impy
    │   │   ├── array_api.html
    │   │   ├── arrays
    │   │   │   ├── axesmixin.html
    │   │   │   ├── bases
    │   │   │   │   ├── metaarray.html
    │   │   │   │   └── overload.html
    │   │   │   ├── big.html
    │   │   │   ├── imgarray.html
    │   │   │   ├── label.html
    │   │   │   ├── labeledarray.html
    │   │   │   ├── lazy.html
    │   │   │   ├── phasearray.html
    │   │   │   ├── specials.html
    │   │   │   └── tiled.html
    │   │   ├── axes.html
    │   │   ├── binder.html
    │   │   ├── collections.html
    │   │   ├── core.html
    │   │   ├── correlation.html
    │   │   ├── frame
    │   │   │   └── frames.html
    │   │   ├── lazy
    │   │   │   ├── core.html
    │   │   │   └── random.html
    │   │   ├── random.html
    │   │   ├── roi.html
    │   │   ├── utils
    │   │   │   ├── axesop.html
    │   │   │   ├── deco.html
    │   │   │   ├── gauss.html
    │   │   │   ├── io.html
    │   │   │   ├── misc.html
    │   │   │   ├── slicer.html
    │   │   │   └── utilcls.html
    │   │   └── viewer
    │   │   │   ├── utils.html
    │   │   │   └── viewer.html
    │   ├── index.html
    │   └── tifffile
    │   │   └── tifffile.html
    ├── _sources
    │   ├── api.rst.txt
    │   ├── apidoc
    │   │   ├── impy.arrays.bases.rst.txt
    │   │   ├── impy.arrays.rst.txt
    │   │   ├── impy.axes.rst.txt
    │   │   ├── impy.frame.rst.txt
    │   │   ├── impy.lazy.rst.txt
    │   │   ├── impy.rst.txt
    │   │   ├── impy.utils.rst.txt
    │   │   ├── impy.viewer.rst.txt
    │   │   └── modules.rst.txt
    │   ├── gallary
    │   │   └── regionprops.rst.txt
    │   ├── gallery
    │   │   ├── drift_correction.rst.txt
    │   │   ├── filters.rst.txt
    │   │   ├── index.rst.txt
    │   │   └── regionprops.rst.txt
    │   ├── index.rst.txt
    │   ├── tutoral_axes.rst.txt
    │   ├── tutorial.rst.txt
    │   ├── tutorial_axes.rst.txt
    │   └── tutorial_cmd.rst.txt
    ├── _static
    │   ├── basic.css
    │   ├── css
    │   │   ├── badge_only.css
    │   │   ├── fonts
    │   │   │   ├── Roboto-Slab-Bold.woff
    │   │   │   ├── Roboto-Slab-Bold.woff2
    │   │   │   ├── Roboto-Slab-Regular.woff
    │   │   │   ├── Roboto-Slab-Regular.woff2
    │   │   │   ├── fontawesome-webfont.eot
    │   │   │   ├── fontawesome-webfont.svg
    │   │   │   ├── fontawesome-webfont.ttf
    │   │   │   ├── fontawesome-webfont.woff
    │   │   │   ├── fontawesome-webfont.woff2
    │   │   │   ├── lato-bold-italic.woff
    │   │   │   ├── lato-bold-italic.woff2
    │   │   │   ├── lato-bold.woff
    │   │   │   ├── lato-bold.woff2
    │   │   │   ├── lato-normal-italic.woff
    │   │   │   ├── lato-normal-italic.woff2
    │   │   │   ├── lato-normal.woff
    │   │   │   └── lato-normal.woff2
    │   │   └── theme.css
    │   ├── doctools.js
    │   ├── documentation_options.js
    │   ├── file.png
    │   ├── jquery-3.5.1.js
    │   ├── jquery.js
    │   ├── js
    │   │   ├── badge_only.js
    │   │   ├── html5shiv-printshiv.min.js
    │   │   ├── html5shiv.min.js
    │   │   └── theme.js
    │   ├── language_data.js
    │   ├── minus.png
    │   ├── plus.png
    │   ├── pygments.css
    │   ├── searchtools.js
    │   ├── sphinx_highlight.js
    │   ├── underscore-1.13.1.js
    │   └── underscore.js
    ├── api.html
    ├── apidoc
    │   ├── impy.arrays.bases.html
    │   ├── impy.arrays.html
    │   ├── impy.axes.html
    │   ├── impy.frame.html
    │   ├── impy.html
    │   ├── impy.lazy.html
    │   ├── impy.utils.html
    │   ├── impy.viewer.html
    │   └── modules.html
    ├── gallery
    │   ├── drift_correction.html
    │   ├── filters.html
    │   ├── index.html
    │   └── regionprops.html
    ├── genindex.html
    ├── index.html
    ├── objects.inv
    ├── py-modindex.html
    ├── search.html
    ├── searchindex.js
    ├── tutorial.html
    ├── tutorial_axes.html
    └── tutorial_cmd.html
├── impy
    ├── __init__.py
    ├── __main__.py
    ├── _const.py
    ├── _types.py
    ├── array_api.py
    ├── arrays
    │   ├── __init__.py
    │   ├── _imshow.py
    │   ├── _utils
    │   │   ├── __init__.py
    │   │   ├── _corr.py
    │   │   ├── _deconv.py
    │   │   ├── _docs.py
    │   │   ├── _filters.py
    │   │   ├── _glcm.py
    │   │   ├── _linalg.py
    │   │   ├── _misc.py
    │   │   ├── _plot.py
    │   │   ├── _process_numba.py
    │   │   ├── _skimage.py
    │   │   ├── _structures.py
    │   │   └── _transform.py
    │   ├── axesmixin.py
    │   ├── bases
    │   │   ├── __init__.py
    │   │   ├── metaarray.py
    │   │   └── overload.py
    │   ├── big.py
    │   ├── imgarray.py
    │   ├── label.py
    │   ├── labeledarray.py
    │   ├── lazy.py
    │   ├── phasearray.py
    │   ├── specials.py
    │   └── tiled.py
    ├── axes
    │   ├── __init__.py
    │   ├── _axes.py
    │   ├── _axes_tuple.py
    │   ├── _axis.py
    │   └── _slicer.py
    ├── binder.py
    ├── collections.py
    ├── core.py
    ├── correlation.py
    ├── frame
    │   ├── __init__.py
    │   └── frames.py
    ├── io
    │   ├── __init__.py
    │   ├── _czi.py
    │   ├── _mrc.py
    │   ├── _nd2.py
    │   ├── _npy.py
    │   ├── _registry.py
    │   ├── _tiff.py
    │   ├── _utils.py
    │   └── _zarr.py
    ├── lazy
    │   ├── __init__.py
    │   ├── core.py
    │   └── random.py
    ├── random.py
    ├── roi.py
    ├── utils
    │   ├── __init__.py
    │   ├── axesop.py
    │   ├── deco.py
    │   ├── gauss.py
    │   ├── misc.py
    │   ├── slicer.py
    │   └── utilcls.py
    └── viewer
    │   ├── __init__.py
    │   ├── utils.py
    │   └── viewer.py
├── pyproject.toml
├── rst
    ├── Makefile
    ├── api.rst
    ├── apidoc
    │   ├── impy.arrays.bases.rst
    │   ├── impy.arrays.rst
    │   ├── impy.axes.rst
    │   ├── impy.frame.rst
    │   ├── impy.lazy.rst
    │   ├── impy.rst
    │   ├── impy.utils.rst
    │   ├── impy.viewer.rst
    │   └── modules.rst
    ├── conf.py
    ├── gallery
    │   ├── drift_correction.rst
    │   ├── filters.rst
    │   ├── index.rst
    │   └── regionprops.rst
    ├── index.rst
    ├── make.bat
    ├── tutorial.rst
    ├── tutorial_axes.rst
    └── tutorial_cmd.rst
└── tests
    ├── __init__.py
    ├── _test_images
        ├── RoiSet.zip
        └── image_tzcyx.tif
    ├── conftest.py
    ├── test_astype.py
    ├── test_axes.py
    ├── test_big.py
    ├── test_bind.py
    ├── test_broadcasting.py
    ├── test_collection.py
    ├── test_correlation.py
    ├── test_crop.py
    ├── test_fft.py
    ├── test_gaussfit.py
    ├── test_io.py
    ├── test_labels.py
    ├── test_lazy.py
    ├── test_map_coords.py
    ├── test_methods.py
    ├── test_numpy_functions.py
    ├── test_props_functions.py
    ├── test_radon.py
    ├── test_random.py
    ├── test_roi.py
    ├── test_shape.py
    └── test_slicing.py


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | .vscode/
  4 | *.py[cod]
  5 | *$py.class
  6 | 
  7 | # C extensions
  8 | *.so
  9 | 
 10 | # Distribution / packaging
 11 | .Python
 12 | build/
 13 | develop-eggs/
 14 | dist/
 15 | downloads/
 16 | eggs/
 17 | .eggs/
 18 | lib/
 19 | lib64/
 20 | parts/
 21 | sdist/
 22 | var/
 23 | wheels/
 24 | pip-wheel-metadata/
 25 | share/python-wheels/
 26 | *.egg-info/
 27 | .installed.cfg
 28 | *.egg
 29 | MANIFEST
 30 | 
 31 | # PyInstaller
 32 | #  Usually these files are written by a python script from a template
 33 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 34 | *.manifest
 35 | *.spec
 36 | 
 37 | # Installer logs
 38 | pip-log.txt
 39 | pip-delete-this-directory.txt
 40 | 
 41 | # Unit test / coverage reports
 42 | htmlcov/
 43 | .tox/
 44 | .nox/
 45 | .coverage
 46 | .coverage.*
 47 | .cache
 48 | nosetests.xml
 49 | coverage.xml
 50 | *.cover
 51 | *.py,cover
 52 | .hypothesis/
 53 | .pytest_cache/
 54 | 
 55 | # Translations
 56 | *.mo
 57 | *.pot
 58 | 
 59 | # Django stuff:
 60 | *.log
 61 | local_settings.py
 62 | db.sqlite3
 63 | db.sqlite3-journal
 64 | 
 65 | # Flask stuff:
 66 | instance/
 67 | .webassets-cache
 68 | 
 69 | # Scrapy stuff:
 70 | .scrapy
 71 | 
 72 | # Sphinx documentation
 73 | docs/_build/
 74 | 
 75 | # PyBuilder
 76 | target/
 77 | 
 78 | # Jupyter Notebook
 79 | .ipynb_checkpoints
 80 | 
 81 | # IPython
 82 | profile_default/
 83 | ipython_config.py
 84 | 
 85 | # pyenv
 86 | .python-version
 87 | 
 88 | # pipenv
 89 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 90 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 91 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 92 | #   install all needed dependencies.
 93 | #Pipfile.lock
 94 | 
 95 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 96 | __pypackages__/
 97 | 
 98 | # Celery stuff
 99 | celerybeat-schedule
100 | celerybeat.pid
101 | 
102 | # SageMath parsed files
103 | *.sage.py
104 | 
105 | # Environments
106 | .env
107 | .venv
108 | env/
109 | venv/
110 | ENV/
111 | env.bak/
112 | venv.bak/
113 | 
114 | # Spyder project settings
115 | .spyderproject
116 | .spyproject
117 | 
118 | # Rope project settings
119 | .ropeproject
120 | 
121 | # mkdocs documentation
122 | /site
123 | 
124 | # mypy
125 | .mypy_cache/
126 | .dmypy.json
127 | dmypy.json
128 | 
129 | # Pyre type checker
130 | .pyre/


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "docs/_build/html"]
2 | 	path = docs/_build/html
3 | 	url = https://github.com/hanjinliu/impy
4 | 	branch = gh-pages
5 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | repos:
 2 |   - repo: https://github.com/pre-commit/pre-commit-hooks
 3 |     rev: v4.4.0
 4 |     hooks:
 5 |       - id: end-of-file-fixer
 6 |       - id: trailing-whitespace
 7 |   - repo: https://github.com/asottile/pyupgrade
 8 |     rev: v3.3.1
 9 |     hooks:
10 |       - id: pyupgrade
11 |         args: ["--keep-runtime-typing"]
12 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2021, hanjinliu
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this
10 |    list of conditions and the following disclaimer.
11 | 
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 |    this list of conditions and the following disclaimer in the documentation
14 |    and/or other materials provided with the distribution.
15 | 
16 | 3. Neither the name of the copyright holder nor the names of its
17 |    contributors may be used to endorse or promote products derived from
18 |    this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![BSD 3-Clause License](https://img.shields.io/pypi/l/impy-array.svg?color=green)](https://github.com/hanjinliu/impy/blob/main/LICENSE)
  2 | [![Python package index download statistics](https://img.shields.io/pypi/dm/impy-array.svg)](https://pypistats.org/packages/impy-array)
  3 | [![PyPI version](https://badge.fury.io/py/impy-array.svg)](https://badge.fury.io/py/impy-array)
  4 | 
  5 | # impy
  6 | 
  7 | `impy` is an all-in-one multi-dimensional image analysis library. The core array,
  8 | `ImgArray`, is a subclass of `numpy.ndarray`, tagged with information such as:
  9 | 
 10 | - image axes
 11 | - scale of each axis
 12 | - directory of the original image
 13 | - and other image metadata
 14 | 
 15 | ## Documentation
 16 | 
 17 | Documentation is available [here](https://hanjinliu.github.io/impy/).
 18 | 
 19 | ## Installation
 20 | 
 21 | - use pip
 22 | 
 23 | ``` sh
 24 | pip install impy-array
 25 | pip install impy-array[tiff]    # with supports for reading/writing .tif files
 26 | pip install impy-array[mrc]     # with supports for reading/writing .mrc files
 27 | pip install impy-array[napari]  # viewer support
 28 | pip install impy-array[all]     # install everything
 29 | ```
 30 | 
 31 | - from source
 32 | 
 33 | ```
 34 | git clone https://github.com/hanjinliu/impy
 35 | ```
 36 | 
 37 | ### Code as fast as you speak
 38 | 
 39 | Almost all the functions, such as filtering, deconvolution, labeling, single molecule
 40 | detection, and even those pure `numpy` functions, are aware of image metadata. They
 41 | "know" which dimension corresponds to `"z"` axis, which axes they should iterate along
 42 | or where to save the image. As a result, **your code will be very concise**:
 43 | 
 44 | ```python
 45 | import impy as ip
 46 | import numpy as np
 47 | 
 48 | img = ip.imread("path/to/image.tif")   # Read images with metadata.
 49 | img["z=3;t=0"].imshow()                # Plot image slice at z=3 and t=0.
 50 | img["y=N//4:N//4*3"].imshow()          # `N` for the size of the axis.
 51 | img_fil = img.gaussian_filter(sigma=2) # Paralell batch denoising. No more for loop!
 52 | img_prj = np.max(img_fil, axis="z")    # Z-projection (numpy is aware of image axes!).
 53 | img_prj.imsave("image_max.tif")        # Save in the same place. Don't spend time on searching for the directory!
 54 | ```
 55 | 
 56 | ### Supports many file formats
 57 | 
 58 | `impy` automatically chooses the proper reader/writer according to the extension.
 59 | 
 60 | - Tiff file (".tif", ".tiff")
 61 | - LSM file (".lsm")
 62 | - MRC file (".mrc", ".rec", ".st", ".map", ".map.gz")
 63 | - Zarr file (".zarr")
 64 | - ND2 file (".nd2")
 65 | - Other image file (".png", ".jpg")
 66 | 
 67 | ### Lazy loading
 68 | 
 69 | With the `lazy` submodule, you can easily make image processing workflows for large
 70 | images.
 71 | 
 72 | ```python
 73 | import impy as ip
 74 | 
 75 | img = ip.lazy.imread("path/to/very-large-image.tif")
 76 | out = img.gaussian_filter()
 77 | out.imsave("image_filtered.tif")
 78 | ```
 79 | 
 80 | ### Switch between CPU and GPU
 81 | 
 82 | `impy` can internally switches the functions between `numpy` and `cupy`.
 83 | 
 84 | ```python
 85 | img.gaussian_filter()  # <- CPU
 86 | with ip.use("cupy"):
 87 |     img.gaussian_filter()  # <- GPU
 88 | ip.Const["RESOURCE"] = "cupy"  # <- globally use GPU
 89 | ```
 90 | 
 91 | ### Seamless interface between `napari`
 92 | 
 93 | [napari](https://github.com/napari/napari) is an interactive viewer for multi-dimensional
 94 | images. `impy` has a **simple and efficient interface** with it, via the object `ip.gui`.
 95 | Since `ImgArray` is tagged with image metadata, you don't have to care about axes or
 96 | scales. Just run
 97 | 
 98 | ```python
 99 | ip.gui.add(img)
100 | ```
101 | 
102 | ### Extend your function for batch processing
103 | 
104 | Already have a function for `numpy` and `scipy`? Decorate it with `@ip.bind`
105 | 
106 | ```python
107 | @ip.bind
108 | def imfilter(img, param=None):
109 |     # Your function here.
110 |     # Do something on a 2D or 3D image and return image, scalar or labels
111 |     return out
112 | ```
113 | 
114 | and it's ready for batch processing!
115 | 
116 | ```python
117 | img.imfilter(param=1.0)
118 | ```
119 | 
120 | ### Command line usage
121 | 
122 | `impy` also supports command-line-based image analysis. All methods of `ImgArray` are
123 | available from the command line, such as
124 | 
125 | ```shell
126 | impy path/to/image.tif ./output.tif --method gaussian_filter --sigma 2.0
127 | ```
128 | 
129 | which is equivalent to
130 | 
131 | ```python
132 | import impy as ip
133 | img = ip.imread("path/to/image.tif")
134 | out = img.gaussian_filter(sigma=2.0)
135 | out.imsave("./output.tif")
136 | ```
137 | 
138 | For more complex procedures, it is possible to send images directly to `IPython`
139 | 
140 | ```
141 | impy path/to/image.tif -i
142 | ```
143 | 
144 | ```python
145 | thr = img.gaussian_filter().threshold()
146 | ```
147 | 


--------------------------------------------------------------------------------
/docs/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: 13bf4155d1ddbde13c39e6754206c4a7
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/docs/.doctrees/api.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/api.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.arrays.bases.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.arrays.bases.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.arrays.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.arrays.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.axes.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.axes.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.frame.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.frame.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.lazy.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.lazy.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.utils.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.utils.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/impy.viewer.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/impy.viewer.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/apidoc/modules.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/apidoc/modules.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/environment.pickle


--------------------------------------------------------------------------------
/docs/.doctrees/gallary/regionprops.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/gallary/regionprops.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/gallery/drift_correction.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/gallery/drift_correction.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/gallery/filters.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/gallery/filters.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/gallery/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/gallery/index.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/gallery/regionprops.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/gallery/regionprops.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/index.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/tutoral_axes.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/tutoral_axes.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/tutorial.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/tutorial.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/tutorial_axes.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/tutorial_axes.doctree


--------------------------------------------------------------------------------
/docs/.doctrees/tutorial_cmd.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.doctrees/tutorial_cmd.doctree


--------------------------------------------------------------------------------
/docs/.nojekyll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/.nojekyll


--------------------------------------------------------------------------------
/docs/_sources/api.rst.txt:
--------------------------------------------------------------------------------
 1 | API References
 2 | ==============
 3 | 
 4 | .. toctree::
 5 |    :maxdepth: 2
 6 |    :caption: Contents:
 7 | 
 8 |    ./apidoc/impy
 9 |    ./apidoc/impy.arrays
10 |    ./apidoc/impy.frames
11 |    ./apidoc/impy.viewer
12 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.arrays.bases.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.arrays.bases package
 2 | =========================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.arrays.bases.metaarray module
 8 | ----------------------------------
 9 | 
10 | .. automodule:: impy.arrays.bases.metaarray
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.arrays.bases.overload module
16 | ---------------------------------
17 | 
18 | .. automodule:: impy.arrays.bases.overload
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.arrays.bases
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.arrays.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.arrays package
 2 | ===================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    impy.arrays.bases
11 | 
12 | Submodules
13 | ----------
14 | 
15 | impy.arrays.axesmixin module
16 | ----------------------------
17 | 
18 | .. automodule:: impy.arrays.axesmixin
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | impy.arrays.big module
24 | ----------------------
25 | 
26 | .. automodule:: impy.arrays.big
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | impy.arrays.imgarray module
32 | ---------------------------
33 | 
34 | .. automodule:: impy.arrays.imgarray
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | impy.arrays.label module
40 | ------------------------
41 | 
42 | .. automodule:: impy.arrays.label
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | impy.arrays.labeledarray module
48 | -------------------------------
49 | 
50 | .. automodule:: impy.arrays.labeledarray
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | impy.arrays.lazy module
56 | -----------------------
57 | 
58 | .. automodule:: impy.arrays.lazy
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 
63 | impy.arrays.phasearray module
64 | -----------------------------
65 | 
66 | .. automodule:: impy.arrays.phasearray
67 |    :members:
68 |    :undoc-members:
69 |    :show-inheritance:
70 | 
71 | impy.arrays.specials module
72 | ---------------------------
73 | 
74 | .. automodule:: impy.arrays.specials
75 |    :members:
76 |    :undoc-members:
77 |    :show-inheritance:
78 | 
79 | impy.arrays.tiled module
80 | ------------------------
81 | 
82 | .. automodule:: impy.arrays.tiled
83 |    :members:
84 |    :undoc-members:
85 |    :show-inheritance:
86 | 
87 | Module contents
88 | ---------------
89 | 
90 | .. automodule:: impy.arrays
91 |    :members:
92 |    :undoc-members:
93 |    :show-inheritance:
94 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.axes.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.axes package
 2 | =================
 3 | 
 4 | Module contents
 5 | ---------------
 6 | 
 7 | .. automodule:: impy.axes
 8 |    :members:
 9 |    :undoc-members:
10 |    :show-inheritance:
11 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.frame.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.frame package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.frame.frames module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.frame.frames
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: impy.frame
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.lazy.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.lazy package
 2 | =================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.lazy.core module
 8 | ---------------------
 9 | 
10 | .. automodule:: impy.lazy.core
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.lazy.random module
16 | -----------------------
17 | 
18 | .. automodule:: impy.lazy.random
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.lazy
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.rst.txt:
--------------------------------------------------------------------------------
 1 | impy package
 2 | ============
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    impy.arrays
11 |    impy.axes
12 |    impy.frame
13 |    impy.lazy
14 |    impy.utils
15 |    impy.viewer
16 | 
17 | Submodules
18 | ----------
19 | 
20 | impy.array\_api module
21 | ----------------------
22 | 
23 | .. automodule:: impy.array_api
24 |    :members:
25 |    :undoc-members:
26 |    :show-inheritance:
27 | 
28 | impy.binder module
29 | ------------------
30 | 
31 | .. automodule:: impy.binder
32 |    :members:
33 |    :undoc-members:
34 |    :show-inheritance:
35 | 
36 | impy.collections module
37 | -----------------------
38 | 
39 | .. automodule:: impy.collections
40 |    :members:
41 |    :undoc-members:
42 |    :show-inheritance:
43 | 
44 | impy.core module
45 | ----------------
46 | 
47 | .. automodule:: impy.core
48 |    :members:
49 |    :undoc-members:
50 |    :show-inheritance:
51 | 
52 | impy.correlation module
53 | -----------------------
54 | 
55 | .. automodule:: impy.correlation
56 |    :members:
57 |    :undoc-members:
58 |    :show-inheritance:
59 | 
60 | impy.io module
61 | --------------
62 | 
63 | .. automodule:: impy.io
64 |    :members:
65 |    :undoc-members:
66 |    :show-inheritance:
67 | 
68 | impy.random module
69 | ------------------
70 | 
71 | .. automodule:: impy.random
72 |    :members:
73 |    :undoc-members:
74 |    :show-inheritance:
75 | 
76 | impy.roi module
77 | ---------------
78 | 
79 | .. automodule:: impy.roi
80 |    :members:
81 |    :undoc-members:
82 |    :show-inheritance:
83 | 
84 | Module contents
85 | ---------------
86 | 
87 | .. automodule:: impy
88 |    :members:
89 |    :undoc-members:
90 |    :show-inheritance:
91 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.utils.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.utils package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.utils.axesop module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.utils.axesop
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.utils.deco module
16 | ----------------------
17 | 
18 | .. automodule:: impy.utils.deco
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | impy.utils.gauss module
24 | -----------------------
25 | 
26 | .. automodule:: impy.utils.gauss
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | impy.utils.misc module
32 | ----------------------
33 | 
34 | .. automodule:: impy.utils.misc
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | impy.utils.slicer module
40 | ------------------------
41 | 
42 | .. automodule:: impy.utils.slicer
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | impy.utils.utilcls module
48 | -------------------------
49 | 
50 | .. automodule:: impy.utils.utilcls
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | Module contents
56 | ---------------
57 | 
58 | .. automodule:: impy.utils
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/impy.viewer.rst.txt:
--------------------------------------------------------------------------------
 1 | impy.viewer package
 2 | ===================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.viewer.utils module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.viewer.utils
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.viewer.viewer module
16 | -------------------------
17 | 
18 | .. automodule:: impy.viewer.viewer
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.viewer
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/docs/_sources/apidoc/modules.rst.txt:
--------------------------------------------------------------------------------
1 | impy
2 | ====
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 |    impy
8 | 


--------------------------------------------------------------------------------
/docs/_sources/gallery/drift_correction.rst.txt:
--------------------------------------------------------------------------------
  1 | ================
  2 | Drift Correction
  3 | ================
  4 | 
  5 | Stage shift during image acquisition is a general problem of microscopy.
  6 | Here shows how to correct the shift using ``drift_correction`` method.
  7 | 
  8 | .. contents:: Contents
  9 |     :local:
 10 |     :depth: 1
 11 | 
 12 | 
 13 | Simplest Correction
 14 | ===================
 15 | 
 16 | We'll create a sample image stack by applying random shifts to an image using ``affine`` method
 17 | and Gaussian noise using ``ip.random.normal`` function.
 18 | 
 19 | .. code-block:: python
 20 |     
 21 |     import numpy as np
 22 |     import impy as ip
 23 | 
 24 |     t_total = 10
 25 |     max_shift = 6
 26 |     img0 = ip.zeros((64, 64))
 27 |     img0[28:36, 22:30] += 1.0
 28 | 
 29 |     imgs = []
 30 |     shifts = (2 * np.random.random((t_total, 2)) - 1.0) * max_shift  # random shift
 31 |     for shift in shifts:
 32 |         img_shift = img0.affine(translation=shift) + ip.random.normal(scale=0.3, size=(64, 64)) 
 33 |         imgs.append(img_shift)
 34 | 
 35 |     img = np.stack(imgs, axis="t")
 36 | 
 37 | The ``img`` is a 3-D image stack with a randomly shifting rectangle in the center.
 38 | 
 39 | ``drift_correction`` method uses phase cross-correlation to track drift and restore non-drifted
 40 | image by Affine transformation. Relative shift between neighbors are calculated.
 41 | 
 42 | It is very simple to obtain the corrected image.
 43 | 
 44 | .. code-block:: python
 45 | 
 46 |     img_corrected = img.drift_correction()
 47 |     img_corrected = img.drift_correction(along="t")  # explicitly specify the "time" axis.
 48 |     
 49 |     img_corrected.imshow()
 50 | 
 51 | Multi-dimensional Correction
 52 | ============================
 53 | 
 54 | By default, ``drift_correction`` consider ``"y", "x"`` axes as the spatial dimensions and conduct
 55 | 2-D correction unlike many of other methods. This is because image drift usually occurs in XY
 56 | direction. The example below:
 57 | 
 58 | .. code-block:: python
 59 | 
 60 |     img4d = ip.random.normal(size=(10, 4, 64, 64), axes="tzyx")
 61 |     img_corrected = img4d.drift_correction()
 62 | 
 63 | is almost equal to:
 64 | 
 65 | .. code-block:: python
 66 | 
 67 |     out = []
 68 |     for z in range(4):
 69 |         out.append(img4d[:, z].drift_correction())
 70 |     img_corrected = np.stack(out, axis="z")
 71 | 
 72 | .. note::
 73 | 
 74 |     ``drift_correct`` uses the most plausible axis as the "time" axis. To avoid unexpected error
 75 |     you should specify ``along`` argument when correction >4 dimensional images.
 76 | 
 77 | Correction with Reference
 78 | =========================
 79 | 
 80 | Sometimes you may want to supply a "reference" image stack to determine drift, instead of using 
 81 | the image itself. There are many occasions that you should think of this.
 82 | 
 83 | - Multi-channel image. In most cases, image shifts are the same among all the channels. You
 84 |   may want to choose one of the channels (a channel that is the most static) for tracking.
 85 | - Images with strong noises. You should not use the region of an image stack if that region 
 86 |   contains such kind of noises. For instance, cropping the image at its edges like
 87 |   ``img["y=40:-40;x=40:-40"]`` will be helpful.
 88 | - Use calculated images. A simple case is to use a filtrated reference image stack.
 89 | 
 90 | ``drift_correction`` takes ``ref`` argument to do this. If ``ref`` is given, ``drift_correction``
 91 | checks dimensionalities of the image to correct and the reference image and can flexibly apply
 92 | tracking and correction.
 93 | 
 94 | .. code-block:: python
 95 | 
 96 |     # Use the first channel to track drift of a multi-channel image
 97 |     img = ip.random.normal((10, 3, 64, 64), axes="tcyx")
 98 |     img_corrected = img.drift_correction(ref=img["c=0"])
 99 | 
100 |     # Use the center of an image
101 |     img = ip.random.normal((10, 8, 64, 64), axes="tzyx")
102 |     img_corrected = img.drift_correction(ref=img["y=40:-40;x=40:-40"])
103 | 
104 |     # Use Gaussian-filtrated image
105 |     img = ip.random.normal((10, 8, 64, 64), axes="tzyx")
106 |     img_corrected = img.drift_correction(ref=img.gaussian_filter())
107 | 
108 | Correct Large Images
109 | ====================
110 | 
111 | TODO


--------------------------------------------------------------------------------
/docs/_sources/gallery/index.rst.txt:
--------------------------------------------------------------------------------
 1 | =======
 2 | Gallery
 3 | =======
 4 | 
 5 | .. toctree::
 6 |    :maxdepth: 1
 7 | 
 8 |    filters
 9 |    regionprops
10 | 


--------------------------------------------------------------------------------
/docs/_sources/gallery/regionprops.rst.txt:
--------------------------------------------------------------------------------
  1 | ========================
  2 | Labeling and Measurement
  3 | ========================
  4 | 
  5 | Here we're going to label a image and measure some features for each label.
  6 | 
  7 | .. contents:: Contents
  8 |     :local:
  9 |     :depth: 1
 10 | 
 11 | Basics
 12 | ------
 13 | 
 14 | Get the sample image.
 15 | 
 16 | .. code-block:: python
 17 | 
 18 |     import impy as ip
 19 |     img = ip.sample_image("coins")
 20 | 
 21 | There are two methods for image labeling.
 22 | 
 23 | - ``label`` ... labeling image with the input reference.
 24 | - ``label_threshold`` ... labeling image with the binarized image as the reference. It can be 
 25 |   considered as a shortcut of ``img.label(img.threshold())``.
 26 | 
 27 | Both method returns a ``Label`` array, a subclass of ``MetaArray``.
 28 | 
 29 | Simple labeling
 30 | ---------------
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     img.label_threshold()
 35 | 
 36 | .. code-block::
 37 | 
 38 |     Label of
 39 |           name      : coins
 40 |          shape      : 303(y), 384(x)
 41 |          dtype      : uint8
 42 |          source     : None
 43 |          scale      : ScaleView(y=1.0, x=1.0)
 44 | 
 45 | The ``Label`` is tagged to the image itself.
 46 | 
 47 | .. code-block:: python
 48 | 
 49 |     img.labels
 50 | 
 51 | .. code-block::
 52 | 
 53 |     Label of
 54 |           name      : coins
 55 |          shape      : 303(y), 384(x)
 56 |          dtype      : uint8
 57 |          source     : None
 58 |          scale      : ScaleView(y=1.0, x=1.0)
 59 | 
 60 | Slicing of image covariantly slices the labels at the same time.
 61 | 
 62 | .. code-block:: python
 63 | 
 64 |     img[100:200, 53].labels
 65 | 
 66 | .. code-block::
 67 | 
 68 |     Label of
 69 |           name      : coins
 70 |          shape      : 100(y)
 71 |          dtype      : uint8
 72 |          source     : None
 73 |          scale      : ScaleView(y=1.0)
 74 | 
 75 | Image with label overlay can be visualized by ``imshow`` method or using ``napari`` viewer.
 76 | 
 77 | .. code-block:: python
 78 | 
 79 |     img.imshow(label=True)  # use matplotlib to show images
 80 |     ip.gui.add(img)  # use napari to show images
 81 | 
 82 | Measurement
 83 | -----------
 84 | 
 85 | After labeling, ``regionprops`` method is useful for image measurement. This method runs 
 86 | ``skimage.measure.regionprops`` inside.
 87 | 
 88 | .. code-block:: python
 89 | 
 90 |     props = img.regionprops(properties=("mean_intensity", "area", "major_axis_length"))
 91 |     props
 92 | 
 93 | .. code-block::
 94 |     
 95 |     DataDict[PropArray] with 3 components:
 96 |     'mean_intensity' => PropArray of
 97 |           name      : coins-prop
 98 |          shape      : 98(N)
 99 |          dtype      : float32
100 |          source     : None
101 |      property name  : mean_intensity
102 |     ,
103 |     'area' => PropArray of
104 |           name      : coins-prop
105 |          shape      : 98(N)
106 |          dtype      : float32
107 |          source     : None
108 |      property name  : area
109 |     ,
110 |     'major_axis_length' => PropArray of
111 |           name      : coins-prop
112 |          shape      : 98(N)
113 |          dtype      : float32
114 |          source     : None
115 |      property name  : major_axis_length
116 | 
117 | The returned ``DataDict`` object is a ``dict``-like object. Its value is assured to be the same
118 | type so that you can easily apply a same method to all the components (see :doc:`../tutorial.rst`).
119 | Since "mean_intensity", "area" and "major_axis_length" are chosen for measurement, ``props`` has
120 | keys "mean_intensity", "area" and "major_axis_length".
121 | 
122 | Here, ``props`` is a ``DataDict`` of ``PropArray``. ``PropArray`` is a subclass of ``MetaArray``
123 | that is specialized in storing properties.
124 | 
125 | All the properties can be summerized as follows.
126 | 
127 | .. code-block:: python
128 | 
129 |     # since PropArray has method `mean`, this line will apply `mean` to all the components.
130 |     props.mean()
131 | 
132 | .. code-block::
133 | 
134 |     DataDict[float32] with 3 components:
135 |     'mean_intensity' => 122.47181,
136 |     'area' => 465.52042,
137 |     'major_axis_length' => 15.488672
138 | 
139 | .. code-block:: python
140 | 
141 |     # PropArray has a visualization method `hist`.
142 |     props.hist()
143 | 
144 | Conditional Labeling
145 | --------------------
146 | 
147 | Simple labeling based on thresholding always yields in insufficient results. 
148 | 
149 | The ``filt`` argument can filter labels based on properties of image and labels.
150 | Basic usage is following. Filter function must take at least two argument, image itself and
151 | newly created label region.
152 | 
153 | .. code-block:: python
154 | 
155 |     def filt(img, lbl):
156 |         """Return true if label passes a criterion you set."""
157 |     
158 |     img.label_threshold(filt=filt)
159 | 
160 | You can use additional arguments with names same as those properties supported in
161 | ``regionprops``. For instance, you can label regions only satisfies proper area and length 
162 | using following filter function.
163 | 
164 | .. code-block:: python
165 | 
166 |     def filt(img, lbl, area, major_axis_length):
167 |         proper_size = 10 < area < 60**2
168 |         proper_shape = 20 < major_axis_length < 120
169 |         return proper_size and proper_shape
170 |     
171 |     img.label_threshold(filt=filt)
172 | 


--------------------------------------------------------------------------------
/docs/_sources/index.rst.txt:
--------------------------------------------------------------------------------
  1 | .. impy documentation master file, created by
  2 |    sphinx-quickstart on Mon Jul 26 15:21:04 2021.
  3 |    You can adapt this file completely to your liking, but it should at least
  4 |    contain the root `toctree` directive.
  5 | 
  6 | impy
  7 | ====
  8 | 
  9 | ``impy`` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and 
 10 | so on.
 11 | 
 12 | `Source code <https://github.com/hanjinliu/impy>`_
 13 | 
 14 | 
 15 | Highlights
 16 | ----------
 17 | 
 18 | - Automatic parallel batch processing using ``dask``.
 19 | 
 20 | - You don't have to care about ``numpy`` / ``scipy`` on CPU, or ``cupy`` on GPU. Same code works for both processors.
 21 | 
 22 | - n-D viewing, cropping, image annotation using ``napari``.
 23 | 
 24 | - Easily integrate your custom functions with ``@ip.bind``.
 25 | 
 26 | - Command line usage.
 27 | 
 28 | 
 29 | Installation
 30 | ------------
 31 | 
 32 | .. code-block:: shell
 33 | 
 34 |    pip install git+https://github.com/hanjinliu/impy
 35 | 
 36 | 
 37 | or
 38 | 
 39 | .. code-block:: shell
 40 | 
 41 |    git clone https://github.com/hanjinliu/impy
 42 | 
 43 | Contents
 44 | --------
 45 | 
 46 | .. toctree::
 47 |    :maxdepth: 1
 48 | 
 49 |    tutorial
 50 |    tutorial_axes
 51 |    tutorial_cmd
 52 |    ./gallery/index
 53 |    api
 54 |    
 55 | 
 56 | Major Classes
 57 | -------------
 58 | 
 59 | Array
 60 | ^^^^^
 61 | 
 62 | .. blockdiag::
 63 |    
 64 |    blockdiag {
 65 |       orientation = portrait
 66 |       
 67 |       numpy.ndarray -> MetaArray -> LabeledArray -> ImgArray;
 68 |       AxesMixin -> MetaArray;
 69 |       MetaArray -> PropArray;
 70 |       MetaArray -> Label;
 71 |       LabeledArray -> PhaseArray;
 72 |       
 73 |       PropArray [color = pink];
 74 |       Label [color = pink];
 75 |       ImgArray [color = pink];
 76 |       PhaseArray [color = pink];
 77 |    }
 78 | 
 79 | - ``AxesMixin``: An abstract class that axes, scale and shape are defined.
 80 | 
 81 | - ``PropArray``: Array object with properties stored in it. Always made from an ``ImgArray``.
 82 | 
 83 | - ``Label``: Array object of image labels that is attached to ``ImgArray``.
 84 | 
 85 | - ``ImgArray``: Array object with many image processing functions.
 86 | 
 87 | - ``PhaseArray``: Array object with periodic values and specific processing functions.
 88 | 
 89 | 
 90 | Array-like
 91 | ^^^^^^^^^^
 92 | 
 93 | .. blockdiag::
 94 |    
 95 |    blockdiag {
 96 |       orientation = portrait
 97 | 
 98 |       AxesMixin -> LazyImgArray -> BigImgArray;
 99 |       LazyImgArray [color = pink];
100 |       BigImgArray [color = pink];
101 |    }
102 | 
103 | - ``LazyImgArray``: Array-like object with image processing functions like ``ImgArray``, but evaluated lazily.
104 | - ``BigImgArray``: Subclass of ``LazyImgArray``, but images will be processed for every method call.
105 | 
106 | 
107 | Data Frame  
108 | ^^^^^^^^^^
109 | 
110 | .. blockdiag::
111 |    
112 |    blockdiag {
113 |       orientation = portrait
114 | 
115 |       pandas.DataFrame -> AxesFrame -> MarkerFrame;
116 |       AxesFrame -> TrackFrame;
117 |       AxesFrame -> PathFrame;
118 |       
119 |       MarkerFrame [color = pink];
120 |       TrackFrame [color = pink];
121 |       PathFrame [color = pink];
122 |    }
123 | 
124 | - ``AxesFrame``: DataFrame with similar properties as ``AxesMixin``.
125 | 
126 | - ``MarkerFrame``: ``AxesFrame`` for markers, such as coordinates.
127 | 
128 | - ``TrackFrame``: ``AxesFrame`` for tracks.
129 | 
130 | - ``PathFrame``: ``AxesFrame`` for paths.
131 | 
132 | 
133 | 
134 | Indices and tables
135 | ==================
136 | 
137 | * :ref:`genindex`
138 | * :ref:`modindex`
139 | * :ref:`search`
140 | 


--------------------------------------------------------------------------------
/docs/_sources/tutorial_cmd.rst.txt:
--------------------------------------------------------------------------------
 1 | Command Line Usage
 2 | ==================
 3 | 
 4 | Image analysis usually relies on different softwares in different platform.
 5 | The traditional command line based interface is still useful in this purpose.
 6 | 
 7 | ``impy`` also supports command line usage.
 8 | 
 9 | Basic Usage
10 | -----------
11 | 
12 | The most basic one is:
13 | 
14 | .. code-block:: shell
15 | 
16 |     impy --input path/to/image.tif --output path/to/output.tif --method gaussian_filter --sigma 2
17 | 
18 | or ``--input`` and ``--output`` can be omitted like:
19 | 
20 | .. code-block:: shell
21 | 
22 |     impy path/to/image.tif path/to/output.tif --method gaussian_filter --sigma 2
23 | 
24 | You have to specify ``--method`` or ``-m`` to let ``impy`` know what method you'd like to run.
25 | Method names should match those in ``ImgArray``. The last ``--sigma`` option is characteristic 
26 | to ``gaussian_filter`` so that it may differ with other method.
27 | Those commands above are equivalent to following Python code.
28 | 
29 | .. code-block:: python
30 | 
31 |     import impy as ip
32 |     img = ip.imread("path/to/image.tif")
33 |     out = img.gaussian_filter(sigma=2)
34 |     out.imsave("path/to/output.tif")
35 | 
36 | 
37 | Advanced Usage
38 | --------------
39 | 
40 | Sometimes you may want to apply multiple filters in tandem to an image. Classically it was
41 | usually done by saving intermediate files, but here we should take advantage of IPython.
42 | 
43 | Instead of parsing ``--output``, you can use ``-i`` flag to launch IPython interpreter with
44 | namespace ``ip`` and ``img``. ``ip`` is an alias of ``impy`` as usual, and ``img`` is an
45 | ``ImgArray`` object that is created by reading the ``--input`` argument.
46 | 
47 | .. code-block:: shell
48 | 
49 |     impy path/to/image.tif -i
50 | 
51 | .. code-block:: python
52 | 
53 |     >>> arr = ip.random.random((100, 120))  # "ip" is already available
54 |     >>> out = img + arr  # img = ip.imread("path/to/image.tif")
55 |     >>> out.imsave("path/to/output.tif")
56 | 
57 | Another option is ``-n``, which send namespace including input image to ``napari`` viewer
58 | and console.
59 | 
60 | .. code-block:: shell
61 | 
62 |     impy path/to/image.tif -n
63 | 


--------------------------------------------------------------------------------
/docs/_static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}


--------------------------------------------------------------------------------
/docs/_static/css/fonts/Roboto-Slab-Bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/Roboto-Slab-Bold.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/Roboto-Slab-Bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/Roboto-Slab-Bold.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/Roboto-Slab-Regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/Roboto-Slab-Regular.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/Roboto-Slab-Regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/Roboto-Slab-Regular.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/_static/css/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/_static/css/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/fontawesome-webfont.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/fontawesome-webfont.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-bold-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-bold-italic.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-bold-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-bold-italic.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-bold.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-bold.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-normal-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-normal-italic.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-normal-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-normal-italic.woff2


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-normal.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-normal.woff


--------------------------------------------------------------------------------
/docs/_static/css/fonts/lato-normal.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/css/fonts/lato-normal.woff2


--------------------------------------------------------------------------------
/docs/_static/doctools.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * doctools.js
  3 |  * ~~~~~~~~~~~
  4 |  *
  5 |  * Base JavaScript utilities for all Sphinx HTML documentation.
  6 |  *
  7 |  * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
  8 |  * :license: BSD, see LICENSE for details.
  9 |  *
 10 |  */
 11 | "use strict";
 12 | 
 13 | const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([
 14 |   "TEXTAREA",
 15 |   "INPUT",
 16 |   "SELECT",
 17 |   "BUTTON",
 18 | ]);
 19 | 
 20 | const _ready = (callback) => {
 21 |   if (document.readyState !== "loading") {
 22 |     callback();
 23 |   } else {
 24 |     document.addEventListener("DOMContentLoaded", callback);
 25 |   }
 26 | };
 27 | 
 28 | /**
 29 |  * Small JavaScript module for the documentation.
 30 |  */
 31 | const Documentation = {
 32 |   init: () => {
 33 |     Documentation.initDomainIndexTable();
 34 |     Documentation.initOnKeyListeners();
 35 |   },
 36 | 
 37 |   /**
 38 |    * i18n support
 39 |    */
 40 |   TRANSLATIONS: {},
 41 |   PLURAL_EXPR: (n) => (n === 1 ? 0 : 1),
 42 |   LOCALE: "unknown",
 43 | 
 44 |   // gettext and ngettext don't access this so that the functions
 45 |   // can safely bound to a different name (_ = Documentation.gettext)
 46 |   gettext: (string) => {
 47 |     const translated = Documentation.TRANSLATIONS[string];
 48 |     switch (typeof translated) {
 49 |       case "undefined":
 50 |         return string; // no translation
 51 |       case "string":
 52 |         return translated; // translation exists
 53 |       default:
 54 |         return translated[0]; // (singular, plural) translation tuple exists
 55 |     }
 56 |   },
 57 | 
 58 |   ngettext: (singular, plural, n) => {
 59 |     const translated = Documentation.TRANSLATIONS[singular];
 60 |     if (typeof translated !== "undefined")
 61 |       return translated[Documentation.PLURAL_EXPR(n)];
 62 |     return n === 1 ? singular : plural;
 63 |   },
 64 | 
 65 |   addTranslations: (catalog) => {
 66 |     Object.assign(Documentation.TRANSLATIONS, catalog.messages);
 67 |     Documentation.PLURAL_EXPR = new Function(
 68 |       "n",
 69 |       `return (${catalog.plural_expr})`
 70 |     );
 71 |     Documentation.LOCALE = catalog.locale;
 72 |   },
 73 | 
 74 |   /**
 75 |    * helper function to focus on search bar
 76 |    */
 77 |   focusSearchBar: () => {
 78 |     document.querySelectorAll("input[name=q]")[0]?.focus();
 79 |   },
 80 | 
 81 |   /**
 82 |    * Initialise the domain index toggle buttons
 83 |    */
 84 |   initDomainIndexTable: () => {
 85 |     const toggler = (el) => {
 86 |       const idNumber = el.id.substr(7);
 87 |       const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`);
 88 |       if (el.src.substr(-9) === "minus.png") {
 89 |         el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`;
 90 |         toggledRows.forEach((el) => (el.style.display = "none"));
 91 |       } else {
 92 |         el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`;
 93 |         toggledRows.forEach((el) => (el.style.display = ""));
 94 |       }
 95 |     };
 96 | 
 97 |     const togglerElements = document.querySelectorAll("img.toggler");
 98 |     togglerElements.forEach((el) =>
 99 |       el.addEventListener("click", (event) => toggler(event.currentTarget))
100 |     );
101 |     togglerElements.forEach((el) => (el.style.display = ""));
102 |     if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler);
103 |   },
104 | 
105 |   initOnKeyListeners: () => {
106 |     // only install a listener if it is really needed
107 |     if (
108 |       !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
109 |       !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS
110 |     )
111 |       return;
112 | 
113 |     document.addEventListener("keydown", (event) => {
114 |       // bail for input elements
115 |       if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
116 |       // bail with special keys
117 |       if (event.altKey || event.ctrlKey || event.metaKey) return;
118 | 
119 |       if (!event.shiftKey) {
120 |         switch (event.key) {
121 |           case "ArrowLeft":
122 |             if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
123 | 
124 |             const prevLink = document.querySelector('link[rel="prev"]');
125 |             if (prevLink && prevLink.href) {
126 |               window.location.href = prevLink.href;
127 |               event.preventDefault();
128 |             }
129 |             break;
130 |           case "ArrowRight":
131 |             if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
132 | 
133 |             const nextLink = document.querySelector('link[rel="next"]');
134 |             if (nextLink && nextLink.href) {
135 |               window.location.href = nextLink.href;
136 |               event.preventDefault();
137 |             }
138 |             break;
139 |         }
140 |       }
141 | 
142 |       // some keyboard layouts may need Shift to get /
143 |       switch (event.key) {
144 |         case "/":
145 |           if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break;
146 |           Documentation.focusSearchBar();
147 |           event.preventDefault();
148 |       }
149 |     });
150 |   },
151 | };
152 | 
153 | // quick alias for translations
154 | const _ = Documentation.gettext;
155 | 
156 | _ready(Documentation.init);
157 | 


--------------------------------------------------------------------------------
/docs/_static/documentation_options.js:
--------------------------------------------------------------------------------
 1 | var DOCUMENTATION_OPTIONS = {
 2 |     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
 3 |     VERSION: '2.3.0',
 4 |     LANGUAGE: 'en',
 5 |     COLLAPSE_INDEX: false,
 6 |     BUILDER: 'html',
 7 |     FILE_SUFFIX: '.html',
 8 |     LINK_SUFFIX: '.html',
 9 |     HAS_SOURCE: true,
10 |     SOURCELINK_SUFFIX: '.txt',
11 |     NAVIGATION_WITH_KEYS: false,
12 |     SHOW_SEARCH_SUMMARY: true,
13 |     ENABLE_SEARCH_SHORTCUTS: true,
14 | };


--------------------------------------------------------------------------------
/docs/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/file.png


--------------------------------------------------------------------------------
/docs/_static/js/badge_only.js:
--------------------------------------------------------------------------------
1 | !function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=4)}({4:function(e,t,r){}});


--------------------------------------------------------------------------------
/docs/_static/js/html5shiv-printshiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3-pre | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/_static/js/html5shiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/_static/js/theme.js:
--------------------------------------------------------------------------------
1 | !function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("<div class='wy-table-responsive'></div>"),n("table.docutils.footnote").wrap("<div class='wy-table-responsive footnote'></div>"),n("table.docutils.citation").wrap("<div class='wy-table-responsive citation'></div>"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n('<button class="toctree-expand" title="Open/close menu"></button>'),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t<e.length&&!window.requestAnimationFrame;++t)window.requestAnimationFrame=window[e[t]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[e[t]+"CancelAnimationFrame"]||window[e[t]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(e,t){var i=(new Date).getTime(),o=Math.max(0,16-(i-n)),r=window.setTimeout((function(){e(i+o)}),o);return n=i+o,r}),window.cancelAnimationFrame||(window.cancelAnimationFrame=function(n){clearTimeout(n)})}()}).call(window)},function(n,e){n.exports=jQuery},function(n,e,t){}]);


--------------------------------------------------------------------------------
/docs/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/minus.png


--------------------------------------------------------------------------------
/docs/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/_static/plus.png


--------------------------------------------------------------------------------
/docs/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | pre { line-height: 125%; }
 2 | td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
 3 | span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
 4 | td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 5 | span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 6 | .highlight .hll { background-color: #ffffcc }
 7 | .highlight { background: #f8f8f8; }
 8 | .highlight .c { color: #3D7B7B; font-style: italic } /* Comment */
 9 | .highlight .err { border: 1px solid #FF0000 } /* Error */
10 | .highlight .k { color: #008000; font-weight: bold } /* Keyword */
11 | .highlight .o { color: #666666 } /* Operator */
12 | .highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */
13 | .highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */
14 | .highlight .cp { color: #9C6500 } /* Comment.Preproc */
15 | .highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */
16 | .highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */
17 | .highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */
18 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
19 | .highlight .ge { font-style: italic } /* Generic.Emph */
20 | .highlight .gr { color: #E40000 } /* Generic.Error */
21 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
22 | .highlight .gi { color: #008400 } /* Generic.Inserted */
23 | .highlight .go { color: #717171 } /* Generic.Output */
24 | .highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
25 | .highlight .gs { font-weight: bold } /* Generic.Strong */
26 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
27 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
28 | .highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
29 | .highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
30 | .highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
31 | .highlight .kp { color: #008000 } /* Keyword.Pseudo */
32 | .highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
33 | .highlight .kt { color: #B00040 } /* Keyword.Type */
34 | .highlight .m { color: #666666 } /* Literal.Number */
35 | .highlight .s { color: #BA2121 } /* Literal.String */
36 | .highlight .na { color: #687822 } /* Name.Attribute */
37 | .highlight .nb { color: #008000 } /* Name.Builtin */
38 | .highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
39 | .highlight .no { color: #880000 } /* Name.Constant */
40 | .highlight .nd { color: #AA22FF } /* Name.Decorator */
41 | .highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */
42 | .highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */
43 | .highlight .nf { color: #0000FF } /* Name.Function */
44 | .highlight .nl { color: #767600 } /* Name.Label */
45 | .highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
46 | .highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
47 | .highlight .nv { color: #19177C } /* Name.Variable */
48 | .highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
49 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
50 | .highlight .mb { color: #666666 } /* Literal.Number.Bin */
51 | .highlight .mf { color: #666666 } /* Literal.Number.Float */
52 | .highlight .mh { color: #666666 } /* Literal.Number.Hex */
53 | .highlight .mi { color: #666666 } /* Literal.Number.Integer */
54 | .highlight .mo { color: #666666 } /* Literal.Number.Oct */
55 | .highlight .sa { color: #BA2121 } /* Literal.String.Affix */
56 | .highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
57 | .highlight .sc { color: #BA2121 } /* Literal.String.Char */
58 | .highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */
59 | .highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
60 | .highlight .s2 { color: #BA2121 } /* Literal.String.Double */
61 | .highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */
62 | .highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
63 | .highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */
64 | .highlight .sx { color: #008000 } /* Literal.String.Other */
65 | .highlight .sr { color: #A45A77 } /* Literal.String.Regex */
66 | .highlight .s1 { color: #BA2121 } /* Literal.String.Single */
67 | .highlight .ss { color: #19177C } /* Literal.String.Symbol */
68 | .highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
69 | .highlight .fm { color: #0000FF } /* Name.Function.Magic */
70 | .highlight .vc { color: #19177C } /* Name.Variable.Class */
71 | .highlight .vg { color: #19177C } /* Name.Variable.Global */
72 | .highlight .vi { color: #19177C } /* Name.Variable.Instance */
73 | .highlight .vm { color: #19177C } /* Name.Variable.Magic */
74 | .highlight .il { color: #666666 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/docs/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/docs/objects.inv


--------------------------------------------------------------------------------
/docs/search.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html class="writer-html5" lang="en" >
  3 | <head>
  4 |   <meta charset="utf-8" />
  5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  6 |   <title>Search &mdash; impy 2.3.0 documentation</title>
  7 |       <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
  8 |       <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  9 |     
 10 |   <!--[if lt IE 9]>
 11 |     <script src="_static/js/html5shiv.min.js"></script>
 12 |   <![endif]-->
 13 |   
 14 |         <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
 15 |         <script src="_static/doctools.js"></script>
 16 |         <script src="_static/sphinx_highlight.js"></script>
 17 |     <script src="_static/js/theme.js"></script>
 18 |     <script src="_static/searchtools.js"></script>
 19 |     <script src="_static/language_data.js"></script>
 20 |     <link rel="index" title="Index" href="genindex.html" />
 21 |     <link rel="search" title="Search" href="#" /> 
 22 | </head>
 23 | 
 24 | <body class="wy-body-for-nav"> 
 25 |   <div class="wy-grid-for-nav">
 26 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 27 |       <div class="wy-side-scroll">
 28 |         <div class="wy-side-nav-search" >
 29 | 
 30 |           
 31 |           
 32 |           <a href="index.html" class="icon icon-home">
 33 |             impy
 34 |           </a>
 35 |               <div class="version">
 36 |                 2.3.0
 37 |               </div>
 38 | <div role="search">
 39 |   <form id="rtd-search-form" class="wy-form" action="#" method="get">
 40 |     <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
 41 |     <input type="hidden" name="check_keywords" value="yes" />
 42 |     <input type="hidden" name="area" value="default" />
 43 |   </form>
 44 | </div>
 45 |         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
 46 |               <ul>
 47 | <li class="toctree-l1"><a class="reference internal" href="tutorial.html">Tutorial</a></li>
 48 | <li class="toctree-l1"><a class="reference internal" href="tutorial_axes.html">Axes in impy</a></li>
 49 | <li class="toctree-l1"><a class="reference internal" href="tutorial_cmd.html">Command Line Usage</a></li>
 50 | <li class="toctree-l1"><a class="reference internal" href="gallery/index.html">Gallery</a></li>
 51 | <li class="toctree-l1"><a class="reference internal" href="api.html">API References</a></li>
 52 | </ul>
 53 | 
 54 |         </div>
 55 |       </div>
 56 |     </nav>
 57 | 
 58 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
 59 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
 60 |           <a href="index.html">impy</a>
 61 |       </nav>
 62 | 
 63 |       <div class="wy-nav-content">
 64 |         <div class="rst-content">
 65 |           <div role="navigation" aria-label="Page navigation">
 66 |   <ul class="wy-breadcrumbs">
 67 |       <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
 68 |       <li class="breadcrumb-item active">Search</li>
 69 |       <li class="wy-breadcrumbs-aside">
 70 |       </li>
 71 |   </ul>
 72 |   <hr/>
 73 | </div>
 74 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
 75 |            <div itemprop="articleBody">
 76 |              
 77 |   <noscript>
 78 |   <div id="fallback" class="admonition warning">
 79 |     <p class="last">
 80 |       Please activate JavaScript to enable the search functionality.
 81 |     </p>
 82 |   </div>
 83 |   </noscript>
 84 | 
 85 |   
 86 |   <div id="search-results">
 87 |   
 88 |   </div>
 89 | 
 90 |            </div>
 91 |           </div>
 92 |           <footer>
 93 | 
 94 |   <hr/>
 95 | 
 96 |   <div role="contentinfo">
 97 |     <p>&#169; Copyright 2021, Hanjin Liu.</p>
 98 |   </div>
 99 | 
100 |   Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
101 |     <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
102 |     provided by <a href="https://readthedocs.org">Read the Docs</a>.
103 |    
104 | 
105 | </footer>
106 |         </div>
107 |       </div>
108 |     </section>
109 |   </div>
110 |   <script>
111 |       jQuery(function () {
112 |           SphinxRtdTheme.Navigation.enable(true);
113 |       });
114 |   </script>
115 |   <script>
116 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
117 |   </script>
118 |   
119 |   <script id="searchindexloader"></script>
120 |    
121 | 
122 | 
123 | </body>
124 | </html>


--------------------------------------------------------------------------------
/impy/__init__.py:
--------------------------------------------------------------------------------
 1 | __version__ = "2.4.9"
 2 | __author__ = "Hanjin Liu"
 3 | __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 4 | 
 5 | import logging
 6 | from typing import TYPE_CHECKING
 7 | 
 8 | from impy._const import Const, SetConst, use  # noqa
 9 | 
10 | from impy.collections import DataList, DataDict  # noqa
11 | from impy.core import *  # noqa
12 | from impy.binder import bind  # noqa
13 | from impy.correlation import *  # noqa
14 | from impy.arrays import ImgArray, LazyImgArray, BigImgArray, Label  # noqa
15 | from impy import random, io, lazy  # noqa
16 | from impy.axes import slicer  # noqa
17 | 
18 | # Inheritance
19 | # -----------
20 | #
21 | # AxesMixin -----> LazyImgArray ------> BigImgArray
22 | #     |
23 | #     +-----> MetaArray --+--> LabeledArray --+--> ImgArray
24 | #     |                   |                   |
25 | # np.ndarray              +--> Label          +--> PhaseArray
26 | #                         |
27 | #                         +--> PropArray
28 | 
29 | 
30 | logging.getLogger("skimage").setLevel(logging.ERROR)
31 | logging.getLogger("tifffile").setLevel(logging.ERROR)
32 | 
33 | 
34 | del logging
35 | 
36 | # dtypes
37 | from numpy import (  # noqa
38 |     uint8, uint16, uint32, uint64,
39 |     int8, int16, int32, int64,
40 |     float16, float32, float64,
41 |     complex64, complex128,
42 |     bool_,
43 | )
44 | 
45 | # lazy loading
46 | 
47 | _VIEWER_CACHE = None
48 | if TYPE_CHECKING:
49 |     from impy.viewer import napariViewers
50 | 
51 |     gui: "napariViewers"
52 | 
53 | def __getattr__(key):
54 |     global _VIEWER_CACHE
55 | 
56 |     if key == "gui":
57 |         from impy.viewer import napariViewers
58 | 
59 |         if _VIEWER_CACHE is None:
60 |             _VIEWER_CACHE = napariViewers()
61 |         return _VIEWER_CACHE
62 |     else:
63 |         raise AttributeError(f"module 'impy' has no attribute '{key}'")
64 | 


--------------------------------------------------------------------------------
/impy/_const.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | import psutil
  3 | from typing import Any, MutableMapping
  4 | 
  5 | memory = psutil.virtual_memory()
  6 | 
  7 | MAX_GB_LIMIT = memory.total / 2 * 1e-9
  8 | 
  9 | class GlobalConstant(MutableMapping[str, Any]):
 10 |     _const: dict[str, Any]
 11 | 
 12 |     def __init__(self, **kwargs):
 13 |         object.__setattr__(self, "_const", dict(**kwargs))
 14 | 
 15 |     def __len__(self) -> int:
 16 |         return len(self._const)
 17 | 
 18 |     def __iter__(self):
 19 |         raise StopIteration
 20 | 
 21 |     def __getitem__(self, k):
 22 |         return self._const[k]
 23 | 
 24 |     def __setitem__(self, k: str, v):
 25 |         k = k.upper()
 26 |         if k == "MAX_GB":
 27 |             if not isinstance(v, (int, float)):
 28 |                 raise TypeError("MAX_GB must be float.")
 29 |             elif v > MAX_GB_LIMIT:
 30 |                 raise ValueError(f"Cannot exceed {MAX_GB_LIMIT} GB.")
 31 |         elif k == "ID_AXIS":
 32 |             if not isinstance(v, str):
 33 |                 raise TypeError("ID_AXIS must be str.")
 34 |             elif len(v) != 1:
 35 |                 raise ValueError("ID_AXIS must be single character.")
 36 |         elif k == "RESOURCE":
 37 |             from .array_api import xp
 38 |             if v == "numpy":
 39 |                 xp.setNumpy()
 40 |             elif v == "cupy":
 41 |                 xp.setCupy()
 42 |             else:
 43 |                 raise ValueError("RESOURCES must be either 'numpy' or 'cupy'.")
 44 |         elif k == "SCHEDULER":
 45 |             if v != self["SCHEDULER"]:
 46 |                 import dask
 47 |                 dask.config.set(scheduler=v)
 48 |         else:
 49 |             raise RuntimeError("Cannot set new keys.")
 50 | 
 51 |         self._const[k] = v
 52 | 
 53 |     __getattr__ = __getitem__
 54 |     __setattr__ = __setitem__
 55 | 
 56 |     def __delitem__(self, v):
 57 |         raise RuntimeError("Cannot delete any items.")
 58 | 
 59 |     def __repr__(self):
 60 |         return (
 61 |             f"""
 62 |                   MAX_GB    : {self['MAX_GB']:.2f} GB
 63 |                  ID_AXIS    : {self['ID_AXIS']}
 64 |                  RESOURCE   : {self['RESOURCE']}
 65 |                 SCHEDULER   : {self['SCHEDULER']}
 66 |             """
 67 |         )
 68 | 
 69 |     def asdict(self) -> dict[str, Any]:
 70 |         return self._const.copy()
 71 | 
 72 | Const = GlobalConstant(
 73 |     MAX_GB = MAX_GB_LIMIT * 0.8,
 74 |     ID_AXIS = "N",
 75 |     RESOURCE = "numpy",
 76 |     SCHEDULER = "threads",
 77 | )
 78 | 
 79 | class SetConst:
 80 |     n_ongoing = 0
 81 |     _locked_keys: set[str] = set()
 82 |     _old_dict: dict[str, Any] = dict()
 83 | 
 84 |     def __init__(self, dict_: dict[str, Any] | None =None, **kwargs):
 85 |         dict_ = dict_ or {}
 86 |         dict_.update(kwargs)
 87 |         self._kwargs = dict_
 88 | 
 89 |     def __enter__(self):
 90 |         self.__class__.n_ongoing += 1
 91 |         if self.__class__.n_ongoing == 1:
 92 |             self.__class__._old_dict = Const.asdict()
 93 |         for k, v in self._kwargs.items():
 94 |             if k not in self.__class__._locked_keys:
 95 |                 self.__class__._locked_keys.add(k)
 96 |                 Const[k] = v
 97 | 
 98 |     def __exit__(self, exc_type, exc_value, traceback):
 99 |         self.__class__.n_ongoing -= 1
100 |         if self.__class__.n_ongoing == 0:
101 |             for k, v in self.__class__._old_dict.items():
102 |                 Const[k] = v
103 |             self._locked_keys.clear()
104 | 
105 | def use(resource, import_error: bool = False):
106 |     """
107 |     Use a resource (numpy or cupy) in this context.
108 | 
109 |     Parameters
110 |     ----------
111 |     resource : str
112 |         Resource to use.
113 |     import_error : bool, default is False
114 |         If false, resource will not be switched to cupy if not available.
115 |         Raise ImportError if true.
116 |     """
117 |     if not import_error and resource=="cupy":
118 |         try:
119 |             import cupy
120 |         except ImportError:
121 |             resource = "numpy"
122 |     return SetConst(RESOURCE=resource)
123 | 


--------------------------------------------------------------------------------
/impy/_types.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from typing import Union, Sequence, Callable, Iterable, Tuple, Any, TYPE_CHECKING, Literal
 3 | from .axes import Slicer, Axes, AxisLike
 4 | 
 5 | if TYPE_CHECKING:
 6 |     import pandas as pd
 7 | 
 8 | __all__ = ["Sequence", "Callable", "Iterable", "nDFloat", "nDInt", "Coords",
 9 |            "Slices", "Dims", "Any", "AxesTargetedSlicer"]
10 | 
11 | nDFloat = Union[Sequence[float], float]
12 | nDInt = Union[Sequence[int], int]
13 | Coords = Union[np.ndarray, "pd.DataFrame"]
14 | Slices = Tuple[Union[slice, int], ...]
15 | if TYPE_CHECKING:
16 |     Dims = list[AxisLike]
17 | else:
18 |     Dims = Union[Sequence[AxisLike], int, None]
19 | AxesTargetedSlicer = Union[str, dict[str, Any], Slicer]
20 | PaddingMode = Union[
21 |     Literal["reflect"], 
22 |     Literal["constant"], 
23 |     Literal["nearest"], 
24 |     Literal["mirror"], 
25 |     Literal["wrap"]
26 | ]


--------------------------------------------------------------------------------
/impy/arrays/__init__.py:
--------------------------------------------------------------------------------
 1 | from impy.arrays.imgarray import ImgArray
 2 | from impy.arrays.labeledarray import LabeledArray
 3 | from impy.arrays.label import Label
 4 | from impy.arrays.phasearray import PhaseArray
 5 | from impy.arrays.specials import PropArray
 6 | from impy.arrays.lazy import LazyImgArray
 7 | from impy.arrays.big import BigImgArray
 8 | 
 9 | __all__ = [
10 |     "ImgArray",
11 |     "LabeledArray",
12 |     "Label",
13 |     "PhaseArray",
14 |     "PropArray",
15 |     "LazyImgArray",
16 |     "BigImgArray",
17 | ]
18 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/__init__.py:
--------------------------------------------------------------------------------
 1 | from . import (_deconv,
 2 |                _filters, 
 3 |                _glcm,
 4 |                _linalg, 
 5 |                _misc, 
 6 |                _skimage, 
 7 |                _docs,
 8 |                _transform,
 9 |                _structures,
10 |                _corr,
11 |                )


--------------------------------------------------------------------------------
/impy/arrays/_utils/_deconv.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | from functools import partial
 4 | import numpy as np
 5 | from impy.array_api import xp
 6 | 
 7 | __all__ = ["wiener", "richardson_lucy", "richardson_lucy_tv", "check_psf"]
 8 | 
 9 | def wiener(obs, psf_ft, psf_ft_conj, lmd):
10 |     obs = xp.asarray(obs)
11 |     fft = xp.fft.rfftn
12 |     ifft = partial(xp.fft.irfftn, s=obs.shape)
13 | 
14 |     img_ft = fft(obs)
15 | 
16 |     estimated = xp.real(ifft(img_ft*psf_ft_conj / (psf_ft*psf_ft_conj + lmd)))
17 |     return xp.fft.fftshift(estimated)
18 | 
19 | def richardson_lucy(obs, psf_ft, psf_ft_conj, niter, eps):
20 |     # Identical to the algorithm in Deconvolution.jl of Julia.
21 |     obs = xp.asarray(obs)
22 |     fft = xp.fft.rfftn
23 |     ifft = partial(xp.fft.irfftn, s=obs.shape)
24 |     conv = factor = xp.empty(obs.shape, dtype=np.float32) # placeholder
25 |     estimated = xp.real(ifft(fft(obs) * psf_ft))   # initialization
26 | 
27 |     for _ in range(niter):
28 |         conv[:] = ifft(fft(estimated) * psf_ft).real
29 |         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
30 |         estimated *= factor
31 | 
32 |     return xp.fft.fftshift(estimated)
33 | 
34 | def richardson_lucy_tv(obs, psf_ft, psf_ft_conj, max_iter, lmd, tol, eps):
35 |     obs = xp.asarray(obs)
36 |     fft = xp.fft.rfftn
37 |     ifft = partial(xp.fft.irfftn, s=obs.shape)
38 |     est_old = ifft(fft(obs) * psf_ft).real
39 |     est_new = xp.empty(obs.shape, dtype=np.float32)
40 |     conv = factor = norm = gg = xp.empty(obs.shape, dtype=np.float32) # placeholder
41 | 
42 |     for _ in range(max_iter):
43 |         conv[:] = ifft(fft(est_old) * psf_ft).real
44 |         factor[:] = ifft(fft(_safe_div(obs, conv, eps=eps)) * psf_ft_conj).real
45 |         est_new[:] = est_old * factor
46 |         grad = xp.gradient(est_old)
47 |         norm[:] = xp.sqrt(sum(g**2 for g in grad))
48 |         gg[:] = sum(xp.gradient(_safe_div(grad[i], norm, eps=1e-8), axis=i)
49 |                     for i in range(obs.ndim))
50 |         est_new /= (1 - lmd * gg)
51 |         gain = xp.sum(xp.abs(est_new - est_old))/xp.sum(xp.abs(est_old))
52 |         if gain < tol:
53 |             break
54 |         est_old[:] = est_new
55 | 
56 |     return xp.fft.fftshift(est_new)
57 | 
58 | 
59 | def _safe_div(a: np.ndarray, b: np.ndarray, eps: float = 1e-8):
60 |     out = xp.zeros(a.shape, dtype=np.float32)
61 |     mask = b > eps
62 |     out[mask] = a[mask] / b[mask]
63 |     return out
64 | 
65 | 
66 | def check_psf(img_shape: tuple[int, ...], img_scale: tuple[float, ...], psf):
67 |     if callable(psf):
68 |         psf = psf(img_shape, img_scale)
69 |     psf = xp.asarray(psf, dtype=np.float32)
70 |     psf /= xp.sum(psf)
71 | 
72 |     if img_shape != psf.shape:
73 |         raise ValueError(
74 |             f"observation and PSF have different shape: {img_shape} and {psf.shape}"
75 |         )
76 |     psf_ft = xp.fft.rfftn(psf)
77 |     psf_ft_conj = xp.conjugate(psf_ft)
78 |     return psf_ft, psf_ft_conj
79 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_glcm.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import scipy
  3 | from impy.collections import DataDict
  4 | 
  5 | __all__ = ["glcm_props_", "check_glcm"]
  6 | 
  7 | def contrast_(glcm, ref, nei):
  8 |     return np.sum((ref-nei)**2 * glcm, axis=(0,1))
  9 | 
 10 | def dissimilarity_(glcm, ref, nei):
 11 |     return np.sum(glcm * np.abs(ref-nei), axis=(0,1))
 12 | 
 13 | def asm_(glcm, ref, nei):
 14 |     return np.sum(glcm**2, axis=(0,1))
 15 | 
 16 | def idm_(glcm, ref, nei):
 17 |     return np.sum(glcm/(1+(ref-nei)**2), axis=(0,1))
 18 | 
 19 | def energy_(glcm, ref, nei):
 20 |     return np.sqrt(np.sum(glcm**2, axis=(0,1)))
 21 | 
 22 | def max_(glcm, ref, nei):
 23 |     return np.max(glcm, axis=(0,1))
 24 | 
 25 | def entropy_(glcm, ref, nei):
 26 |     prob = glcm / np.sum(glcm, axis=(0,1), keepdims=True)
 27 |     return scipy.stats.entropy(prob, axis=(0,1))
 28 | 
 29 | def correlation_(glcm, ref, nei):
 30 |     diffy = ref - np.sum(glcm * ref, axis=(0,1))
 31 |     diffx = nei - np.sum(glcm * nei, axis=(0,1))
 32 | 
 33 |     stdy = np.sqrt(np.sum(glcm*diffy**2, axis=(0,1)))
 34 |     stdx = np.sqrt(np.sum(glcm*diffx**2, axis=(0,1)))
 35 |     cov = np.sum(glcm*diffx*diffy, axis=(0,1))
 36 | 
 37 |     out = np.empty(glcm.shape[2:], dtype=np.float32)
 38 |     mask_0 = np.logical_or(stdx<1e-15, stdy<1e-15)
 39 |     mask_1 = ~mask_0
 40 |     out[mask_0] = 1
 41 | 
 42 |     # handle the standard case
 43 |     out[mask_1] = cov[mask_1] / (stdx[mask_1] * stdy[mask_1])
 44 |     return out
 45 | 
 46 | def mean_ref_(glcm, ref, nei):
 47 |     return np.sum(glcm*ref, axis=(0,1))
 48 | 
 49 | def mean_neighbor_(glcm, ref, nei):
 50 |     return np.sum(glcm*nei, axis=(0,1))
 51 | 
 52 | def std_ref_(glcm, ref, nei):
 53 |     return np.std(glcm*ref, axis=(0,1))
 54 | 
 55 | def std_neighbor_(glcm, ref, nei):
 56 |     return np.std(glcm*nei, axis=(0,1))
 57 | 
 58 | propdict = {"contrast": contrast_,
 59 |             "dissimilarity": dissimilarity_,
 60 |             "idm": idm_,
 61 |             "asm": asm_,
 62 |             "energy": energy_,
 63 |             "max": max_,
 64 |             "entropy": entropy_,
 65 |             "correlation": correlation_,
 66 |             "mean_ref": mean_ref_,
 67 |             "mean_neighbor": mean_neighbor_,
 68 |             "std_ref": std_ref_,
 69 |             "std_neighbor": std_neighbor_,
 70 |             }
 71 | 
 72 | 
 73 | def glcm_props_(data, distances, angles, levels, radius, properties):
 74 |     outshape = (len(distances), len(angles)) + \
 75 |         (data.shape[0]-2*radius, data.shape[1]-2*radius)
 76 | 
 77 |     propout = DataDict()
 78 |     for prop in properties:
 79 |         if isinstance(prop, str):
 80 |             propout[prop] = np.empty(outshape, dtype=np.float32)
 81 |         else:
 82 |             propout[prop.__name__] = np.empty(outshape, dtype=np.float32)
 83 |     # placeholder
 84 |     glcm = np.empty((levels, levels, len(distances), len(angles)), dtype=np.float32)
 85 | 
 86 |     ref, nei = np.indices((levels, levels), dtype=np.float32)
 87 |     ref = ref[:, :, np.newaxis, np.newaxis]
 88 |     nei = nei[:, :, np.newaxis, np.newaxis]
 89 | 
 90 |     from ._process_numba import _calc_glcm
 91 | 
 92 |     for x in range(outshape[3]):
 93 |         for y in range(outshape[2]):
 94 |             # calc glcm
 95 |             patch = data[y:y+2*radius+1, x:x+2*radius+1]
 96 |             _calc_glcm(distances, angles, levels, radius, patch, glcm)
 97 |             # calc props
 98 |             for prop in properties:
 99 |                 if isinstance(prop, str):
100 |                     propout[prop][:,:,y,x] = propdict[prop](glcm, ref, nei)
101 |                 else:
102 |                     # only callable
103 |                     propout[prop.__name__][:,:,y,x] = prop(glcm, ref, nei)
104 | 
105 |     return propout
106 | 
107 | def check_glcm(self, bins, rescale_max):
108 |     if bins is None:
109 |         if self.dtype == bool:
110 |             bins = 2
111 |         else:
112 |             bins = 256
113 |     elif bins > 256:
114 |         raise ValueError("`bins` must be smaller than 256.")
115 | 
116 |     if self.dtype == np.uint16:
117 |         self = self.as_uint8()
118 |     elif self.dtype == np.uint8:
119 |         pass
120 |     else:
121 |         raise TypeError(f"Cannot calculate comatrix of {self.dtype} image.")
122 | 
123 |     imax = np.iinfo(self.dtype).max
124 | 
125 |     if rescale_max:
126 |         scale = int(imax/self.max())
127 |         self *= scale
128 | 
129 |     if (imax+1) % bins != 0 or bins > imax+1:
130 |         raise ValueError(f"`bins` must be a divisor of {imax+1} (max value of {self.dtype}).")
131 |     self = self // ((imax+1) // bins)
132 | 
133 |     return self, bins, rescale_max
134 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_linalg.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | import numpy as np
 3 | from typing import TYPE_CHECKING
 4 | from itertools import combinations_with_replacement as CwR
 5 | from impy.array_api import xp
 6 | 
 7 | if TYPE_CHECKING:
 8 |     from impy.arrays.imgarray import ImgArray
 9 |     from impy.axes import Axes
10 | 
11 | def eigh(a: np.ndarray):
12 |     a = xp.asarray(a, dtype=a.dtype)
13 |     val, vec = xp.linalg.eigh(a)
14 |     return val, vec
15 | 
16 | def eigvalsh(a: np.ndarray):
17 |     a = xp.asarray(a, dtype=a.dtype)
18 |     val = xp.linalg.eigvalsh(a)
19 |     return val
20 | 
21 | def structure_tensor_eigval(img: np.ndarray, sigma: float, pxsize: float):
22 |     from skimage.feature import structure_tensor
23 | 
24 |     tensor_elements = structure_tensor(
25 |         img, sigma, mode="reflect"
26 |     )
27 |     return _solve_hermitian_eigval(tensor_elements, pxsize)
28 | 
29 | def structure_tensor_eigh(img: np.ndarray, sigma: float, pxsize: float):
30 |     from skimage.feature import structure_tensor
31 | 
32 |     tensor_elements = structure_tensor(
33 |         img, sigma, mode="reflect"
34 |     )
35 |     return _solve_hermitian_eigs(tensor_elements, pxsize)
36 | 
37 | def hessian_eigval(img: np.ndarray, sigma: float, pxsize: float):
38 |     from skimage.feature import hessian_matrix
39 |     
40 |     hessian_elements = hessian_matrix(
41 |         img, sigma=sigma, mode="reflect", use_gaussian_derivatives=False,
42 |     )
43 |     return _solve_hermitian_eigval(hessian_elements, pxsize)
44 | 
45 | def hessian_eigh(img: np.ndarray, sigma: float, pxsize: float):
46 |     from skimage.feature import hessian_matrix
47 |     
48 |     hessian_elements = hessian_matrix(
49 |         img, sigma=sigma, mode="reflect", use_gaussian_derivatives=False,
50 |     )
51 |     return _solve_hermitian_eigs(hessian_elements, pxsize)
52 | 
53 | 
54 | def _solve_hermitian_eigval(elems, pxsize) -> np.ndarray:
55 |     # Correct for scale
56 |     pxsize = np.asarray(pxsize)
57 |     hessian = _symmetric_image(elems)
58 |     hessian *= (pxsize.reshape(-1, 1) * pxsize.reshape(1, -1))
59 |     eigval = eigvalsh(hessian)
60 |     return eigval
61 | 
62 | def _solve_hermitian_eigs(elems, pxsize):
63 |     # Correct for scale
64 |     pxsize = np.asarray(pxsize)
65 |     hessian = _symmetric_image(elems)
66 |     hessian *= (pxsize.reshape(-1, 1) * pxsize.reshape(1, -1))
67 |     eigval, eigvec = eigh(hessian)
68 |     return np.concatenate([eigval[..., np.newaxis], eigvec], axis=-1)
69 | 
70 | def eigs_post_process(eigs: ImgArray, axes: Axes, self: ImgArray):
71 |     eigval = eigs[..., 0]
72 |     eigvec = eigs[..., 1:]
73 |     eigval: ImgArray = np.moveaxis(eigval, -1, 0)
74 |     eigvec: ImgArray = np.moveaxis(eigvec, [-2, -1], [0, 1])
75 |     
76 |     val_axes = ["base"] + axes
77 |     vec_axes = ["dim", "base"] + axes
78 |     nspatial = eigvec.shape[0]
79 |     eigval._set_info(self, new_axes=val_axes)
80 |     eigvec._set_info(self, new_axes=vec_axes)
81 |     eigvec.axes["dim"].labels = tuple(map(str, eigvec.axes[-nspatial:]))
82 |     return eigval, eigvec
83 | 
84 | # copied from skimage.feature.corner
85 | def _symmetric_image(elems: np.ndarray):
86 |     image: np.ndarray = elems[0]
87 |     shape = image.shape + (image.ndim, image.ndim)
88 |     symmetric_image = np.zeros(shape, dtype=image.dtype)
89 |     for idx, (row, col) in enumerate(CwR(range(image.ndim), 2)):
90 |         symmetric_image[..., row, col] = elems[idx]
91 |         symmetric_image[..., col, row] = elems[idx]
92 |     return symmetric_image
93 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_misc.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | import numpy as np
 3 | from impy.array_api import xp
 4 | 
 5 | def adjust_bin(
 6 |     img: np.ndarray,
 7 |     binsize: int,
 8 |     check_edges: bool,
 9 |     dims: str,
10 |     all_axes: str
11 | ) -> tuple[np.ndarray, tuple[int, ...], float]:
12 |     """Adjust bin size of an image prior to calling `binning`."""
13 |     shape = []
14 |     scale = []
15 |     sl = []
16 |     dims = list(dims)
17 |     for i, a in enumerate(all_axes):
18 |         s = img.shape[i]
19 |         if a in dims:
20 |             b = binsize
21 |             if s % b != 0:
22 |                 if check_edges:
23 |                     raise ValueError(f"Cannot bin axis {a} with length {s} by bin size {binsize}")
24 |                 else:
25 |                     sl.append(slice(None, s//b*b))
26 |             else:
27 |                 sl.append(slice(None))
28 |         else:
29 |             b = 1
30 |             sl.append(slice(None))
31 |         shape += [s//b, b]
32 |         scale.append(1/b)
33 |     sl = tuple(sl)
34 |     shape = tuple(shape)
35 |     return img[sl], shape, scale
36 | 
37 | 
38 | def make_rotated_axis(src, dst):
39 |     dr = dst - src
40 |     d = np.sqrt(sum(dr**2))
41 |     n = int(round(d))
42 |     return np.linspace(src, src + dr / d * (n - 1), n)
43 | 
44 | def make_rotated_axis_by_vec(src, unit_vec, n: int):
45 |     return np.linspace(src, src + unit_vec * (n - 1), n)
46 | 
47 | def make_pad(pad_width, dims, all_axes, **kwargs):
48 |     """More flexible padding than `np.pad`."""
49 |     pad_width_ = []
50 | 
51 |     # for consistency with scipy-format
52 |     if "cval" in kwargs.keys():
53 |         kwargs["constant_values"] = kwargs["cval"]
54 |         kwargs.pop("cval")
55 | 
56 |     if hasattr(pad_width, "__iter__") and len(pad_width) == len(dims):
57 |         pad_iter = iter(pad_width)
58 |         for a in all_axes:
59 |             if a in dims:
60 |                 pad_width_.append(next(pad_iter))
61 |             else:
62 |                 pad_width_.append((0, 0))
63 | 
64 |     elif isinstance(pad_width, int):
65 |         for a in all_axes:
66 |             if a in dims:
67 |                 pad_width_.append((pad_width, pad_width))
68 |             else:
69 |                 pad_width_.append((0, 0))
70 |     else:
71 |         raise TypeError(f"pad_width must be iterable or int, but got {type(pad_width)}")
72 | 
73 |     return pad_width_
74 | 
75 | def dft(img: np.ndarray, exps: list[np.ndarray] = None):
76 |     """Discrete Fourier Transform."""
77 |     img = xp.asarray(img)
78 |     for ker in reversed(exps):
79 |         # K_{kx} * I_{zyx}
80 |         img = xp.tensordot(xp.asarray(ker), img, axes=(1, -1))
81 |     return img
82 | 
83 | def inpaint_mean(img: np.ndarray, mask: np.ndarray):
84 |     """Inpaint missing values with mean of surrounding pixels."""
85 |     img = xp.asarray(img)
86 |     mask = xp.asarray(mask)
87 |     labels, nfeatures = xp.ndi.label(mask)
88 |     ndim = img.ndim
89 |     out = img.copy()
90 |     for i in range(nfeatures):
91 |         mask_i = labels == i + 1
92 |         expanded_i = xp.ndi.binary_dilation(mask_i , xp.ones((3,) * ndim))
93 |         border = expanded_i ^ mask_i
94 |         out[mask_i] = xp.mean(img[border])
95 |     return out
96 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_process_numba.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from numba import jit
 3 | 
 4 | @jit("void(uint8[:], f4[:], i8, i8, uint8[:,:], f4[:,:,:,:])", nopython=True, cache=True)
 5 | def _calc_glcm(distances, angles, levels, radius, patch, glcm):
 6 |     glcm[:,:,:,:] = 0
 7 |     for a_idx in range(angles.size):
 8 |         angle = angles[a_idx]
 9 |         for d_idx in range(distances.size):
10 |             d = distances[d_idx]
11 |             offset_row = round(np.sin(angle) * d)
12 |             offset_col = round(np.cos(angle) * d)
13 |             start_row = max(0, -offset_row)
14 |             end_row = min(2*radius+1, 2*radius+1 - offset_row)
15 |             start_col = max(0, -offset_col)
16 |             end_col = min(2*radius+1, 2*radius+1 - offset_col)
17 |             for r in range(start_row, end_row):
18 |                 for c in range(start_col, end_col):
19 |                     i = patch[r, c]
20 |                     # compute the location of the offset pixel
21 |                     row = r + offset_row
22 |                     col = c + offset_col
23 |                     j = patch[row, col]
24 |                     if 0 <= i < levels and 0 <= j < levels:
25 |                         glcm[i, j, d_idx, a_idx] += 1.
26 | 
27 | @jit(nopython=True)
28 | def _specify_square_2d(arr, coords, radius, label_offset=1):
29 |     npoints = coords.shape[0]
30 |     ny, nx = arr.shape
31 |     ry, rx = radius
32 |     for i in range(npoints):
33 |         coord = coords[i,:]
34 |         yc = coord[0]
35 |         xc = coord[1]
36 |         y0 = max( 0, yc-ry)
37 |         y1 = min(ny, yc+ry+1)        
38 |         x0 = max( 0, xc-rx)
39 |         x1 = min(nx, xc+rx+1)
40 |         arr[y0:y1, x0:x1] = i + label_offset
41 | 
42 | @jit(nopython=True)
43 | def _specify_square_3d(arr, coords, radius, label_offset=1):
44 |     npoints = coords.shape[0]
45 |     nz, ny, nx = arr.shape
46 |     rz, ry, rx = radius
47 |     for i in range(npoints):
48 |         coord = coords[i,:]
49 |         zc = coord[0]
50 |         yc = coord[1]
51 |         xc = coord[2]
52 |         z0 = max( 0, zc-rz)
53 |         z1 = min(nz, zc+rz+1)        
54 |         y0 = max( 0, yc-ry)
55 |         y1 = min(ny, yc+ry+1)        
56 |         x0 = max( 0, xc-rx)
57 |         x1 = min(nx, xc+rx+1)
58 |         arr[z0:z1, y0:y1, x0:x1] = i + label_offset
59 | 
60 | @jit(nopython=True)
61 | def _specify_circ_2d(arr, coords, radius, label_offset=1):
62 |     npoints = coords.shape[0]
63 |     ny, nx = arr.shape
64 |     ry, rx = radius
65 |     for i in range(npoints):
66 |         coord = coords[i,:]
67 |         yc = coord[0]
68 |         xc = coord[1]
69 |         y0 = max( 0, yc-ry)
70 |         y1 = min(ny, yc+ry+1)        
71 |         x0 = max( 0, xc-rx)
72 |         x1 = min(nx, xc+rx+1)
73 |         for y in range(y0, y1):
74 |             for x in range(x0, x1):
75 |                 if ((x-xc)/rx)**2 + ((y-yc)/ry)**2 <= 1:
76 |                     arr[y,x] = i + label_offset
77 | 
78 | @jit(nopython=True)
79 | def _specify_circ_3d(arr, coords, radius, label_offset=1):
80 |     npoints = coords.shape[0]
81 |     nz, ny, nx = arr.shape
82 |     rz, ry, rx = radius
83 |     for i in range(npoints):
84 |         coord = coords[i,:]
85 |         zc = coord[0]
86 |         yc = coord[1]
87 |         xc = coord[2]
88 |         z0 = max( 0, zc-rz)
89 |         z1 = min(nz, zc+rz+1)        
90 |         y0 = max( 0, yc-ry)
91 |         y1 = min(ny, yc+ry+1)        
92 |         x0 = max( 0, xc-rx)
93 |         x1 = min(nx, xc+rx+1)
94 |         for z in range(z0, z1):
95 |             for y in range(y0, y1):
96 |                 for x in range(x0, x1):
97 |                     if ((x-xc)/rx)**2 + ((y-yc)/ry)**2 + ((z-zc)/rz)**2 <= 1:
98 |                         arr[z,y,x] = i + label_offset
99 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_skimage.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | import numpy as np
 4 | 
 5 | from functools import reduce, lru_cache
 6 | 
 7 | # same as the function in skimage.filters._fft_based (available in scikit-image >= 0.19)
 8 | @lru_cache(maxsize=4)
 9 | def _get_ND_butterworth_filter(
10 |     shape: tuple[int, ...],
11 |     cutoff: float,
12 |     order: int,
13 |     high_pass: bool,
14 |     real: bool,
15 | ):
16 |     if cutoff == 0:
17 |         if high_pass:
18 |             wfilt = np.ones(shape, dtype=np.float32)
19 |         else:
20 |             wfilt = np.zeros(shape, dtype=np.float32)
21 |         return wfilt
22 |     ranges = []
23 |     for d, fc in zip(shape, cutoff):
24 |         axis = np.arange(-(d - 1) // 2, (d - 1) // 2 + 1, dtype=np.float32) / (d*fc)
25 |         ranges.append(np.fft.ifftshift(axis ** 2))
26 |     if real:
27 |         limit = d // 2 + 1
28 |         ranges[-1] = ranges[-1][:limit]
29 |     q2 = reduce(np.add, np.meshgrid(*ranges, indexing="ij", sparse=True))
30 |     wfilt = 1 / (1 + q2**order)
31 |     if high_pass:
32 |         wfilt = 1 - wfilt
33 |     return wfilt
34 | 


--------------------------------------------------------------------------------
/impy/arrays/_utils/_structures.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from impy.array_api import xp
 3 | 
 4 | def circle(radius, shape, dtype="bool"):
 5 |     x = xp.arange(-(shape[0] - 1) / 2, (shape[0] - 1) / 2 + 1)
 6 |     y = xp.arange(-(shape[1] - 1) / 2, (shape[1] - 1) / 2 + 1)
 7 |     dx, dy = xp.meshgrid(x, y)
 8 |     return xp.array((dx ** 2 + dy ** 2) <= radius ** 2, dtype=dtype)
 9 | 
10 | def ball_like(radius, ndim:int):
11 |     half_int = int(2*radius)/2
12 |     L = xp.arange(-half_int, half_int + 1)
13 | 
14 |     if ndim == 1:
15 |         return xp.ones(int(radius)*2+1, dtype=np.uint8)
16 |     elif ndim == 2:
17 |         X, Y = xp.meshgrid(L, L)
18 |         s = X**2 + Y**2
19 |         return xp.array(s <= radius**2, dtype=np.uint8)
20 |     elif ndim == 3:
21 |         Z, Y, X = xp.meshgrid(L, L, L)
22 |         s = X**2 + Y**2 + Z**2
23 |         return xp.array(s <= radius**2, dtype=np.uint8)
24 |     else:
25 |         raise ValueError(f"dims must be 1 - 3, but got {ndim}")
26 | 
27 | def ball_like_odd(radius, ndim):
28 |     """
29 |     In ball_like, sometimes shapes of output will be even length, such as:
30 |     [[0, 1, 1, 0],
31 |      [1, 1, 1, 1],
32 |      [1, 1, 1, 1],
33 |      [0, 1, 1, 0]]
34 |     This is not suitable for specify().
35 |     """
36 |     xc = int(radius)
37 |     l = xc*2 + 1
38 |     coords = xp.indices((l,)*ndim)
39 |     s = xp.sum((a-xc)**2 for a in coords)
40 |     return xp.array(s <= radius*radius, dtype=bool)
41 | 


--------------------------------------------------------------------------------
/impy/arrays/bases/__init__.py:
--------------------------------------------------------------------------------
1 | from .metaarray import MetaArray
2 | 
3 | # overload numpy functions to MetaArray
4 | from . import overload


--------------------------------------------------------------------------------
/impy/arrays/big.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | from functools import wraps
 4 | 
 5 | from impy.arrays.lazy import LazyImgArray
 6 | 
 7 | 
 8 | def wrap_method(method):
 9 |     @wraps(method)
10 |     def wrapped(self: LazyImgArray, *args, **kwargs):
11 |         out = method(self, *args, **kwargs)
12 |         if isinstance(out, LazyImgArray):
13 |             out.release()
14 |         return out
15 |     return wrapped
16 | 
17 | class BigImgArray(LazyImgArray):
18 |     affine = wrap_method(LazyImgArray.affine)
19 |     erosion = wrap_method(LazyImgArray.erosion)
20 |     dilation = wrap_method(LazyImgArray.dilation)
21 |     opening = wrap_method(LazyImgArray.opening)
22 |     closing = wrap_method(LazyImgArray.closing)
23 |     gaussian_filter = wrap_method(LazyImgArray.gaussian_filter)
24 |     spline_filter = wrap_method(LazyImgArray.spline_filter)
25 |     median_filter = wrap_method(LazyImgArray.median_filter)
26 |     mean_filter = wrap_method(LazyImgArray.mean_filter)
27 |     convolve = wrap_method(LazyImgArray.convolve)
28 |     edge_filter = wrap_method(LazyImgArray.edge_filter)
29 |     laplacian_filter = wrap_method(LazyImgArray.laplacian_filter)
30 |     kalman_filter = wrap_method(LazyImgArray.kalman_filter)
31 |     fft = wrap_method(LazyImgArray.fft)
32 |     ifft = wrap_method(LazyImgArray.ifft)
33 |     power_spectra = wrap_method(LazyImgArray.power_spectra)
34 |     proj = wrap_method(LazyImgArray.proj)
35 |     binning = wrap_method(LazyImgArray.binning)
36 |     track_drift = wrap_method(LazyImgArray.track_drift)
37 |     drift_correction = wrap_method(LazyImgArray.drift_correction)
38 |     radon = wrap_method(LazyImgArray.radon)
39 |     wiener = wrap_method(LazyImgArray.wiener)
40 |     lucy = wrap_method(LazyImgArray.lucy)
41 |     as_uint8 = wrap_method(LazyImgArray.as_uint8)
42 |     as_uint16 = wrap_method(LazyImgArray.as_uint16)
43 |     as_float = wrap_method(LazyImgArray.as_float)
44 |     as_img_type = wrap_method(LazyImgArray.as_img_type)
45 |     __neg__ = wrap_method(LazyImgArray.__neg__)
46 |     __add__ = wrap_method(LazyImgArray.__add__)
47 |     __iadd__ = wrap_method(LazyImgArray.__iadd__)
48 |     __sub__ = wrap_method(LazyImgArray.__sub__)
49 |     __isub__ = wrap_method(LazyImgArray.__isub__)
50 |     __mul__ = wrap_method(LazyImgArray.__mul__)
51 |     __imul__ = wrap_method(LazyImgArray.__imul__)
52 |     __truediv__ = wrap_method(LazyImgArray.__truediv__)
53 |     __itruediv__ = wrap_method(LazyImgArray.__itruediv__)
54 |     __gt__ = wrap_method(LazyImgArray.__gt__)
55 |     __ge__ = wrap_method(LazyImgArray.__ge__)
56 |     __lt__ = wrap_method(LazyImgArray.__lt__)
57 |     __lt__ = wrap_method(LazyImgArray.__lt__)
58 |     __eq__ = wrap_method(LazyImgArray.__eq__)
59 |     __ne__ = wrap_method(LazyImgArray.__ne__)
60 |     __mod__ = wrap_method(LazyImgArray.__mod__)
61 |     __floordiv__ = wrap_method(LazyImgArray.__floordiv__)
62 |     __pow__ = wrap_method(LazyImgArray.__pow__)
63 | 


--------------------------------------------------------------------------------
/impy/axes/__init__.py:
--------------------------------------------------------------------------------
1 | from ._axes import Axes, AxesLike, ImageAxesError, ScaleView, broadcast
2 | from ._axis import Axis, as_axis, UndefAxis, AxisLike
3 | from ._slicer import Slicer
4 | from ._axes_tuple import AxesTuple
5 | 
6 | slicer = Slicer()  # default slicer object
7 | 


--------------------------------------------------------------------------------
/impy/axes/_axes_tuple.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | from typing import Generic, NamedTuple, overload, TYPE_CHECKING, TypeVar
 3 | from collections import namedtuple
 4 | from ._axis import Axis
 5 | 
 6 | if TYPE_CHECKING:
 7 |     from ._axes import Axes
 8 |     _T = TypeVar("_T")
 9 |     
10 |     class AxesTuple(tuple[_T, ...], Generic[_T]):
11 |         def __init__(self, *iterable: _T):
12 |             ...
13 | 
14 |         def __getattr__(self, axis: str) -> _T:
15 |             ...
16 |         
17 |         @overload
18 |         def __getitem__(self, key: int | str | Axis) -> _T:
19 |             ...
20 | 
21 |         @overload
22 |         def __getitem__(self, key: slice) -> AxesTuple[_T]:
23 |             ...        
24 |         
25 | else:
26 |     AxesTuple = NamedTuple
27 |     
28 | _AxesShapes: dict[str, AxesTuple] = {}  # cache
29 | 
30 | def get_axes_tuple(axes: Axes):
31 |     try:
32 |         return _AxesShapes[axes]
33 |     except KeyError:
34 |         fields = []
35 |         for i, a in enumerate(axes):
36 |             s = str(a)
37 |             if s.isidentifier():
38 |                 fields.append(s)
39 |             else:
40 |                 fields.append(f"axis_{i}")
41 |         tup = namedtuple("AxesShape", fields)
42 |         tup.__getitem__ = _getitem
43 |         _AxesShapes[axes] = tup
44 |         return tup
45 | 
46 | @overload
47 | def _getitem(self: AxesTuple, key: int | str | Axis) -> int:
48 |     ...
49 | 
50 | @overload
51 | def _getitem(self: AxesTuple, key: slice) -> tuple[int, ...]:
52 |     ...
53 | 
54 | def _getitem(self: AxesTuple, key, /):
55 |     if isinstance(key, (str, Axis)):
56 |         return self._asdict()[key]
57 |     return tuple.__getitem__(self, key)
58 | 


--------------------------------------------------------------------------------
/impy/axes/_slicer.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | from typing import Any, Iterable
 3 | from numbers import Number
 4 | 
 5 | class Slicer:
 6 |     def __init__(self, sl: dict[str, Any] = None):
 7 |         self._dict = sl or {}
 8 | 
 9 |     def __getattr__(self, axis: str) -> _AxisSlice:
10 |         return _AxisSlice(self, axis)
11 | 
12 |     def __call__(self, axis: str) -> _AxisSlice:
13 |         return _AxisSlice(self, axis)
14 |     
15 |     def __len__(self) -> int:
16 |         return len(self._dict)
17 |     
18 |     def __repr__(self) -> str:
19 |         s = []
20 |         for k, v in self._dict.items():
21 |             s.append(f"\n\t{k} ==> {_fmt(v)}")
22 |         s = "".join(s)
23 |         return f"{self.__class__.__name__} of {s}"
24 | 
25 |     def get_formatter(self, axes: Iterable[str]) -> SliceFormatter:
26 |         """Return a formatter for the given axes."""
27 |         return SliceFormatter(axes, self._dict)
28 | 
29 | class _AxisSlice:
30 |     def __init__(self, slicer: Slicer, axis: str):
31 |         self.dict = slicer._dict
32 |         self.axis = axis
33 |     
34 |     def __getitem__(self, key) -> Slicer:
35 |         if isinstance(key, tuple):
36 |             # img[slicer.x[1, 3, 5]] == img[slicer.x[[1, 3, 5]]]
37 |             # to avoid to many "[]".
38 |             key = list(key)
39 |         d = self.dict.copy()
40 |         if self.axis in d.keys():
41 |             raise ValueError(f"Axis {self.axis} was sliced twice.")
42 |         d[self.axis] = key
43 |         return Slicer(d)
44 | 
45 | class SliceFormatter:
46 |     def __init__(self, axes: Iterable[str], defined: dict[str, Any]):
47 |         self._defined = defined
48 |         self.axes = list(axes)
49 |     
50 |     def __getitem__(self, key) -> Slicer | SliceFormatter:
51 |         if not isinstance(key, tuple):
52 |             key = (key,)
53 |         n = len(key)
54 |         d = self._defined.copy()
55 |         for i, k in enumerate(key):
56 |             d.update({self.axes[i]: k})
57 |         if n == len(self.axes):
58 |             return Slicer(d)
59 |         else:
60 |             return SliceFormatter(self.axes[n:], d)
61 |     
62 |     def __repr__(self) -> str:
63 |         s = []
64 |         for k, v in self._defined.items():
65 |             s.append(f"\n\t{k} ==> {_fmt(v)}")
66 |         for a in self.axes:
67 |             s.append(f"\n\t{a} ==> Undefined")
68 |         s = "".join(s)
69 |         return f"{self.__class__.__name__} of {s}"
70 |     
71 |     def zeros(self) -> Slicer:
72 |         return self[(0,) * len(self.axes)]
73 | 
74 | 
75 | def _fmt(s):
76 |     if isinstance(s, slice):
77 |         r = ":".join("" if a is None else str(a) for a in [s.start, s.stop, s.step])
78 |         if r.count(":") == 2 and r.endswith(":"):
79 |             r = r[:-1]
80 |     elif isinstance(s, (Number, list)):
81 |         r = repr(s)
82 |     else:
83 |         r = str(s.__class__)
84 |     return r
85 |         


--------------------------------------------------------------------------------
/impy/frame/__init__.py:
--------------------------------------------------------------------------------
1 | from .frames import AxesFrame, MarkerFrame, TrackFrame, PathFrame


--------------------------------------------------------------------------------
/impy/io/__init__.py:
--------------------------------------------------------------------------------
 1 | from ._registry import imread, imread_dask, imsave, mark_reader, mark_writer, read_header
 2 | from . import _tiff, _mrc, _npy, _zarr, _nd2, _czi
 3 | 
 4 | del _tiff, _mrc, _npy, _zarr, _nd2, _czi
 5 | 
 6 | __all__ = [
 7 |     "imread",
 8 |     "imread_dask",
 9 |     "imsave",
10 |     "read_header",
11 |     "mark_reader",
12 |     "mark_writer",
13 | ]
14 | 


--------------------------------------------------------------------------------
/impy/io/_czi.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | from typing import TYPE_CHECKING
 4 | import numpy as np
 5 | from impy.io._registry import IO
 6 | from impy.io._utils import ImageData, ImageMetadata
 7 | 
 8 | if TYPE_CHECKING:
 9 |     from czifile import CziFile
10 | 
11 | @IO.mark_reader(".czi")
12 | def _(path: str, memmap: bool = False) -> ImageData:
13 |     """The CZI format reader"""
14 |     import czifile
15 | 
16 |     if memmap:
17 |         raise NotImplementedError("CZI reader does not support memmap mode yet.")
18 |     else:
19 |         out = None
20 |     with czifile.CziFile(path) as czi:
21 |         data = np.squeeze(czi.asarray(out=out))
22 |         meta = _parse_czi_meta(czi)
23 | 
24 |     return ImageData.from_metadata(data, meta)
25 | 
26 | def _parse_czi_meta(czi: CziFile) -> ImageMetadata:
27 |     """Parse metadata from a CZI file."""
28 |     axes_all: str = czi.axes
29 |     shape = czi.shape
30 |     axes = "".join(a.lower() for s, a in zip(shape, axes_all) if s > 1)
31 |     try:
32 |         img_meta = czi.metadata(raw=False)["ImageDocument"]["Metadata"]
33 |         scale = {}
34 |         for item in img_meta["Scaling"]["Items"]["Distance"]:
35 |             a = item["Id"].lower()
36 |             if a in axes:
37 |                 scale[a] = item.get("Value", 1e-6) * 1e6  # as micron
38 |         try:
39 |             labels = [item["ImageChannelName"] for item in img_meta["Experiment"]["ExperimentBlocks"]["AcquisitionBlock"]["MultiTrackSetup"]["TrackSetup"]["Detectors"]["Detector"]]
40 |         except Exception:
41 |             labels = None
42 |     except KeyError:
43 |         scale = None
44 |         labels = None
45 | 
46 |     return ImageMetadata(
47 |         axes=axes,
48 |         scale=scale,
49 |         unit="μm",
50 |         metadata=img_meta,
51 |         labels=labels,
52 |     )
53 | 


--------------------------------------------------------------------------------
/impy/io/_mrc.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | 
  3 | from pathlib import Path
  4 | from typing import TYPE_CHECKING
  5 | import warnings
  6 | import numpy as np
  7 | from impy.io._registry import IO
  8 | from impy.io._utils import rechunk_to_ones, MemmapArrayWriter, ImpyArray, ImageData, ImageMetadata
  9 | 
 10 | from impy.axes import ImageAxesError
 11 | 
 12 | if TYPE_CHECKING:
 13 |     from mrcfile.mrcobject import MrcObject
 14 | 
 15 | @IO.mark_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz")
 16 | def _(path: str, memmap: bool = False) -> ImageData:
 17 |     """The MRC format reader"""
 18 |     import mrcfile
 19 | 
 20 |     if memmap:
 21 |         open_func = mrcfile.mmap
 22 |     else:
 23 |         open_func = mrcfile.open
 24 | 
 25 |     with open_func(path, permissive=True, mode="r") as mrc:
 26 |         meta = _parse_mrcfile(mrc)
 27 |         image = mrc.data
 28 | 
 29 |     return ImageData.from_metadata(image, meta)
 30 | 
 31 | 
 32 | @IO.mark_header_reader(".mrc", ".rec", ".st", ".map", ".mrc.gz", ".map.gz")
 33 | def _(path: str) -> ImageData:
 34 |     """The MRC header reader"""
 35 |     import mrcfile
 36 | 
 37 |     with mrcfile.mmap(path, permissive=True, mode="r") as mrc:
 38 |         meta = _parse_mrcfile(mrc)
 39 | 
 40 |     return meta
 41 | 
 42 | @IO.mark_writer(".mrc", ".rec", ".st", ".map")
 43 | def _(path: str, img: ImpyArray, lazy: bool = False):
 44 |     """The MRC writer."""
 45 | 
 46 |     import mrcfile
 47 | 
 48 |     if img.scale_unit == "nm":
 49 |         voxel_size = tuple(np.array(img.scale)[::-1] * 10)
 50 |     elif img.scale_unit in ("ang", "Å", "angstrom"):
 51 |         voxel_size = tuple(np.array(img.scale)[::-1])
 52 |     else:
 53 |         warnings.warn(
 54 |             f"Scale unit was {img.scale_unit}. Could not normalize scale."
 55 |         )
 56 |         voxel_size = (1.0, 1.0, 1.0)
 57 |     if len(voxel_size) == 2:
 58 |         voxel_size = (1.0,) + voxel_size
 59 | 
 60 |     if img.dtype == "bool":
 61 |         img = img.astype(np.int8)
 62 |     elif img.dtype == "float64":
 63 |         warnings.warn(
 64 |             "MRC format does not support float64. Converting to float32.",
 65 |             UserWarning,
 66 |             stacklevel=2,
 67 |         )
 68 |         img = img.astype(np.float32)
 69 |     if lazy:
 70 |         from dask import array as da
 71 | 
 72 |         mode = _MRC_MODE[img.dtype]
 73 |         mrc_mmap = mrcfile.new_mmap(path, img.shape, mrc_mode=mode, overwrite=True)
 74 |         mrc_mmap.voxel_size = voxel_size
 75 | 
 76 |         img_dask = rechunk_to_ones(img.value)
 77 |         writer = MemmapArrayWriter(path, mrc_mmap.data.offset, img.shape, img_dask.chunksize)
 78 |         da.store(img_dask, writer)
 79 |         return None
 80 | 
 81 |     # get voxel_size
 82 |     if img.axes not in ("zyx", "yx"):
 83 |         raise ImageAxesError(
 84 |             f"Can only save zyx- or yx- image as a mrc file, but image has {img.axes} "
 85 |             "axes."
 86 |         )
 87 |     if Path(path).exists():
 88 |         with mrcfile.open(path, mode="r+") as mrc:
 89 |             mrc.set_data(img.value)
 90 |             mrc.voxel_size = voxel_size
 91 | 
 92 |     else:
 93 |         with mrcfile.new(path) as mrc:
 94 |             mrc.set_data(img.value)
 95 |             mrc.voxel_size = voxel_size
 96 |     return None
 97 | 
 98 | _MRC_MODE = {
 99 |     np.dtype("int8"): 0,
100 |     np.dtype("int16"): 1,
101 |     np.dtype("float32"): 2,
102 |     np.dtype("complex64"): 4,
103 |     np.dtype("uint16"): 6,
104 |     np.dtype("float16"): 12,
105 | }
106 | 
107 | def _parse_mrcfile(mrc: MrcObject) -> ImageMetadata:
108 |     if mrc.is_single_image():
109 |         axes = "yx"
110 |     elif mrc.is_volume_stack():
111 |         axes = "tzyx"
112 |     else:
113 |         axes = "zyx"
114 | 
115 |     scale = dict.fromkeys(axes, 1.0)
116 |     for a in axes:
117 |         scale[a] = mrc.voxel_size[a] / 10
118 | 
119 |     return ImageMetadata(
120 |         axes=axes,
121 |         scale=scale,
122 |         unit={a: "nm" for a in axes},
123 |         metadata={},
124 |         labels=None,
125 |     )
126 | 


--------------------------------------------------------------------------------
/impy/io/_nd2.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | from typing import TYPE_CHECKING
 4 | from impy.io._registry import IO
 5 | from impy.io._utils import ImageData, ImageMetadata
 6 | 
 7 | if TYPE_CHECKING:
 8 |     from nd2 import ND2File
 9 | 
10 | @IO.mark_reader(".nd2")
11 | def _(path: str, memmap: bool = False):
12 |     import nd2
13 | 
14 |     with nd2.ND2File(path) as f:
15 |         if not memmap:
16 |             image = f.asarray()
17 |         else:
18 |             image = f.to_dask()
19 |         meta = _parse_nd2_metadata(f)
20 | 
21 |     return ImageData.from_metadata(image, meta)
22 | 
23 | @IO.mark_header_reader(".nd2")
24 | def _(path: str):
25 |     import nd2
26 | 
27 |     with nd2.ND2File(path) as f:
28 |         meta = _parse_nd2_metadata(f)
29 |     return meta
30 | 
31 | def _parse_nd2_metadata(f: ND2File) -> ImageMetadata:
32 |     from dataclasses import is_dataclass, asdict
33 | 
34 |     axes = "".join(f.sizes.keys()).lower()
35 |     vsize = f.voxel_size()
36 |     scale = dict(z=vsize.z, y=vsize.y, x=vsize.x)
37 |     metadata = f.metadata
38 |     labels = None
39 |     if "c" in axes:
40 |         try:
41 |             labels = []
42 |             for chn in metadata.channels:
43 |                 labels.append(chn.channel.name)
44 |         except Exception:
45 |             pass
46 |     if is_dataclass(metadata):
47 |         metadata = asdict(metadata)
48 | 
49 |     return ImageMetadata(
50 |         axes=axes,
51 |         scale=scale,
52 |         unit="μm",
53 |         metadata=metadata,
54 |         labels=labels,
55 |     )
56 | 


--------------------------------------------------------------------------------
/impy/io/_npy.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | from typing import Any, TYPE_CHECKING
 4 | import numpy as np
 5 | from impy.io._registry import IO
 6 | from impy.io._utils import get_channel_labels, ImpyArray, ImageData
 7 | 
 8 | if TYPE_CHECKING:
 9 |     from numpy.lib.npyio import NpzFile
10 | 
11 | @IO.mark_reader(".npy")
12 | def _(path: str, memmap: bool = False) -> ImageData:
13 |     """The numpy reader."""
14 |     if memmap:
15 |         image = np.load(path, mmap_mode="r", allow_pickle=True)
16 |     else:
17 |         image = np.load(path, allow_pickle=True)
18 |     return ImageData(
19 |         image=image,
20 |         axes=None,
21 |         scale=None,
22 |         unit=None,
23 |         metadata={},
24 |         labels=None,
25 |     )
26 | 
27 | 
28 | @IO.mark_writer(".npy")
29 | def _(path: str, img: ImpyArray, lazy: bool = False):
30 |     """The numpy writer."""
31 |     if lazy:
32 |         raise NotImplementedError("Lazy saving is not implemented for npy files.")
33 |     else:
34 |         np.save(path, img.value)
35 |     return None
36 | 
37 | 
38 | @IO.mark_reader(".npz")
39 | def _(path: str, memmap: bool = False) -> ImageData:
40 |     """The numpy reader."""
41 |     npz: NpzFile = np.load(path, mmap_mode="r", allow_pickle=True)
42 | 
43 |     none_scalar = _scalar(None)
44 |     metadata = npz.get("metadata", none_scalar).item()
45 |     if metadata is None:
46 |         metadata = {}
47 |     return ImageData(
48 |         image=npz["data"],
49 |         axes=npz.get("axes", none_scalar).item(),
50 |         scale=npz.get("scale", none_scalar).item(),
51 |         unit=npz.get("unit", none_scalar).item(),
52 |         metadata=metadata,
53 |         labels=npz.get("labels", none_scalar).item(),
54 |     )
55 | 
56 | 
57 | @IO.mark_writer(".npz")
58 | def _(path: str, img: ImpyArray, lazy: bool = False):
59 |     """The numpy writer."""
60 |     if lazy:
61 |         raise NotImplementedError("Lazy saving is not implemented for npz files.")
62 |     else:
63 |         np.savez(
64 |             path,
65 |             data=img.value,
66 |             axes=_scalar(str(img.axes)),
67 |             scale=_scalar(img.scale.asdict()),
68 |             metadata=_scalar(img.metadata),
69 |             unit=_scalar(img.scale_unit),
70 |             labels=_scalar(get_channel_labels(img.axes)),
71 |         )
72 |     return None
73 | 
74 | def _scalar(x: Any) -> np.ndarray:
75 |     ar = np.array(None, dtype=object)
76 |     ar[()] = x
77 |     return ar
78 | 


--------------------------------------------------------------------------------
/impy/io/_utils.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | 
  3 | from typing import TYPE_CHECKING, Any, Union, NamedTuple, Protocol
  4 | import numpy as np
  5 | 
  6 | if TYPE_CHECKING:
  7 |     from dask.array.core import Array
  8 |     from impy.arrays.bases import MetaArray
  9 |     from impy.arrays import LazyImgArray
 10 |     from impy.axes import Axes
 11 |     from numpy.typing import DTypeLike
 12 | 
 13 |     ImpyArray = Union[MetaArray, LazyImgArray]
 14 | else:
 15 |     ImpyArray = Any
 16 | 
 17 | def rechunk_to_ones(arr: Array):
 18 |     """Rechunk the array to (1, 1, ..., 1, n, Ny, Nx)"""
 19 |     size = np.prod(arr.chunksize)
 20 |     shape = arr.shape
 21 |     cur_prod = 1
 22 |     max_i = arr.ndim
 23 |     for i in reversed(range(arr.ndim)):
 24 |         cur_prod *= shape[i]
 25 |         if cur_prod > size:
 26 |             break
 27 |         max_i = i
 28 |     nslices = max(int(size / np.prod(shape[max_i:])), 1)
 29 |     if max_i == 0:
 30 |         return arr
 31 |     else:
 32 |         return arr.rechunk((1,) * (max_i - 1) + (nslices,) + shape[max_i:])
 33 | 
 34 | class MemmapArrayWriter:
 35 |     def __init__(
 36 |         self,
 37 |         path: str,
 38 |         offset: int,
 39 |         shape: tuple[int, ...],
 40 |         chunksize: tuple[int, ...],
 41 |     ):
 42 |         self._path = path
 43 |         self._offset = offset
 44 |         self._shape = shape  # original shape
 45 |         self._chunksize = chunksize  # chunk size
 46 |         # shape = (33, 160, 1000, 1000)
 47 |         # chunksize = (1, 16, 1000, 1000)
 48 |         border = 0
 49 |         for i, c in enumerate(chunksize):
 50 |             if c != 1:
 51 |                 border = i
 52 |                 break
 53 |         self._border = border
 54 | 
 55 |     def __setitem__(self, sl: tuple[slice, ...], arr: np.ndarray):
 56 |         # efficient: shape = (10, 100, 150) and sl = (3:5, 0:100, 0:150)
 57 |         # sl = (0:1, 16:32, 0:1000, 0:1000)
 58 | 
 59 |         offset = np.sum([sl[i].start * arr.strides[i] for i in range(self._border + 1)])
 60 |         arr_ravel = arr.ravel()
 61 |         mmap = np.memmap(
 62 |             self._path,
 63 |             mode="r+",
 64 |             offset=self._offset + offset,
 65 |             shape=arr_ravel.shape,
 66 |             dtype=arr.dtype,
 67 |         )
 68 |         mmap[:arr_ravel.size] = arr_ravel
 69 |         mmap.flush()
 70 | 
 71 | class _ImageType(Protocol):
 72 |     @property
 73 |     def ndim(self) -> int:
 74 |         """Should return the number of dimensions of the image."""
 75 | 
 76 |     @property
 77 |     def dtype(self) -> np.dtype:
 78 |         """Should return the data type of the image."""
 79 | 
 80 |     @property
 81 |     def shape(self) -> tuple[int, ...]:
 82 |         """Should return the shape of the image."""
 83 | 
 84 |     def astype(self, dtype: DTypeLike):
 85 |         """Should return an image with the specified data type."""
 86 | 
 87 | class ImageData(NamedTuple):
 88 |     """Tuple of image info."""
 89 | 
 90 |     image: _ImageType
 91 |     axes: str | None
 92 |     scale: dict[str, float] | None
 93 |     unit: dict[str, str | None] | str | None
 94 |     metadata: dict[str, Any]
 95 |     labels: list[Any]  # channel labels
 96 | 
 97 |     @classmethod
 98 |     def from_metadata(self, image: _ImageType, meta: ImageMetadata):
 99 |         return ImageData(
100 |             image=image,
101 |             axes=meta.axes,
102 |             scale=meta.scale,
103 |             unit=meta.unit,
104 |             metadata=meta.metadata,
105 |             labels=meta.labels,
106 |         )
107 | 
108 | class ImageMetadata(NamedTuple):
109 |     """Tuple of image info except for the image data itself."""
110 | 
111 |     axes: str | None
112 |     scale: dict[str, float] | None
113 |     unit: dict[str, str | None] | str | None
114 |     metadata: dict[str, Any]
115 |     labels: list[Any]  # channel labels
116 | 
117 | def get_channel_labels(axes: Axes):
118 |     if "c" in axes:
119 |         axis = axes["c"]
120 |         if axis.labels is not None:
121 |             return axis.labels
122 |     return None
123 | 


--------------------------------------------------------------------------------
/impy/io/_zarr.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | 
 3 | import os
 4 | import numpy as np
 5 | from impy.io._registry import IO
 6 | from impy.io._utils import get_channel_labels, ImpyArray, ImageData
 7 | 
 8 | from impy.axes import ImageAxesError
 9 | 
10 | 
11 | @IO.mark_reader(".zarr")
12 | def _(path: str, memmap: bool = False) -> ImageData:
13 |     """The zarr reader."""
14 |     import zarr
15 | 
16 |     zf = zarr.open(path, mode="r")
17 |     if memmap:
18 |         image = zf["data"]
19 |     else:
20 |         image = np.asarray(zf["data"])
21 |     return ImageData(
22 |         image=image,
23 |         axes=zf.attrs.get("axes", None),
24 |         scale=zf.attrs.get("scale", None),
25 |         unit=zf.attrs.get("unit", None),
26 |         metadata=zf.attrs.get("metadata", {}),
27 |         labels=zf.attrs.get("labels", None),
28 |     )
29 | 
30 | 
31 | @IO.mark_writer(".zarr")
32 | def _(path: str, img: ImpyArray, lazy: bool = False):
33 |     """The zarr writer."""
34 |     import zarr
35 | 
36 |     f = zarr.open(path, mode="w")
37 |     metadata = img.metadata.copy()
38 | 
39 |     f.attrs["axes"] = str(img.axes)
40 |     f.attrs["scale"] = {str(a): v for a, v in img.scale.items()}
41 |     f.attrs["metadata"] = metadata
42 |     f.attrs["unit"] = img.scale_unit
43 |     f.attrs["labels"] = get_channel_labels(img.axes)
44 |     if lazy:
45 |         img.value.to_zarr(url=os.path.join(path, "data"))
46 |     else:
47 |         z = img.value
48 |         f.array("data", z)
49 |     return None
50 | 


--------------------------------------------------------------------------------
/impy/lazy/__init__.py:
--------------------------------------------------------------------------------
1 | from .core import *  # noqa
2 | from . import random  # noqa
3 | 


--------------------------------------------------------------------------------
/impy/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/impy/utils/__init__.py


--------------------------------------------------------------------------------
/impy/utils/axesop.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | import numpy as np
  3 | from ..axes import Axes, Axis, UndefAxis, AxisLike
  4 | 
  5 | 
  6 | def find_first_appeared(axes, include="", exclude=""):
  7 |     include = list(include)
  8 |     exclude = list(exclude)
  9 |     for a in axes:
 10 |         if a in include and not a in exclude:
 11 |             return a
 12 |     raise ValueError(f"Inappropriate axes: {axes}")
 13 | 
 14 | def add_axes(axes: Axes, shape: tuple[int, ...], key: np.ndarray, key_axes="yx"):
 15 |     """
 16 |     Stack `key` to make its shape key_axes-> axes.
 17 |     """
 18 |     key_axes = list(key_axes)
 19 |     if shape == key.shape:
 20 |         return key
 21 | 
 22 |     for i, o in enumerate(axes):
 23 |         if o not in key_axes:
 24 |             key = np.stack([key] * shape[i], axis=i)
 25 |     return key
 26 | 
 27 | 
 28 | def complement_axes(axes, all_axes="ptzcyx") -> list[AxisLike]:
 29 |     c_axes = []
 30 |     axes_list = list(axes)
 31 |     for a in all_axes:
 32 |         if a not in axes_list:
 33 |             c_axes.append(a)
 34 |     return c_axes
 35 | 
 36 | 
 37 | def switch_slice(axes, all_axes, ifin=np.newaxis, ifnot=":"):
 38 |     axes = list(axes)
 39 |     if ifnot == ":":
 40 |         ifnot = [slice(None)] * len(all_axes)
 41 |     elif not hasattr(ifnot, "__iter__"):
 42 |         ifnot = [ifnot] * len(all_axes)
 43 |         
 44 |     if not hasattr(ifin, "__iter__"):
 45 |         ifin = [ifin] * len(all_axes)
 46 |         
 47 |     sl = []
 48 |     for a, slin, slout in zip(all_axes, ifin, ifnot):
 49 |         if a in axes:
 50 |             sl.append(slin)
 51 |         else:
 52 |             sl.append(slout)
 53 |     sl = tuple(sl)
 54 |     return sl
 55 | 
 56 | 
 57 | def slice_axes(axes: Axes, key):
 58 |     ndim = len(axes)
 59 |     if isinstance(key, tuple):
 60 |         ndim += sum(k is None for k in key)
 61 |         rest = ndim - len(key)
 62 |         if any(k is ... for k in key):
 63 |             idx = key.index(...)
 64 |             _keys = key[:idx] + (slice(None),) * (rest + 1) + key[idx + 1:]
 65 |         else:
 66 |             _keys = key + (slice(None),) * rest
 67 |     elif isinstance(key, np.ndarray) or hasattr(key, "__array__"):
 68 |         if key.ndim == 1:
 69 |             new_axes = axes
 70 |         else:
 71 |             new_axes = [UndefAxis()] + axes[key.ndim:]
 72 |         return new_axes
 73 |     elif key is None:
 74 |         return [UndefAxis()] + axes
 75 |     elif key is ...:
 76 |         return axes
 77 |     else:
 78 |         _keys = (key,) +(slice(None),) * (ndim - 1)
 79 | 
 80 |     new_axes: list[Axis] = []
 81 |     list_idx: list[int] = []
 82 | 
 83 |     axes_iter = iter(axes)
 84 |     for sl in _keys:
 85 |         if sl is not None:
 86 |             a = next(axes_iter)
 87 |             if isinstance(sl, (slice, np.ndarray)):
 88 |                 new_axes.append(a.slice_axis(sl))
 89 |             elif isinstance(sl, list):
 90 |                 new_axes.append(a.slice_axis(sl))
 91 |                 list_idx.append(a)
 92 |         else:
 93 |             new_axes.append(UndefAxis())  # new axis
 94 |         
 95 |     if len(list_idx) > 1:
 96 |         added = False
 97 |         out: list[Axis] = []
 98 |         for a in new_axes:
 99 |             if a not in list_idx:
100 |                 out.append(a)
101 |             elif not added:
102 |                 out.append(UndefAxis())
103 |                 added = True
104 |         new_axes = out
105 | 
106 |     return new_axes
107 | 


--------------------------------------------------------------------------------
/impy/utils/gauss.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | from typing import Any
  3 | import numpy as np
  4 | 
  5 | def square(params, func, r, z):
  6 |     """
  7 |     calculate ||z - func(x, y, *params)||^2
  8 |     where x and y are determine by z.shape
  9 |     """
 10 |     z_guess = func(r, *params)
 11 |     return np.mean((z - z_guess)**2)
 12 | 
 13 | def masked_square(params, func, r, z, mask):
 14 |     z_guess = func(r, *params)
 15 |     return np.mean((z[mask] - z_guess[mask])**2)
 16 | 
 17 | def diagonal_gaussian(r, *params):
 18 |     a, b = params[-2:]
 19 |     ndim = len(params[:-2])//2
 20 |     mu = params[:ndim]
 21 |     sg = params[ndim:-2]
 22 |     z_value = np.array(
 23 |         [(x0 - mu0) / sg0 for x0, mu0, sg0 in zip(r, mu, sg)],
 24 |         dtype=np.float32
 25 |     )
 26 |     return a * np.exp(-np.sum(z_value**2, axis=0) / 2) + b
 27 | 
 28 | class Gaussian:
 29 |     def mu_inrange(self, low, high):
 30 |         return np.logical_and(low<=self.mu, self.mu<=high).all()
 31 | 
 32 |     def sg_inrange(self, low, high):
 33 |         sg_ = np.abs(self.sg)
 34 |         return np.logical_and(low<=sg_, sg_<=high).all()
 35 | 
 36 | class DiagonalGaussian(Gaussian):
 37 |     def __init__(self, params=None):
 38 |         if params is None:
 39 |             self.mu = self.sg = self.a = self.b = None
 40 |         else:
 41 |             self.mu, self.sg, self.a, self.b = params
 42 | 
 43 |     @property
 44 |     def mu(self):
 45 |         return self._mu
 46 | 
 47 |     @mu.setter
 48 |     def mu(self, value):
 49 |         if value is None:
 50 |             self._mu = None
 51 |         else:
 52 |             self._mu = np.asarray(value)
 53 | 
 54 |     @property
 55 |     def sg(self):
 56 |         return self._sg
 57 | 
 58 |     @sg.setter
 59 |     def sg(self, value):
 60 |         if value is None:
 61 |             self._sg = None
 62 |         else:
 63 |             self._sg = np.asarray(value)
 64 | 
 65 |     @property
 66 |     def params(self):
 67 |         """Get flattened parameters."""
 68 |         return tuple(self.mu) + tuple(self.sg) + (self.a, self.b)
 69 | 
 70 |     @params.setter
 71 |     def params(self, params:tuple):
 72 |         self.a, self.b = params[-2:]
 73 |         self.mu = params[:self.ndim]
 74 |         self.sg = params[self.ndim:-2]
 75 | 
 76 |     def asdict(self) -> dict[str, Any]:
 77 |         return {
 78 |             "mu": self.mu.tolist(),
 79 |             "sigma": self.sg.tolist(),
 80 |             "A": self.a,
 81 |             "B": self.b,
 82 |         }
 83 | 
 84 |     @property
 85 |     def ndim(self):
 86 |         return self.mu.size
 87 | 
 88 |     def fit(
 89 |         self,
 90 |         data: np.ndarray,
 91 |         method: str = "Powell",
 92 |         mask: np.ndarray | None = None,
 93 |     ):
 94 |         from scipy.optimize import minimize
 95 |         if self.mu is None or self.sg is None or self.a is None or self.b is None:
 96 |             if mask is not None:
 97 |                 data = data.copy()
 98 |                 data[mask] = -np.inf
 99 |                 self._estimate_params(data)
100 |             else:
101 |                 self._estimate_params(data)
102 |         r = np.indices(data.shape)
103 | 
104 |         if mask is None:
105 |             result = minimize(
106 |                 square,
107 |                 self.params,
108 |                 args=(diagonal_gaussian, r, data),
109 |                 method=method
110 |             )
111 |         else:
112 |             if mask.shape != data.shape:
113 |                 raise ValueError(
114 |                     f"Shape mismatch between data {data.shape!r} and mask {mask.shape!r}."
115 |                 )
116 |             result = minimize(
117 |                 masked_square,
118 |                 self.params,
119 |                 args=(diagonal_gaussian, r, data, ~mask),
120 |                 method=method
121 |             )
122 |         self.params = result.x
123 | 
124 |         return result
125 | 
126 |     def rescale(self, scale: float):
127 |         self.mu *= scale
128 |         self.sg *= scale
129 |         return None
130 | 
131 |     def shift(self, dxdy):
132 |         self.mu += np.array(dxdy)
133 |         return None
134 | 
135 |     def generate(self, shape:tuple) -> np.ndarray:
136 |         r = np.indices(shape, dtype=np.float32)
137 |         return diagonal_gaussian(r, *self.params)
138 | 
139 |     def _estimate_params(self, data: np.ndarray):
140 |         pass
141 | 
142 | class GaussianParticle(DiagonalGaussian):
143 |     def __init__(self, params=None, initial_sg=1):
144 |         super().__init__(params)
145 |         self.initial_sg = initial_sg
146 | 
147 |     def _estimate_params(self, data:np.ndarray):
148 |         # n-dim argmax
149 |         self.mu = np.array(np.unravel_index(np.argmax(data), data.shape), dtype="float32")
150 |         self.sg = np.full(data.ndim, self.initial_sg, dtype="float32")
151 |         self.b, p95 = np.percentile(data, [5, 95])
152 |         self.a = p95 - self.b
153 |         return None
154 | 
155 | class GaussianBackground(DiagonalGaussian):
156 |     def _estimate_params(self, data: np.ndarray):
157 |         # n-dim argmax
158 |         self.mu = np.array(np.unravel_index(np.argmax(data), data.shape), dtype="float32")
159 |         self.sg = np.array(data.shape, dtype="float32")
160 |         self.b, p95 = np.percentile(data, [5, 95])
161 |         self.a = p95 - self.b
162 |         return None
163 | 


--------------------------------------------------------------------------------
/impy/utils/misc.py:
--------------------------------------------------------------------------------
 1 | from __future__ import annotations
 2 | from typing import Sequence, TypeVar
 3 | import numpy as np
 4 | 
 5 | T = TypeVar("T")
 6 | 
 7 | def check_nd(x: T, ndim: int) -> Sequence[T]:
 8 |     if np.isscalar(x):
 9 |         x = (x,) * ndim
10 |     elif len(x) != ndim:
11 |         raise ValueError("length of parameter and dimension must match.")
12 |     return x
13 |     
14 | 
15 | def largest_zeros(shape) -> np.ndarray:
16 |     try:
17 |         out = np.zeros(shape, dtype=np.uint64)
18 |     except MemoryError:
19 |         try:
20 |             out = np.zeros(shape, dtype=np.uint32)
21 |         except MemoryError:
22 |             out = np.zeros(shape, dtype=np.uint16)
23 |     return out
24 | 


--------------------------------------------------------------------------------
/impy/utils/slicer.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | 
  3 | from abc import ABC, abstractmethod
  4 | from functools import lru_cache
  5 | import math
  6 | from typing import Any, Mapping
  7 | from impy._types import Slices
  8 | from impy.axes import Slicer, Axes
  9 | 
 10 | __all__ = ["str_to_slice", "solve_slicer"]
 11 | 
 12 | class _Slicer(ABC):
 13 |     def str_to_slice(self, v: str) -> list[int] | slice | int:
 14 |         v = v.replace(" ", "")
 15 |         if "," in v:
 16 |             sl = sum((self._range_to_list(v) for v in v.split(",")), [])
 17 |         elif ":" in v:
 18 |             sl = slice(*map(self._int_or_none, v.split(":")))
 19 |         else:
 20 |             sl = self._int(v)
 21 |         return sl
 22 |     
 23 |     def _range_to_list(self, v: str) -> list[int]:    
 24 |         if ":" in v:
 25 |             s, e = v.split(":")
 26 |             return list(range(self._int(s), self._int(e)))
 27 |         else:
 28 |             return [self._int(v)]
 29 | 
 30 |     def _int_or_none(self, v: str) -> int | None:
 31 |         if v:
 32 |             return self._int(v)
 33 |         else:
 34 |             return None
 35 | 
 36 |     @abstractmethod
 37 |     def _int(self, v: str) -> int:
 38 |         """Convert a string to an integer."""
 39 | 
 40 |     
 41 | def str_to_slice(v: str) -> list[int] | slice | int:
 42 |     return ConstSlicer().str_to_slice(v)
 43 | 
 44 | class ConstSlicer(_Slicer):
 45 |     def _int(self, v: str) -> int:
 46 |         return int(v)
 47 | 
 48 | class EvalSlicer(_Slicer):
 49 |     def __init__(self, size: int):
 50 |         self._size = size
 51 | 
 52 |     def _int(self, v: str) -> int:
 53 |         ns = {
 54 |             "N": self._size,
 55 |             "int": int,
 56 |             "ceil": math.ceil,
 57 |             "floor": math.floor,
 58 |             "round": round,
 59 |             "__builtins__": {},
 60 |         }
 61 |         out = eval(v, ns)
 62 |         if not hasattr(out, "__index__"):
 63 |             raise ValueError(f"Invalid index: {v!r}.")
 64 |         return out.__index__()
 65 | 
 66 | 
 67 | def axis_targeted_slicing(
 68 |     axes: tuple[str, ...], 
 69 |     string: str,
 70 |     shape: tuple[int, ...] | None = None,
 71 | ) -> Slices:
 72 |     """
 73 |     Make a conventional slices from an axis-targeted slicing string.
 74 | 
 75 |     Parameters
 76 |     ----------
 77 |     axes : str
 78 |         Axes of input ndarray.
 79 |     string : str
 80 |         Axis-targeted slicing string. If an axis that does not exist in `axes` is
 81 |         contained, this function will raise ValueError.
 82 | 
 83 |     Returns
 84 |     -------
 85 |     slices
 86 |     """    
 87 |     if "N" in string:
 88 |         return axis_targeted_slicing_eval(axes, string, shape)
 89 |     else:
 90 |         return axis_targeted_slicing_const(axes, string)
 91 | 
 92 | @lru_cache
 93 | def axis_targeted_slicing_const(axes: tuple[str, ...], string: str) -> Slices:
 94 |     keylist = string.replace(" ", "").split(";")
 95 |     dict_slicer: dict[str, Any] = {}
 96 |     
 97 |     for k in keylist:
 98 |         if k.count("=") != 1:
 99 |             raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
100 |         axis, sl_str = k.split("=")
101 |         try:
102 |             sl = str_to_slice(sl_str)
103 |         except ValueError:
104 |             raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
105 |         else:
106 |             dict_slicer[axis] = sl
107 |     
108 |     return _dict_to_slice(dict_slicer, axes)
109 | 
110 | def axis_targeted_slicing_eval(
111 |     axes: tuple[str, ...], 
112 |     string: str, 
113 |     shape: tuple[int, ...] | None = None,
114 | ) -> Slices:
115 |     keylist = string.replace(" ", "").split(";")
116 |     dict_slicer: dict[str, Any] = {}
117 |     
118 |     for k in keylist:
119 |         if k.count("=") != 1:
120 |             raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
121 |         axis, sl_str = k.split("=")
122 |         try:
123 |             size = shape[axes.index(axis)]
124 |             sl = EvalSlicer(size).str_to_slice(sl_str)
125 |         except ValueError:
126 |             raise ValueError(f"Informal axis-targeted slicing: {k!r}.")
127 |         else:
128 |             dict_slicer[axis] = sl
129 |     
130 |     return _dict_to_slice(dict_slicer, axes)
131 | 
132 | def _dict_to_slice(sl: dict[str, Any], axes: tuple[str, ...]):
133 |     sl_list = [slice(None)] * len(axes)
134 |     
135 |     for k, v in sl.items():
136 |         idx = axes.index(k)
137 |         sl_list[idx] = v
138 |     
139 |     return tuple(sl_list)
140 | 
141 | def solve_slicer(key: Any, axes: Axes, shape: tuple[int, ...] | None = None) -> Slices:
142 |     if isinstance(key, str):
143 |         key = axis_targeted_slicing(tuple(axes), key, shape)
144 |     
145 |     elif isinstance(key, (Mapping, Slicer)):
146 |         key = axes.create_slice(key)
147 |     
148 |     return key
149 | 


--------------------------------------------------------------------------------
/impy/utils/utilcls.py:
--------------------------------------------------------------------------------
 1 | from importlib import import_module
 2 | 
 3 | __all__ = ["ImportOnRequest"]
 4 | 
 5 | 
 6 | class ImportOnRequest:
 7 |     def __init__(self, name: str):
 8 |         self.name = name
 9 |     
10 |     def __getattr__(self, name: str):
11 |         try:
12 |             mod = super().__getattribute__("mod")
13 |         except AttributeError:
14 |             self.mod = import_module(self.name)
15 |             mod = super().__getattribute__("mod")
16 |         return getattr(mod, name)
17 | 


--------------------------------------------------------------------------------
/impy/viewer/__init__.py:
--------------------------------------------------------------------------------
 1 | try:
 2 |     from .viewer import napariViewers
 3 | except ImportError:
 4 |     class napariViewer:
 5 |         def __getattr__(self, key):
 6 |             raise ModuleNotFoundError(
 7 |                 "napari viewer could not be constructed due to ImportError."
 8 |             )
 9 | 
10 | __all__ = ["napariViewers"]
11 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["hatchling>=1.26.1"]
 3 | build-backend = "hatchling.build"
 4 | 
 5 | [project]
 6 | name = "impy-array"
 7 | dynamic = ["version"]
 8 | description = "Speed up coding/extending image analysis in Python."
 9 | readme = "README.md"
10 | license = { file = "LICENSE" }
11 | requires-python = ">=3.9"
12 | classifiers = [
13 |     "Programming Language :: Python :: Implementation :: CPython",
14 |     "Programming Language :: Python :: Implementation :: PyPy",
15 |     "Programming Language :: Python :: 3 :: Only",
16 |     "Programming Language :: Python :: 3.9",
17 |     "Programming Language :: Python :: 3.10",
18 |     "Programming Language :: Python :: 3.11",
19 |     "Programming Language :: Python :: 3.12",
20 |     "Programming Language :: Python :: 3.13",
21 | ]
22 | authors = [
23 |     { name = "Hanjin Liu", email = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp" },
24 | ]
25 | dependencies = [
26 |     "dask>=2021.6.0",
27 |     "numpy>=1.22",
28 |     "scipy>=1.7",
29 |     "pandas>=1.3",
30 |     "scikit-image>=0.20.0",
31 | ]
32 | 
33 | [project.optional-dependencies]
34 | all = [
35 |     "tifffile",
36 |     "roifile",
37 |     "mrcfile",
38 |     "napari>=0.4.17",
39 |     "zarr",
40 | ]
41 | napari = [
42 |     "napari>=0.4.17",
43 | ]
44 | tiff = [
45 |     "tifffile",
46 | ]
47 | mrc = [
48 |     "mrcfile",
49 | ]
50 | zarr = [
51 |     "zarr",
52 | ]
53 | testing = [
54 |     "pytest",
55 |     "dask_image",
56 |     "tifffile",
57 |     "roifile",
58 |     "mrcfile",
59 |     "zarr",
60 | ]
61 | 
62 | [project.scripts]
63 | impy = "impy.__main__:main"
64 | 
65 | [project.urls]
66 | Download = "https://github.com/hanjinliu/impy"
67 | 
68 | [tool.hatch.version]
69 | path = "impy/__init__.py"
70 | 
71 | [tool.hatch.build.targets.sdist]
72 | include = [
73 |     "/impy",
74 | ]
75 | 
76 | [tool.hatch.build.targets.wheel]
77 | packages = [
78 |     "/impy"
79 | ]
80 | 


--------------------------------------------------------------------------------
/rst/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line, and also
 5 | # from the environment for the first two.
 6 | SPHINXOPTS    ?=
 7 | SPHINXBUILD   ?= sphinx-build
 8 | SOURCEDIR     = .
 9 | BUILDDIR      = _build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
21 | 


--------------------------------------------------------------------------------
/rst/api.rst:
--------------------------------------------------------------------------------
 1 | API References
 2 | ==============
 3 | 
 4 | .. toctree::
 5 |    :maxdepth: 2
 6 |    :caption: Contents:
 7 | 
 8 |    ./apidoc/impy
 9 |    ./apidoc/impy.arrays
10 |    ./apidoc/impy.frames
11 |    ./apidoc/impy.viewer
12 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.arrays.bases.rst:
--------------------------------------------------------------------------------
 1 | impy.arrays.bases package
 2 | =========================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.arrays.bases.metaarray module
 8 | ----------------------------------
 9 | 
10 | .. automodule:: impy.arrays.bases.metaarray
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.arrays.bases.overload module
16 | ---------------------------------
17 | 
18 | .. automodule:: impy.arrays.bases.overload
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.arrays.bases
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.arrays.rst:
--------------------------------------------------------------------------------
 1 | impy.arrays package
 2 | ===================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    impy.arrays.bases
11 | 
12 | Submodules
13 | ----------
14 | 
15 | impy.arrays.axesmixin module
16 | ----------------------------
17 | 
18 | .. automodule:: impy.arrays.axesmixin
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | impy.arrays.big module
24 | ----------------------
25 | 
26 | .. automodule:: impy.arrays.big
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | impy.arrays.imgarray module
32 | ---------------------------
33 | 
34 | .. automodule:: impy.arrays.imgarray
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | impy.arrays.label module
40 | ------------------------
41 | 
42 | .. automodule:: impy.arrays.label
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | impy.arrays.labeledarray module
48 | -------------------------------
49 | 
50 | .. automodule:: impy.arrays.labeledarray
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | impy.arrays.lazy module
56 | -----------------------
57 | 
58 | .. automodule:: impy.arrays.lazy
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 
63 | impy.arrays.phasearray module
64 | -----------------------------
65 | 
66 | .. automodule:: impy.arrays.phasearray
67 |    :members:
68 |    :undoc-members:
69 |    :show-inheritance:
70 | 
71 | impy.arrays.specials module
72 | ---------------------------
73 | 
74 | .. automodule:: impy.arrays.specials
75 |    :members:
76 |    :undoc-members:
77 |    :show-inheritance:
78 | 
79 | impy.arrays.tiled module
80 | ------------------------
81 | 
82 | .. automodule:: impy.arrays.tiled
83 |    :members:
84 |    :undoc-members:
85 |    :show-inheritance:
86 | 
87 | Module contents
88 | ---------------
89 | 
90 | .. automodule:: impy.arrays
91 |    :members:
92 |    :undoc-members:
93 |    :show-inheritance:
94 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.axes.rst:
--------------------------------------------------------------------------------
 1 | impy.axes package
 2 | =================
 3 | 
 4 | Module contents
 5 | ---------------
 6 | 
 7 | .. automodule:: impy.axes
 8 |    :members:
 9 |    :undoc-members:
10 |    :show-inheritance:
11 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.frame.rst:
--------------------------------------------------------------------------------
 1 | impy.frame package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.frame.frames module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.frame.frames
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: impy.frame
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.lazy.rst:
--------------------------------------------------------------------------------
 1 | impy.lazy package
 2 | =================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.lazy.core module
 8 | ---------------------
 9 | 
10 | .. automodule:: impy.lazy.core
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.lazy.random module
16 | -----------------------
17 | 
18 | .. automodule:: impy.lazy.random
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.lazy
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.rst:
--------------------------------------------------------------------------------
 1 | impy package
 2 | ============
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    impy.arrays
11 |    impy.axes
12 |    impy.frame
13 |    impy.lazy
14 |    impy.utils
15 |    impy.viewer
16 | 
17 | Submodules
18 | ----------
19 | 
20 | impy.array\_api module
21 | ----------------------
22 | 
23 | .. automodule:: impy.array_api
24 |    :members:
25 |    :undoc-members:
26 |    :show-inheritance:
27 | 
28 | impy.binder module
29 | ------------------
30 | 
31 | .. automodule:: impy.binder
32 |    :members:
33 |    :undoc-members:
34 |    :show-inheritance:
35 | 
36 | impy.collections module
37 | -----------------------
38 | 
39 | .. automodule:: impy.collections
40 |    :members:
41 |    :undoc-members:
42 |    :show-inheritance:
43 | 
44 | impy.core module
45 | ----------------
46 | 
47 | .. automodule:: impy.core
48 |    :members:
49 |    :undoc-members:
50 |    :show-inheritance:
51 | 
52 | impy.correlation module
53 | -----------------------
54 | 
55 | .. automodule:: impy.correlation
56 |    :members:
57 |    :undoc-members:
58 |    :show-inheritance:
59 | 
60 | impy.io module
61 | --------------
62 | 
63 | .. automodule:: impy.io
64 |    :members:
65 |    :undoc-members:
66 |    :show-inheritance:
67 | 
68 | impy.random module
69 | ------------------
70 | 
71 | .. automodule:: impy.random
72 |    :members:
73 |    :undoc-members:
74 |    :show-inheritance:
75 | 
76 | impy.roi module
77 | ---------------
78 | 
79 | .. automodule:: impy.roi
80 |    :members:
81 |    :undoc-members:
82 |    :show-inheritance:
83 | 
84 | Module contents
85 | ---------------
86 | 
87 | .. automodule:: impy
88 |    :members:
89 |    :undoc-members:
90 |    :show-inheritance:
91 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.utils.rst:
--------------------------------------------------------------------------------
 1 | impy.utils package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.utils.axesop module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.utils.axesop
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.utils.deco module
16 | ----------------------
17 | 
18 | .. automodule:: impy.utils.deco
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | impy.utils.gauss module
24 | -----------------------
25 | 
26 | .. automodule:: impy.utils.gauss
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | impy.utils.misc module
32 | ----------------------
33 | 
34 | .. automodule:: impy.utils.misc
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | impy.utils.slicer module
40 | ------------------------
41 | 
42 | .. automodule:: impy.utils.slicer
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | impy.utils.utilcls module
48 | -------------------------
49 | 
50 | .. automodule:: impy.utils.utilcls
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | Module contents
56 | ---------------
57 | 
58 | .. automodule:: impy.utils
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 


--------------------------------------------------------------------------------
/rst/apidoc/impy.viewer.rst:
--------------------------------------------------------------------------------
 1 | impy.viewer package
 2 | ===================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | impy.viewer.utils module
 8 | ------------------------
 9 | 
10 | .. automodule:: impy.viewer.utils
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | impy.viewer.viewer module
16 | -------------------------
17 | 
18 | .. automodule:: impy.viewer.viewer
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | Module contents
24 | ---------------
25 | 
26 | .. automodule:: impy.viewer
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 


--------------------------------------------------------------------------------
/rst/apidoc/modules.rst:
--------------------------------------------------------------------------------
1 | impy
2 | ====
3 | 
4 | .. toctree::
5 |    :maxdepth: 4
6 | 
7 |    impy
8 | 


--------------------------------------------------------------------------------
/rst/conf.py:
--------------------------------------------------------------------------------
 1 | # Configuration file for the Sphinx documentation builder.
 2 | #
 3 | # This file only contains a selection of the most common options. For a full
 4 | # list see the documentation:
 5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html
 6 | 
 7 | # -- Path setup --------------------------------------------------------------
 8 | 
 9 | # If extensions (or modules to document with autodoc) are in another directory,
10 | # add these directories to sys.path here. If the directory is relative to the
11 | # documentation root, use os.path.abspath to make it absolute, like shown here.
12 | #
13 | import os
14 | import sys
15 | sys.path.insert(0, os.path.abspath('../'))
16 | import impy
17 | import sphinx_rtd_theme
18 | 
19 | # -- Project information -----------------------------------------------------
20 | 
21 | project = 'impy'
22 | copyright = '2021, Hanjin Liu'
23 | author = 'Hanjin Liu'
24 | 
25 | # The full version, including alpha/beta/rc tags
26 | version = impy.__version__
27 | release = impy.__version__
28 | 
29 | 
30 | # -- General configuration ---------------------------------------------------
31 | 
32 | # Add any Sphinx extension module names here, as strings. They can be
33 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
34 | # ones.
35 | extensions = ['sphinx.ext.autodoc', 
36 |               'sphinx.ext.napoleon',
37 |               'sphinx.ext.viewcode',
38 |               'sphinx.ext.githubpages',
39 |               'sphinxcontrib.blockdiag',
40 |               ]
41 | 
42 | blockdiag_html_image_format = 'SVG'
43 | 
44 | # Add any paths that contain templates here, relative to this directory.
45 | templates_path = ['_templates']
46 | 
47 | # List of patterns, relative to source directory, that match files and
48 | # directories to ignore when looking for source files.
49 | # This pattern also affects html_static_path and html_extra_path.
50 | exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
51 | 
52 | 
53 | # -- Options for HTML output -------------------------------------------------
54 | 
55 | # The theme to use for HTML and HTML Help pages.  See the documentation for
56 | # a list of builtin themes.
57 | #
58 | html_theme = 'sphinx_rtd_theme'
59 | html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
60 | 
61 | # Add any paths that contain custom static files (such as style sheets) here,
62 | # relative to this directory. They are copied after the builtin static files,
63 | # so a file named "default.css" will overwrite the builtin "default.css".
64 | html_static_path = ['_static']


--------------------------------------------------------------------------------
/rst/gallery/drift_correction.rst:
--------------------------------------------------------------------------------
  1 | ================
  2 | Drift Correction
  3 | ================
  4 | 
  5 | Stage shift during image acquisition is a general problem of microscopy.
  6 | Here shows how to correct the shift using ``drift_correction`` method.
  7 | 
  8 | .. contents:: Contents
  9 |     :local:
 10 |     :depth: 1
 11 | 
 12 | 
 13 | Simplest Correction
 14 | ===================
 15 | 
 16 | We'll create a sample image stack by applying random shifts to an image using ``affine`` method
 17 | and Gaussian noise using ``ip.random.normal`` function.
 18 | 
 19 | .. code-block:: python
 20 |     
 21 |     import numpy as np
 22 |     import impy as ip
 23 | 
 24 |     t_total = 10
 25 |     max_shift = 6
 26 |     img0 = ip.zeros((64, 64))
 27 |     img0[28:36, 22:30] += 1.0
 28 | 
 29 |     imgs = []
 30 |     shifts = (2 * np.random.random((t_total, 2)) - 1.0) * max_shift  # random shift
 31 |     for shift in shifts:
 32 |         img_shift = img0.affine(translation=shift) + ip.random.normal(scale=0.3, size=(64, 64)) 
 33 |         imgs.append(img_shift)
 34 | 
 35 |     img = np.stack(imgs, axis="t")
 36 | 
 37 | The ``img`` is a 3-D image stack with a randomly shifting rectangle in the center.
 38 | 
 39 | ``drift_correction`` method uses phase cross-correlation to track drift and restore non-drifted
 40 | image by Affine transformation. Relative shift between neighbors are calculated.
 41 | 
 42 | It is very simple to obtain the corrected image.
 43 | 
 44 | .. code-block:: python
 45 | 
 46 |     img_corrected = img.drift_correction()
 47 |     img_corrected = img.drift_correction(along="t")  # explicitly specify the "time" axis.
 48 |     
 49 |     img_corrected.imshow()
 50 | 
 51 | Multi-dimensional Correction
 52 | ============================
 53 | 
 54 | By default, ``drift_correction`` consider ``"y", "x"`` axes as the spatial dimensions and conduct
 55 | 2-D correction unlike many of other methods. This is because image drift usually occurs in XY
 56 | direction. The example below:
 57 | 
 58 | .. code-block:: python
 59 | 
 60 |     img4d = ip.random.normal(size=(10, 4, 64, 64), axes="tzyx")
 61 |     img_corrected = img4d.drift_correction()
 62 | 
 63 | is almost equal to:
 64 | 
 65 | .. code-block:: python
 66 | 
 67 |     out = []
 68 |     for z in range(4):
 69 |         out.append(img4d[:, z].drift_correction())
 70 |     img_corrected = np.stack(out, axis="z")
 71 | 
 72 | .. note::
 73 | 
 74 |     ``drift_correct`` uses the most plausible axis as the "time" axis. To avoid unexpected error
 75 |     you should specify ``along`` argument when correction >4 dimensional images.
 76 | 
 77 | Correction with Reference
 78 | =========================
 79 | 
 80 | Sometimes you may want to supply a "reference" image stack to determine drift, instead of using 
 81 | the image itself. There are many occasions that you should think of this.
 82 | 
 83 | - Multi-channel image. In most cases, image shifts are the same among all the channels. You
 84 |   may want to choose one of the channels (a channel that is the most static) for tracking.
 85 | - Images with strong noises. You should not use the region of an image stack if that region 
 86 |   contains such kind of noises. For instance, cropping the image at its edges like
 87 |   ``img["y=40:-40;x=40:-40"]`` will be helpful.
 88 | - Use calculated images. A simple case is to use a filtrated reference image stack.
 89 | 
 90 | ``drift_correction`` takes ``ref`` argument to do this. If ``ref`` is given, ``drift_correction``
 91 | checks dimensionalities of the image to correct and the reference image and can flexibly apply
 92 | tracking and correction.
 93 | 
 94 | .. code-block:: python
 95 | 
 96 |     # Use the first channel to track drift of a multi-channel image
 97 |     img = ip.random.normal((10, 3, 64, 64), axes="tcyx")
 98 |     img_corrected = img.drift_correction(ref=img["c=0"])
 99 | 
100 |     # Use the center of an image
101 |     img = ip.random.normal((10, 8, 64, 64), axes="tzyx")
102 |     img_corrected = img.drift_correction(ref=img["y=40:-40;x=40:-40"])
103 | 
104 |     # Use Gaussian-filtrated image
105 |     img = ip.random.normal((10, 8, 64, 64), axes="tzyx")
106 |     img_corrected = img.drift_correction(ref=img.gaussian_filter())
107 | 
108 | Correct Large Images
109 | ====================
110 | 
111 | TODO


--------------------------------------------------------------------------------
/rst/gallery/index.rst:
--------------------------------------------------------------------------------
 1 | =======
 2 | Gallery
 3 | =======
 4 | 
 5 | .. toctree::
 6 |    :maxdepth: 1
 7 | 
 8 |    filters
 9 |    regionprops
10 | 


--------------------------------------------------------------------------------
/rst/gallery/regionprops.rst:
--------------------------------------------------------------------------------
  1 | ========================
  2 | Labeling and Measurement
  3 | ========================
  4 | 
  5 | Here we're going to label a image and measure some features for each label.
  6 | 
  7 | .. contents:: Contents
  8 |     :local:
  9 |     :depth: 1
 10 | 
 11 | Basics
 12 | ------
 13 | 
 14 | Get the sample image.
 15 | 
 16 | .. code-block:: python
 17 | 
 18 |     import impy as ip
 19 |     img = ip.sample_image("coins")
 20 | 
 21 | There are two methods for image labeling.
 22 | 
 23 | - ``label`` ... labeling image with the input reference.
 24 | - ``label_threshold`` ... labeling image with the binarized image as the reference. It can be 
 25 |   considered as a shortcut of ``img.label(img.threshold())``.
 26 | 
 27 | Both method returns a ``Label`` array, a subclass of ``MetaArray``.
 28 | 
 29 | Simple labeling
 30 | ---------------
 31 | 
 32 | .. code-block:: python
 33 | 
 34 |     img.label_threshold()
 35 | 
 36 | .. code-block::
 37 | 
 38 |     Label of
 39 |           name      : coins
 40 |          shape      : 303(y), 384(x)
 41 |          dtype      : uint8
 42 |          source     : None
 43 |          scale      : ScaleView(y=1.0, x=1.0)
 44 | 
 45 | The ``Label`` is tagged to the image itself.
 46 | 
 47 | .. code-block:: python
 48 | 
 49 |     img.labels
 50 | 
 51 | .. code-block::
 52 | 
 53 |     Label of
 54 |           name      : coins
 55 |          shape      : 303(y), 384(x)
 56 |          dtype      : uint8
 57 |          source     : None
 58 |          scale      : ScaleView(y=1.0, x=1.0)
 59 | 
 60 | Slicing of image covariantly slices the labels at the same time.
 61 | 
 62 | .. code-block:: python
 63 | 
 64 |     img[100:200, 53].labels
 65 | 
 66 | .. code-block::
 67 | 
 68 |     Label of
 69 |           name      : coins
 70 |          shape      : 100(y)
 71 |          dtype      : uint8
 72 |          source     : None
 73 |          scale      : ScaleView(y=1.0)
 74 | 
 75 | Image with label overlay can be visualized by ``imshow`` method or using ``napari`` viewer.
 76 | 
 77 | .. code-block:: python
 78 | 
 79 |     img.imshow(label=True)  # use matplotlib to show images
 80 |     ip.gui.add(img)  # use napari to show images
 81 | 
 82 | Measurement
 83 | -----------
 84 | 
 85 | After labeling, ``regionprops`` method is useful for image measurement. This method runs 
 86 | ``skimage.measure.regionprops`` inside.
 87 | 
 88 | .. code-block:: python
 89 | 
 90 |     props = img.regionprops(properties=("mean_intensity", "area", "major_axis_length"))
 91 |     props
 92 | 
 93 | .. code-block::
 94 |     
 95 |     DataDict[PropArray] with 3 components:
 96 |     'mean_intensity' => PropArray of
 97 |           name      : coins-prop
 98 |          shape      : 98(N)
 99 |          dtype      : float32
100 |          source     : None
101 |      property name  : mean_intensity
102 |     ,
103 |     'area' => PropArray of
104 |           name      : coins-prop
105 |          shape      : 98(N)
106 |          dtype      : float32
107 |          source     : None
108 |      property name  : area
109 |     ,
110 |     'major_axis_length' => PropArray of
111 |           name      : coins-prop
112 |          shape      : 98(N)
113 |          dtype      : float32
114 |          source     : None
115 |      property name  : major_axis_length
116 | 
117 | The returned ``DataDict`` object is a ``dict``-like object. Its value is assured to be the same
118 | type so that you can easily apply a same method to all the components (see :doc:`../tutorial.rst`).
119 | Since "mean_intensity", "area" and "major_axis_length" are chosen for measurement, ``props`` has
120 | keys "mean_intensity", "area" and "major_axis_length".
121 | 
122 | Here, ``props`` is a ``DataDict`` of ``PropArray``. ``PropArray`` is a subclass of ``MetaArray``
123 | that is specialized in storing properties.
124 | 
125 | All the properties can be summerized as follows.
126 | 
127 | .. code-block:: python
128 | 
129 |     # since PropArray has method `mean`, this line will apply `mean` to all the components.
130 |     props.mean()
131 | 
132 | .. code-block::
133 | 
134 |     DataDict[float32] with 3 components:
135 |     'mean_intensity' => 122.47181,
136 |     'area' => 465.52042,
137 |     'major_axis_length' => 15.488672
138 | 
139 | .. code-block:: python
140 | 
141 |     # PropArray has a visualization method `hist`.
142 |     props.hist()
143 | 
144 | Conditional Labeling
145 | --------------------
146 | 
147 | Simple labeling based on thresholding always yields in insufficient results. 
148 | 
149 | The ``filt`` argument can filter labels based on properties of image and labels.
150 | Basic usage is following. Filter function must take at least two argument, image itself and
151 | newly created label region.
152 | 
153 | .. code-block:: python
154 | 
155 |     def filt(img, lbl):
156 |         """Return true if label passes a criterion you set."""
157 |     
158 |     img.label_threshold(filt=filt)
159 | 
160 | You can use additional arguments with names same as those properties supported in
161 | ``regionprops``. For instance, you can label regions only satisfies proper area and length 
162 | using following filter function.
163 | 
164 | .. code-block:: python
165 | 
166 |     def filt(img, lbl, area, major_axis_length):
167 |         proper_size = 10 < area < 60**2
168 |         proper_shape = 20 < major_axis_length < 120
169 |         return proper_size and proper_shape
170 |     
171 |     img.label_threshold(filt=filt)
172 | 


--------------------------------------------------------------------------------
/rst/index.rst:
--------------------------------------------------------------------------------
  1 | .. impy documentation master file, created by
  2 |    sphinx-quickstart on Mon Jul 26 15:21:04 2021.
  3 |    You can adapt this file completely to your liking, but it should at least
  4 |    contain the root `toctree` directive.
  5 | 
  6 | impy
  7 | ====
  8 | 
  9 | ``impy`` is an all-in-one image analysis library, equipped with parallel processing, GPU support, GUI based tools and 
 10 | so on.
 11 | 
 12 | `Source code <https://github.com/hanjinliu/impy>`_
 13 | 
 14 | 
 15 | Highlights
 16 | ----------
 17 | 
 18 | - Automatic parallel batch processing using ``dask``.
 19 | 
 20 | - You don't have to care about ``numpy`` / ``scipy`` on CPU, or ``cupy`` on GPU. Same code works for both processors.
 21 | 
 22 | - n-D viewing, cropping, image annotation using ``napari``.
 23 | 
 24 | - Easily integrate your custom functions with ``@ip.bind``.
 25 | 
 26 | - Command line usage.
 27 | 
 28 | 
 29 | Installation
 30 | ------------
 31 | 
 32 | .. code-block:: shell
 33 | 
 34 |    pip install git+https://github.com/hanjinliu/impy
 35 | 
 36 | 
 37 | or
 38 | 
 39 | .. code-block:: shell
 40 | 
 41 |    git clone https://github.com/hanjinliu/impy
 42 | 
 43 | Contents
 44 | --------
 45 | 
 46 | .. toctree::
 47 |    :maxdepth: 1
 48 | 
 49 |    tutorial
 50 |    tutorial_axes
 51 |    tutorial_cmd
 52 |    ./gallery/index
 53 |    api
 54 |    
 55 | 
 56 | Major Classes
 57 | -------------
 58 | 
 59 | Array
 60 | ^^^^^
 61 | 
 62 | .. blockdiag::
 63 |    
 64 |    blockdiag {
 65 |       orientation = portrait
 66 |       
 67 |       numpy.ndarray -> MetaArray -> LabeledArray -> ImgArray;
 68 |       AxesMixin -> MetaArray;
 69 |       MetaArray -> PropArray;
 70 |       MetaArray -> Label;
 71 |       LabeledArray -> PhaseArray;
 72 |       
 73 |       PropArray [color = pink];
 74 |       Label [color = pink];
 75 |       ImgArray [color = pink];
 76 |       PhaseArray [color = pink];
 77 |    }
 78 | 
 79 | - ``AxesMixin``: An abstract class that axes, scale and shape are defined.
 80 | 
 81 | - ``PropArray``: Array object with properties stored in it. Always made from an ``ImgArray``.
 82 | 
 83 | - ``Label``: Array object of image labels that is attached to ``ImgArray``.
 84 | 
 85 | - ``ImgArray``: Array object with many image processing functions.
 86 | 
 87 | - ``PhaseArray``: Array object with periodic values and specific processing functions.
 88 | 
 89 | 
 90 | Array-like
 91 | ^^^^^^^^^^
 92 | 
 93 | .. blockdiag::
 94 |    
 95 |    blockdiag {
 96 |       orientation = portrait
 97 | 
 98 |       AxesMixin -> LazyImgArray -> BigImgArray;
 99 |       LazyImgArray [color = pink];
100 |       BigImgArray [color = pink];
101 |    }
102 | 
103 | - ``LazyImgArray``: Array-like object with image processing functions like ``ImgArray``, but evaluated lazily.
104 | - ``BigImgArray``: Subclass of ``LazyImgArray``, but images will be processed for every method call.
105 | 
106 | 
107 | Data Frame  
108 | ^^^^^^^^^^
109 | 
110 | .. blockdiag::
111 |    
112 |    blockdiag {
113 |       orientation = portrait
114 | 
115 |       pandas.DataFrame -> AxesFrame -> MarkerFrame;
116 |       AxesFrame -> TrackFrame;
117 |       AxesFrame -> PathFrame;
118 |       
119 |       MarkerFrame [color = pink];
120 |       TrackFrame [color = pink];
121 |       PathFrame [color = pink];
122 |    }
123 | 
124 | - ``AxesFrame``: DataFrame with similar properties as ``AxesMixin``.
125 | 
126 | - ``MarkerFrame``: ``AxesFrame`` for markers, such as coordinates.
127 | 
128 | - ``TrackFrame``: ``AxesFrame`` for tracks.
129 | 
130 | - ``PathFrame``: ``AxesFrame`` for paths.
131 | 
132 | 
133 | 
134 | Indices and tables
135 | ==================
136 | 
137 | * :ref:`genindex`
138 | * :ref:`modindex`
139 | * :ref:`search`
140 | 


--------------------------------------------------------------------------------
/rst/make.bat:
--------------------------------------------------------------------------------
 1 | @ECHO OFF
 2 | 
 3 | pushd %~dp0
 4 | 
 5 | REM Command file for Sphinx documentation
 6 | 
 7 | if "%SPHINXBUILD%" == "" (
 8 | 	set SPHINXBUILD=sphinx-build
 9 | )
10 | set SOURCEDIR=.
11 | set BUILDDIR=_build
12 | 
13 | if "%1" == "" goto help
14 | 
15 | %SPHINXBUILD% >NUL 2>NUL
16 | if errorlevel 9009 (
17 | 	echo.
18 | 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
19 | 	echo.installed, then set the SPHINXBUILD environment variable to point
20 | 	echo.to the full path of the 'sphinx-build' executable. Alternatively you
21 | 	echo.may add the Sphinx directory to PATH.
22 | 	echo.
23 | 	echo.If you don't have Sphinx installed, grab it from
24 | 	echo.http://sphinx-doc.org/
25 | 	exit /b 1
26 | )
27 | 
28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
29 | goto end
30 | 
31 | :help
32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
33 | 
34 | :end
35 | popd
36 | 


--------------------------------------------------------------------------------
/rst/tutorial_cmd.rst:
--------------------------------------------------------------------------------
 1 | Command Line Usage
 2 | ==================
 3 | 
 4 | Image analysis usually relies on different softwares in different platform.
 5 | The traditional command line based interface is still useful in this purpose.
 6 | 
 7 | ``impy`` also supports command line usage.
 8 | 
 9 | Basic Usage
10 | -----------
11 | 
12 | The most basic one is:
13 | 
14 | .. code-block:: shell
15 | 
16 |     impy --input path/to/image.tif --output path/to/output.tif --method gaussian_filter --sigma 2
17 | 
18 | or ``--input`` and ``--output`` can be omitted like:
19 | 
20 | .. code-block:: shell
21 | 
22 |     impy path/to/image.tif path/to/output.tif --method gaussian_filter --sigma 2
23 | 
24 | You have to specify ``--method`` or ``-m`` to let ``impy`` know what method you'd like to run.
25 | Method names should match those in ``ImgArray``. The last ``--sigma`` option is characteristic 
26 | to ``gaussian_filter`` so that it may differ with other method.
27 | Those commands above are equivalent to following Python code.
28 | 
29 | .. code-block:: python
30 | 
31 |     import impy as ip
32 |     img = ip.imread("path/to/image.tif")
33 |     out = img.gaussian_filter(sigma=2)
34 |     out.imsave("path/to/output.tif")
35 | 
36 | 
37 | Advanced Usage
38 | --------------
39 | 
40 | Sometimes you may want to apply multiple filters in tandem to an image. Classically it was
41 | usually done by saving intermediate files, but here we should take advantage of IPython.
42 | 
43 | Instead of parsing ``--output``, you can use ``-i`` flag to launch IPython interpreter with
44 | namespace ``ip`` and ``img``. ``ip`` is an alias of ``impy`` as usual, and ``img`` is an
45 | ``ImgArray`` object that is created by reading the ``--input`` argument.
46 | 
47 | .. code-block:: shell
48 | 
49 |     impy path/to/image.tif -i
50 | 
51 | .. code-block:: python
52 | 
53 |     >>> arr = ip.random.random((100, 120))  # "ip" is already available
54 |     >>> out = img + arr  # img = ip.imread("path/to/image.tif")
55 |     >>> out.imsave("path/to/output.tif")
56 | 
57 | Another option is ``-n``, which send namespace including input image to ``napari`` viewer
58 | and console.
59 | 
60 | .. code-block:: shell
61 | 
62 |     impy path/to/image.tif -n
63 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/tests/__init__.py


--------------------------------------------------------------------------------
/tests/_test_images/RoiSet.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/tests/_test_images/RoiSet.zip


--------------------------------------------------------------------------------
/tests/_test_images/image_tzcyx.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hanjinliu/impy/3c5897440c7bf7d2a86fd78fe95983b05ec1b0bf/tests/_test_images/image_tzcyx.tif


--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | def pytest_addoption(parser):
 4 |     parser.addoption("--resource", default="numpy")
 5 | 
 6 | @pytest.fixture(scope="session")
 7 | def resource(request):
 8 |     import impy as ip
 9 |     res = request.config.getoption('--resource')
10 |     return res
11 | 


--------------------------------------------------------------------------------
/tests/test_astype.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import numpy as np
 3 | import impy as ip
 4 | 
 5 | @pytest.mark.parametrize(
 6 |     "dtype",
 7 |     [
 8 |         np.uint8, np.int8, np.uint16, np.int16, np.uint32, np.int32,
 9 |         np.float16, np.float32, np.float64,
10 |     ]
11 | )
12 | def test_as_img_type(dtype):
13 |     img = ip.zeros((4, 5, 6), dtype=dtype, axes="zyx")
14 |     assert img.dtype == dtype
15 |     img = ip.zeros((4, 5, 6), dtype=np.uint8, axes="zyx")
16 |     assert img.as_img_type(dtype).dtype == dtype
17 | 


--------------------------------------------------------------------------------
/tests/test_big.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | from pathlib import Path
 3 | import numpy as np
 4 | from numpy.testing import assert_allclose
 5 | import pytest
 6 | import operator
 7 | 
 8 | filters = ["median_filter", "mean_filter", "erosion", "dilation", "opening", "closing",
 9 |            "kalman_filter", "gaussian_filter"]
10 | 
11 | 
12 | def test_functions_and_slicing(resource):
13 |     with ip.SetConst(RESOURCE=resource):
14 |         path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
15 |         img = ip.big_imread(path, chunks=(4, 5, 2, 32, 32))
16 |         sl = "y=20:40;x=30:50;c=0;z=2,4"
17 |         assert_allclose(img[sl].compute(), img.compute()[sl])
18 |         assert_allclose(
19 |             img.affine(translation=[1, 50, 50]).compute(),
20 |             img.compute().affine(translation=[1, 50, 50])
21 |         )
22 | 
23 | @pytest.mark.parametrize("fn", filters)
24 | def test_filters(fn, resource):
25 |     with ip.SetConst(RESOURCE=resource):
26 |         path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
27 |         img = ip.big_imread(path, chunks=(4, 5, 2, 32, 32))
28 |         
29 |         assert_allclose(
30 |             getattr(img, fn)().compute(),
31 |             getattr(img.compute(), fn)()
32 |         )
33 |         
34 | 
35 | def test_numpy_function():
36 |     from dask.array.core import Array as DaskArray
37 |     img = ip.asbigarray(ip.random.random_uint16((2, 3, 4)))
38 |     assert img.axes == "tyx"
39 |     assert isinstance(np.mean(img).compute(), float)
40 |     proj = np.mean(img, axis="y")
41 |     assert isinstance(proj.value, DaskArray)
42 |     assert proj.axes == "tx"
43 |     assert isinstance(proj.compute(), ip.ImgArray)
44 | 
45 | 
46 | @pytest.mark.parametrize("opname", ["gt", "lt", "ge", "le", "eq", "ne"])
47 | def test_operator(opname):
48 |     op = getattr(operator, opname)
49 |     rng = ip.random.default_rng(0)
50 |     img1 = ip.asbigarray(rng.random_uint16((2, 3, 4)))
51 |     img2 = ip.asbigarray(rng.random_uint16((2, 3, 4)))
52 |     assert_allclose(
53 |         op(img1, img2).compute(),
54 |         op(img1.compute(), img2.compute()),
55 |     )
56 | 


--------------------------------------------------------------------------------
/tests/test_bind.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | from pathlib import Path
 3 | import numpy as np
 4 | 
 5 | def test_bind_unbind():
 6 |     path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
 7 |     img = ip.imread(path)
 8 |     
 9 |     @ip.bind(indtype=np.float32, outdtype=np.float32)
10 |     def normalize(img: np.ndarray):
11 |         min_, max_ = img.min(), img.max()
12 |         return (img - min_)/(max_ - min_)
13 | 
14 |     out = img.normalize()
15 |     assert out.dtype == np.float32
16 | 
17 |     def normalize(img: np.ndarray):
18 |         min_, max_ = img.min(), img.max()
19 |         return (img - min_)/(max_ - min_)
20 |     
21 |     with ip.bind(normalize, indtype=np.float32, outdtype=np.float32):
22 |         out = img.normalize()
23 |         assert out.dtype == np.float32
24 |     assert not hasattr(img, "normalize")
25 | 
26 |     ip.bind(np.mean, "calc_mean", outdtype=np.float32, kind="property")
27 |     img.calc_mean()
28 | 
29 |     assert ip.bind.bound == set(["calc_mean"])


--------------------------------------------------------------------------------
/tests/test_broadcasting.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import impy as ip
 3 | from impy.axes import ImageAxesError
 4 | import pytest
 5 | 
 6 | def test_operators():
 7 |     arr = ip.random.normal(size=(3, 4, 10), axes="tyx")
 8 |     fit = ip.asarray(np.arange(1, 41).reshape(4, 10), axes="yx")
 9 |     fit0 = np.stack([fit]*3, axis="t")
10 |     assert np.all(arr/fit == arr/fit0)
11 |     assert np.all(arr[fit>12] == arr[fit0>12])
12 | 
13 | def test_mismatch():
14 |     img0 = ip.zeros((3, 3), axes="yx")
15 |     img1 = ip.zeros((3, 3), axes="zy")
16 |     
17 |     with pytest.raises(ImageAxesError):
18 |         img0 + img1
19 | 
20 | def test_broadcasting_arrays():
21 |     out = ip.broadcast_arrays(
22 |         ip.zeros((3, 4, 5), axes="zyx"),
23 |         ip.zeros((4, 5), axes="yx"),
24 |         ip.zeros((3, 4), axes="zy"),
25 |     )
26 |     for i in range(3):
27 |         assert out[i].shape == (3, 4, 5)
28 |         assert out[i].axes == ["z", "y", "x"]
29 |     
30 |     out = ip.broadcast_arrays(
31 |         ip.zeros((3,), axes="z"),
32 |         ip.zeros((4,), axes="y"),
33 |         ip.zeros((5,), axes="x"),
34 |     )
35 |     for i in range(3):
36 |         assert out[i].shape == (3, 4, 5)
37 |         assert out[i].axes == ["z", "y", "x"]
38 |     
39 |     out = ip.broadcast_arrays(
40 |         ip.zeros((3, 3), axes="dz"),
41 |         ip.zeros((3, 4), axes="dy"),
42 |         ip.zeros((3, 5), axes="dx"),
43 |     )
44 |     for i in range(3):
45 |         assert out[i].shape == (3, 3, 4, 5)
46 |         assert out[i].axes == ["d", "z", "y", "x"]
47 | 
48 | def test_error():
49 |     with pytest.raises(Exception):
50 |         ip.broadcast_arrays(
51 |             ip.zeros((3, 4, 5), axes="zyx"),
52 |             ip.zeros((4, 6), axes="yx"),
53 |         )
54 | 
55 |     with pytest.raises(Exception):
56 |         ip.broadcast_arrays(
57 |             ip.zeros((3, 4, 5), axes="zyx"),
58 |             ip.zeros((5, 5), axes="yt"),
59 |         )
60 |         
61 |     with pytest.raises(Exception):
62 |         ip.broadcast_arrays(
63 |             ip.zeros((3, 4, 5), axes="zyx"),
64 |             ip.zeros((4, 5), axes="zy"),
65 |         )


--------------------------------------------------------------------------------
/tests/test_collection.py:
--------------------------------------------------------------------------------
 1 | from impy import DataList, DataDict
 2 | import pytest
 3 | 
 4 | def test_empty_list():
 5 |     l0 = DataList()
 6 |     l0 + [1]
 7 |     DataList([1]) + l0
 8 |     l0.append(1)
 9 |     
10 | def test_list():
11 |     l = DataList(["a", "b"])
12 |     
13 |     l1 = l + DataList(["c"])
14 |     with pytest.raises(TypeError):
15 |         l1.append(2)
16 |     
17 |     assert l1[[0, 2]]._list == ["a", "c"]
18 |     assert l.endswith("a")._list == [True, False]
19 |     del l[0]
20 | 
21 | def test_empty_dict():
22 |     d0 = DataDict()
23 |     d0["a"] = 0
24 | 
25 | def test_dict():
26 |     d = DataDict(a="A", b="B")
27 |     
28 |     with pytest.raises(TypeError):
29 |         d[3] = 4
30 |     
31 |     out = d.endswith("A")
32 |     assert out["a"] == True
33 |     assert out["b"] == False


--------------------------------------------------------------------------------
/tests/test_crop.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | 
 3 | def test_remove_edges():
 4 |     img = ip.zeros((50, 50, 50), axes="zyx")
 5 |     img0 = img.remove_edges(3)
 6 |     assert img0.shape == (50, 44, 44)
 7 |     assert img0.axes == ["z", "y", "x"]
 8 |     
 9 |     img0 = img.remove_edges(3, dims="zyx")
10 |     assert img0.shape == (44, 44, 44)
11 |     assert img0.axes == ["z", "y", "x"]
12 |     
13 |     img0 = img.remove_edges([3, 5, 0], dims="zyx")
14 |     assert img0.shape == (44, 40, 50)
15 |     assert img0.axes == ["z", "y", "x"]
16 |     
17 | 
18 | def test_crop_center_even():
19 |     img = ip.zeros((60, 60, 60), axes="zyx")
20 |     img[15:45, 15:45, 15:45] = 1
21 |     img0 = img.crop_center(0.5, dims="yx")
22 |     assert img0.shape == (60, 30, 30)
23 |     assert img0.axes == ["z", "y", "x"]
24 |     
25 |     img0 = img.crop_center(0.5, dims="zyx")
26 |     assert img0.shape == (30, 30, 30)
27 |     assert img0.axes == ["z", "y", "x"]
28 |     assert img0.mean() == 1.0
29 | 
30 |     img0 = img.crop_center([0.5, 1, 0.2], dims="zyx")
31 |     assert img0.shape == (30, 60, 12)
32 |     assert img0.axes == ["z", "y", "x"]
33 | 
34 | def test_crop_center_odd():
35 |     img = ip.zeros((17, 17), axes="yx")
36 |     img[4:13, 4:13] = 1
37 |     img0 = img.crop_center(0.5)
38 |     assert img0.shape == (9, 9)
39 |     assert img0.mean() == 1


--------------------------------------------------------------------------------
/tests/test_fft.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | from pathlib import Path
 3 | import numpy as np
 4 | from impy.array_api import xp
 5 | from numpy.testing import assert_allclose
 6 | 
 7 | path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
 8 | img_orig = ip.imread(path)
 9 | 
10 | def test_precision(resource):
11 |     with ip.SetConst(RESOURCE=resource):
12 |         img = img_orig["c=1;t=0"].as_float()
13 |         
14 |         assert_allclose(img.fft(shift=False),
15 |                         xp.asnumpy(xp.fft.fftn(xp.asarray(img.value)))
16 |                         )
17 |         
18 |         assert_allclose(img.fft(shift=False, double_precision=True),
19 |                         xp.asnumpy(xp.fft.fftn(xp.asarray(img.value.astype(np.float64))).astype(np.complex64))
20 |                         )
21 |         
22 |         assert_allclose(img.fft().ifft(), img, rtol=1e-6)
23 |         assert_allclose(img.fft(double_precision=True).ifft(double_precision=True), img)
24 |         
25 |         assert_allclose(np.fft.fftshift(img.local_dft()).ifft(), img, rtol=1e-6)
26 |         assert_allclose(np.fft.fftshift(img.local_dft(double_precision=True)).ifft(double_precision=True), img)
27 | 
28 | def test_iteration(resource):
29 |     if resource == "cupy":
30 |         rtol = 1e-4
31 |         atol = 1e-4
32 |     else:
33 |         rtol = 1e-6
34 |         atol = 1e-6
35 |     with ip.SetConst(RESOURCE=resource):
36 |         img = img_orig["c=1;t=0"].as_float()
37 |         
38 |         ft0 = img.fft(dims="zx")
39 |         fmt = ip.slicer.get_formatter("y")
40 |         ft1 = np.stack([img[fmt[i]].fft(dims="zx") for i in range(img.shape.y)], axis="y")
41 |         assert_allclose(ft0, ft1, rtol=rtol, atol=atol)
42 |         
43 |         ft0 = img.ifft(dims="zx")
44 |         ft1 = np.stack([img[fmt[i]].ifft(dims="zx") for i in range(img.shape.y)], axis="y")
45 |         assert_allclose(ft0, ft1, rtol=rtol, atol=atol)
46 | 
47 | def test_local_dft_works(resource):
48 |     with ip.SetConst(RESOURCE=resource):
49 |         img = img_orig["c=1"].as_float()
50 |         img.local_dft(key="y=2:5", upsample_factor=8)
51 |         img.local_dft(key="y=-2:3", upsample_factor=8)
52 |         img.local_dft(key="y=-2:3;x=2:4", upsample_factor=8)
53 |         img.local_dft(key=ip.slicer.y[:2].x[:3], upsample_factor=8)
54 | 


--------------------------------------------------------------------------------
/tests/test_gaussfit.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import impy as ip
 3 | from impy.utils.gauss import GaussianBackground
 4 | 
 5 | rng = np.random.default_rng(12345)
 6 | mu = np.array([30.5, 26.3])
 7 | sg = np.array([22.1, 19.6])
 8 | a = 1.5
 9 | b = 0.2
10 | gs = GaussianBackground([mu, sg, a, b])
11 | img = ip.asarray(gs.generate((56, 56))) + rng.normal(scale=0.1, size=(56, 56))
12 | 
13 | def test_2d():
14 |     fit = img.gaussfit(scale=0.5)
15 |     assert "GaussianParameters" in fit.metadata
16 |     assert "GaussianParameters" not in img.metadata
17 |     assert np.all(np.abs(mu - fit.metadata["GaussianParameters"]["mu"]) < 1)
18 |     assert np.all(np.abs(sg - fit.metadata["GaussianParameters"]["sigma"]) < 1)
19 |     assert abs(a - fit.metadata["GaussianParameters"]["A"]) < 0.2
20 |     assert abs(b - fit.metadata["GaussianParameters"]["B"]) < 0.04
21 |     
22 | def test_3d():
23 |     img0 = ip.asarray(gs.generate((56, 56))) + rng.normal(scale=0.1, size=(56, 56))
24 |     a0 = [(1.2, 0), (1.0, 0.6), (2.2, 0.3)]
25 |     img: ip.ImgArray = np.stack([a*img0 + b for a, b in a0], axis="c")
26 |     fit = img.gaussfit(scale=0.5)
27 |     assert fit.axes == img.axes
28 |     
29 |     assert "GaussianParameters" in fit.metadata
30 |     params = fit.metadata["GaussianParameters"]
31 |     for c in range(3):
32 |         _a, _b = a0[c]
33 |         assert np.all(np.abs(mu - params[c]["mu"]) < 1)
34 |         assert np.all(np.abs(sg - params[c]["sigma"]) < 1)
35 |         assert abs(_a * a - params[c]["A"]) < 0.2 * _a
36 |         assert abs(_a * b + _b - params[c]["B"]) < 0.1 * _a
37 | 
38 | def test_2d_with_mask():
39 |     mask = np.zeros_like(img.value, dtype=bool)
40 |     mask[4:6, 5:7] = True
41 |     mask[18:20, 8:10] = True
42 |     mask[22:23, 23:24] = True
43 |     mask[15:17, 16:18] = True
44 |     img0 = img.copy()
45 |     img0[mask] = 20.0  # outliers
46 |     
47 |     fit_no_mask = img0.gaussfit(scale=1, mask=None)
48 |     fit_with_mask = img0.gaussfit(scale=1, mask=mask)
49 |     param_no_mask = fit_no_mask.metadata["GaussianParameters"]
50 |     param_with_mask = fit_with_mask.metadata["GaussianParameters"]
51 |     assert np.all(np.abs(mu - fit_with_mask.metadata["GaussianParameters"]["mu"]) < 1)
52 |     
53 |     assert abs(param_no_mask["A"] - a) > 0.25
54 |     assert abs(param_no_mask["B"] - b) > 0.1
55 |     
56 |     assert abs(param_with_mask["A"] - a) < 0.2 
57 |     assert abs(param_with_mask["B"] - b) < 0.05
58 |     


--------------------------------------------------------------------------------
/tests/test_io.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | import tempfile
 3 | from pathlib import Path
 4 | from numpy.testing import assert_allclose, assert_equal
 5 | import pytest
 6 | 
 7 | @pytest.mark.parametrize(
 8 |     ["ext", "unit"], 
 9 |     [(".tif", "μm"), (".mrc", "nm"), (".zarr", "μm"), (".npz", "µm")]
10 | )
11 | def test_imread_and_imsave(ext, unit):
12 |     img = ip.random.random_uint16((4, 100, 100), axes="zyx")
13 |     img.set_scale(z=0.4, xy=0.3)
14 |     img.scale_unit = unit
15 |     with tempfile.TemporaryDirectory() as path:
16 |         file_path = Path(path) / f"test{ext}"
17 |         img.imsave(file_path)
18 |         img0 = ip.imread(file_path)
19 |         assert img.dtype == img0.dtype == "uint16"
20 |         assert img.axes == img0.axes
21 |         assert_allclose(img.scale, img0.scale)
22 |         assert img.scale_unit == img0.scale_unit
23 |         assert_equal(img, img0)
24 | 
25 | 
26 | path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
27 | img_orig = ip.imread(path)
28 | 
29 | @pytest.mark.parametrize(
30 |     "key",
31 |     ["y=:10;x=:10",
32 |      "t=1;y=2,4,6",
33 |      ip.slicer.y[10:].x[12:],
34 |      ip.slicer.c[1].x[12:],
35 |      ])
36 | def test_imread_key(key):
37 |     img0 = ip.imread(path, key=key)
38 |     img1 = img_orig[key]
39 |     assert_equal(img0, img1)
40 |     assert img1.scale_unit == "μm"
41 |     assert img0.scale_unit == "μm"
42 | 
43 | def test_imsave_safety():
44 |     img = ip.random.random_uint16((4, 100, 100), axes="zyx")
45 |     img.set_scale(z=0.4, xy=0.3)
46 |     img.scale_unit = "μm"
47 |     assert img.source is None
48 |     with tempfile.TemporaryDirectory() as path:
49 |         img.imsave(Path(path) / "test.tif")
50 |         with pytest.raises(Exception):
51 |             img.imsave("test.tif")
52 |         img.source = Path(path) / "dummy.tif"
53 |         img.imsave("test.tif")
54 |         img.imsave("test")
55 |         with pytest.raises(Exception):
56 |             img.imsave("test.tif", overwrite=False)
57 | 


--------------------------------------------------------------------------------
/tests/test_labels.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from numpy.testing import assert_equal
  3 | import impy as ip
  4 | import pytest
  5 | from impy.axes import ImageAxesError
  6 | 
  7 | def test_inherit_label():
  8 |     img = ip.zeros((10, 10, 10), axes="zyx")
  9 |     label = np.zeros((10, 10, 10), dtype=np.uint8)
 10 |     label[:4] = 1
 11 |     label[4:6] = 2
 12 |     img.labels = label
 13 |     
 14 |     out = img.gaussian_filter()
 15 |     assert_equal(out.labels, img.labels)
 16 |     assert out.labels is not img.labels
 17 |     assert out.labels.axes == "zyx"
 18 |     
 19 |     out = img + 1
 20 |     assert_equal(out.labels, img.labels)
 21 |     assert out.labels is not img.labels
 22 |     assert out.labels.axes == "zyx"
 23 |     
 24 |     out = img.proj("z")
 25 |     assert out.labels is None
 26 |     
 27 | def test_lower_dim():
 28 |     img = ip.zeros((10, 10, 10), axes="zyx")
 29 |     label = np.zeros((10, 10), dtype=np.uint8)
 30 |     label[:4] = 1
 31 |     label[4:6] = 2
 32 |     img.labels = label
 33 |     
 34 |     assert img.labels.axes == "yx"
 35 |     
 36 |     out = img.gaussian_filter()
 37 |     assert_equal(out.labels, img.labels)
 38 |     assert out.labels is not img.labels
 39 |     assert out.labels.axes == "yx"
 40 |     
 41 |     out = img + 1
 42 |     assert_equal(out.labels, img.labels)
 43 |     assert out.labels is not img.labels
 44 |     assert out.labels.axes == "yx"
 45 |     
 46 |     out = img.proj("z")
 47 |     assert_equal(out.labels, img.labels)
 48 |     assert out.labels is not img.labels
 49 |     assert out.labels.axes == "yx"
 50 |     
 51 |     out = img.proj("y")
 52 |     assert out.labels is None
 53 | 
 54 | def test_getitem():
 55 |     img = ip.zeros((10, 10, 10), axes="zyx")
 56 |     label = np.zeros((10, 10, 10), dtype=np.uint8)
 57 |     label[:4] = 1
 58 |     label[4:6] = 2
 59 |     label[:, 3:8] = 3
 60 |     img.labels = label
 61 |     
 62 |     out = img[2:7, 1:-1, 3:6]
 63 |     assert out.labels.axes == out.axes == "zyx"
 64 |     assert out.labels.shape == out.shape
 65 |     assert_equal(out.labels, img.labels[2:7, 1:-1, 3:6])
 66 |     
 67 |     
 68 |     out = img[2:7, [0, 2, 4, 6, 9]]
 69 |     assert out.labels.axes == out.axes == "zyx"
 70 |     assert out.labels.shape == out.shape
 71 |     assert_equal(out.labels, img.labels[2:7, [0, 2, 4, 6, 9]])
 72 | 
 73 |     
 74 | def test_getitem_lower_dim():
 75 |     img = ip.zeros((10, 10, 10), axes="zyx")
 76 |     label = np.zeros((10, 10), dtype=np.uint8)
 77 |     label[:4] = 1
 78 |     label[4:6] = 2
 79 |     label[:, 3:8] = 3
 80 |     img.labels = label
 81 |     
 82 |     out = img[2:7, 1:-1, 3:6]
 83 |     assert out.labels.axes == "yx"
 84 |     assert out.labels.shape == out.shape[1:]
 85 |     assert_equal(out.labels, img.labels[1:-1, 3:6])
 86 |     
 87 |     
 88 |     out = img[2:7, [0, 2, 4, 6, 9]]
 89 |     assert out.labels.axes == "yx"
 90 |     assert out.labels.shape == out.shape[1:]
 91 |     assert_equal(out.labels, img.labels[[0, 2, 4, 6, 9]])
 92 | 
 93 | 
 94 | def test_error():
 95 |     img = ip.zeros((10, 10, 10), axes="zyx")
 96 |     with pytest.raises(ValueError):
 97 |         img.labels = img
 98 |     with pytest.raises(TypeError):
 99 |         img.labels = np.zeros((10, 10, 10), dtype=np.float32)
100 |     with pytest.raises(ValueError):
101 |         img.labels = np.zeros((10, 10, 8), dtype=np.uint8)
102 |     with pytest.raises(ValueError):
103 |         img.labels = np.zeros((10, 8), dtype=np.uint8)
104 |     with pytest.raises(ImageAxesError):
105 |         img.labels = np.zeros((2, 10, 10, 10), dtype=np.uint8)
106 | 
107 | def test_changing_axes():
108 |     img = ip.zeros((10, 10, 10), axes="zyx")
109 |     labels = np.zeros((10, 10, 10), dtype=np.uint8)
110 |     img.labels = labels
111 |     
112 |     assert img.labels.axes == ["z", "y", "x"]
113 |     img.axes = "tyx"
114 |     assert img.labels.axes == ["t", "y", "x"]
115 |     
116 |     img = ip.zeros((10, 10, 10), axes="zyx")
117 |     labels = np.zeros((10, 10), dtype=np.uint8)
118 |     img.labels = labels
119 |     
120 |     assert img.labels.axes == ["y", "x"]
121 |     img.axes = "tyx"
122 |     assert img.labels.axes == ["y", "x"]
123 |     img.axes = "zYx"
124 |     assert img.labels.axes == ["Y", "x"]
125 | 


--------------------------------------------------------------------------------
/tests/test_lazy.py:
--------------------------------------------------------------------------------
 1 | import tempfile
 2 | import impy as ip
 3 | from pathlib import Path
 4 | import numpy as np
 5 | from numpy.testing import assert_allclose
 6 | import pytest
 7 | import operator
 8 | 
 9 | filters = [
10 |     "median_filter",
11 |     "mean_filter",
12 |     "erosion",
13 |     "dilation",
14 |     "opening",
15 |     "closing",
16 |     "kalman_filter",
17 |     "gaussian_filter",
18 |     "edge_filter",
19 | ]
20 | 
21 | 
22 | def test_functions_and_slicing(resource):
23 |     with ip.SetConst(RESOURCE=resource):
24 |         path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
25 |         img = ip.lazy.imread(path, chunks=(4, 5, 2, 32, 32))
26 |         sl = "y=20:40;x=30:50;c=0;z=2,4"
27 |         assert_allclose(img[sl].compute(), img.compute()[sl])
28 |         assert_allclose(
29 |             img.affine(translation=[1, 50, 50]).compute(),
30 |             img.compute().affine(translation=[1, 50, 50])
31 |         )
32 | 
33 | @pytest.mark.parametrize("fn", filters)
34 | def test_filters(fn, resource):
35 |     if resource == "cupy" and fn in ("edge_filter",):
36 |         # not supported on GPU
37 |         return
38 |     with ip.SetConst(RESOURCE=resource):
39 |         path = Path(__file__).parent / "_test_images" / "image_tzcyx.tif"
40 |         img = ip.lazy.imread(path, chunks=(4, 5, 2, 32, 32))
41 | 
42 |         assert_allclose(
43 |             getattr(img, fn)().compute(),
44 |             getattr(img.compute(), fn)()
45 |         )
46 | 
47 | 
48 | def test_numpy_function():
49 |     from dask.array.core import Array as DaskArray
50 |     rng = ip.lazy.random.default_rng(0)
51 |     img = rng.random_uint16((2, 3, 4))
52 |     assert img.axes == "tyx"
53 |     assert isinstance(np.mean(img).compute(), float)
54 |     proj = np.mean(img, axis="y")
55 |     assert isinstance(proj.value, DaskArray)
56 |     assert proj.axes == "tx"
57 |     assert isinstance(proj.compute(), ip.ImgArray)
58 | 
59 | 
60 | @pytest.mark.parametrize("opname", ["gt", "lt", "ge", "le", "eq", "ne"])
61 | def test_operator(opname):
62 |     op = getattr(operator, opname)
63 |     rng = ip.lazy.random.default_rng(0)
64 |     img1 = rng.random_uint16((2, 3, 4))
65 |     img2 = rng.random_uint16((2, 3, 4))
66 |     assert_allclose(
67 |         op(img1, img2).compute(),
68 |         op(img1.compute(), img2.compute()),
69 |     )
70 | 
71 | @pytest.mark.parametrize("ext", [".tif", ".mrc"])
72 | @pytest.mark.parametrize("dtype", [np.uint16, np.float32])
73 | def test_lazy_imsave(ext: str, dtype):
74 |     rng = ip.random.default_rng(1234)
75 |     if dtype == np.uint16:
76 |         img = rng.random_uint16((4, 8, 80), axes="zyx")
77 |     else:
78 |         img = rng.random((4, 8, 80), axes="zyx")
79 |     assert img.dtype == dtype
80 |     img_lazy = ip.lazy.asarray(img, chunks=(1, 2, 80))
81 |     img_lazy.scale_unit = "nm"
82 |     assert img_lazy.dtype == dtype
83 |     with tempfile.TemporaryDirectory() as path:
84 |         fp = Path(path) / f"test{ext}"
85 |         img_lazy.imsave(fp)
86 |         img0 = ip.imread(fp)
87 |         assert img_lazy.shape == img0.shape
88 |         assert img_lazy.dtype == img0.dtype
89 |         assert img_lazy.axes == img0.axes
90 |         assert_allclose(img, img0)
91 | 


--------------------------------------------------------------------------------
/tests/test_map_coords.py:
--------------------------------------------------------------------------------
 1 | from numpy.testing import assert_allclose
 2 | import impy as ip
 3 | from scipy import ndimage as ndi
 4 | 
 5 | def test_map_coordinates(resource):
 6 |     with ip.SetConst(RESOURCE=resource):
 7 |         img = ip.arange(120, dtype=ip.float32).reshape(10, 12, axes="yx")
 8 |         
 9 |         coords = ip.random.random((2, 4, 4), axes="duv") * 10
10 |         ans = ndi.map_coordinates(img.value, coords.value)
11 |         
12 |         out = img.map_coordinates(coords)
13 |         assert out.axes == ["u", "v"]
14 |         assert_allclose(ans, out, rtol=1e-6, atol=1e-6)
15 |         
16 |         out = img.map_coordinates(coords.value)
17 |         assert out.axes == ["y", "x"]
18 |         assert_allclose(ans, out, rtol=1e-6, atol=1e-6)
19 |         
20 |         coords = ip.random.random((2, 7), axes="dv") * 10
21 |         ans = ndi.map_coordinates(img.value, coords.value)
22 |         
23 |         out = img.map_coordinates(coords)
24 |         assert out.axes == ["v"]
25 |         assert_allclose(ans, out, rtol=1e-6, atol=1e-6)
26 |         
27 |         out = img.map_coordinates(coords.value)
28 |         assert out.axes == ["#"]
29 |         assert_allclose(ans, out, rtol=1e-6, atol=1e-6)
30 | 
31 | def test_multi_map_coordinates(resource):
32 |     with ip.SetConst(RESOURCE=resource):
33 |         img = ip.arange(120 * 21, dtype=ip.float32).reshape(3, 7, 10, 12, axes="ctyx")
34 |         
35 |         coords = ip.random.random((2, 4, 5), axes="duv") * 10
36 |         
37 |         out = img.map_coordinates(coords)
38 |         assert out.axes == ["c", "t", "u", "v"]
39 |         assert out.shape == (3, 7, 4, 5)
40 |         
41 |         out = img.map_coordinates(coords.value)
42 |         assert out.axes == ["c", "t", "y", "x"]
43 |         assert out.shape == (3, 7, 4, 5)
44 |         
45 |         coords = ip.random.random((2, 6), axes="dv") * 10
46 |         out = img.map_coordinates(coords)
47 |         assert out.axes == ["c", "t", "v"]
48 |         assert out.shape == (3, 7, 6)
49 |         
50 |         out = img.map_coordinates(coords.value)
51 |         assert out.axes == ["c", "t", "#"]
52 |         assert out.shape == (3, 7, 6)
53 | 


--------------------------------------------------------------------------------
/tests/test_numpy_functions.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | import impy as ip
  3 | from impy.axes import ImageAxesError
  4 | import numpy as np
  5 | from numpy.testing import assert_allclose
  6 | 
  7 | def test_numpy_function():
  8 |     np.random.seed(1234)
  9 |     img = ip.random.random_uint16((10, 100, 100))
 10 |     assert img.axes == "tyx"
 11 |     assert isinstance(np.mean(img), float)
 12 |     proj = np.mean(img, axis="y")
 13 |     assert_allclose(proj, np.mean(img.value, axis=1))
 14 |     np.random.seed()
 15 | 
 16 | def test_squeeze():
 17 |     img0 = ip.zeros((3, 3, 1), axes="zyx")
 18 |     out = np.squeeze(img0)
 19 |     assert out.axes == ["z", "y"]
 20 |     assert out.shape == (3, 3)
 21 |     
 22 | def test_stack():
 23 |     img0 = ip.zeros((3, 3))
 24 |     img1 = ip.zeros((3, 3))
 25 |     
 26 |     out = np.stack([img0, img1], axis=0)
 27 |     assert out.axes == ["#", "y", "x"]
 28 |     assert out.shape == (2, 3, 3)
 29 |     
 30 |     out = np.stack([img0, img1], axis=1)
 31 |     assert out.axes == ["y", "#", "x"]
 32 |     assert out.shape == (3, 2, 3)
 33 |     
 34 |     out = np.stack([img0, img1], axis="p")
 35 |     assert out.axes == ["p", "y", "x"]
 36 |     assert out.shape == (2, 3, 3)
 37 |     
 38 |     with pytest.raises(ImageAxesError):
 39 |         np.stack([img0, img1], axis="y")
 40 | 
 41 | def test_concatenate():
 42 |     img0 = ip.zeros((3, 2))
 43 |     img1 = ip.zeros((3, 2))
 44 |     
 45 |     out = np.concatenate([img0, img1], axis=0)
 46 |     assert out.axes == ["y", "x"]
 47 |     assert out.shape == (6, 2)
 48 |     
 49 |     out = np.concatenate([img0, img1], axis=1)
 50 |     assert out.axes == ["y", "x"]
 51 |     assert out.shape == (3, 4)
 52 |     
 53 |     out = np.concatenate([img0, img1], axis="y")
 54 |     assert out.axes == ["y", "x"]
 55 |     assert out.shape == (6, 2)
 56 |     
 57 |     with pytest.raises(ImageAxesError):
 58 |         np.concatenate([img0, img1], axis="z")
 59 |     
 60 | def test_expand_dims():
 61 |     img0 = ip.zeros((3, 3))
 62 |     out = np.expand_dims(img0, axis=0)
 63 |     assert out.axes == ["#", "y", "x"]
 64 |     assert out.shape == (1, 3, 3)
 65 |     
 66 |     out = np.expand_dims(img0, axis=1)
 67 |     assert out.axes == ["y", "#", "x"]
 68 |     assert out.shape == (3, 1, 3)
 69 |     
 70 |     out = np.expand_dims(img0, axis="z")
 71 |     assert out.axes == ["z", "y", "x"]
 72 |     assert out.shape == (1, 3, 3)
 73 |     
 74 |     with pytest.raises(ImageAxesError):
 75 |         np.expand_dims(img0, axis="y")
 76 | 
 77 | def test_transpose():
 78 |     img0 = ip.zeros((2, 3, 4), axes="zyx")
 79 |     
 80 |     out = np.transpose(img0, "zxy")
 81 |     assert out.axes == ["z", "x", "y"]
 82 |     assert out.shape == (2, 4, 3)
 83 |     
 84 |     out = np.transpose(img0, "yxz")
 85 |     assert out.axes == ["y", "x", "z"]
 86 |     assert out.shape == (3, 4, 2)
 87 |     
 88 |     out = np.transpose(img0)
 89 |     assert out.axes == ["x", "y", "z"]
 90 |     assert out.shape == (4, 3, 2)
 91 | 
 92 | def test_broadcast_to():
 93 |     img0 = ip.zeros((2, 3), axes="yx")
 94 |     
 95 |     out = np.broadcast_to(img0, (4, 2, 3))
 96 |     assert out.axes == ["#", "y", "x"]
 97 |     assert out.shape == (4, 2, 3)
 98 |     
 99 |     out = np.broadcast_to(img0, (6, 4, 2, 3))
100 |     assert out.axes == ["#", "#", "y", "x"]
101 |     assert out.shape == (6, 4, 2, 3)
102 | 
103 | def test_moveaxis():
104 |     img0 = ip.zeros((4, 3, 2, 5), axes="tzyx")
105 |     
106 |     out = np.moveaxis(img0, 0, 2)
107 |     assert out.axes == ["z", "y", "t", "x"]
108 |     assert out.shape == np.moveaxis(img0.value, 0, 2).shape
109 |     
110 |     out = np.moveaxis(img0, [0, 2], [1, 3])
111 |     assert out.axes == ["z", "t", "x", "y"]
112 |     assert out.shape == np.moveaxis(img0.value, [0, 2], [1, 3]).shape
113 | 
114 | def test_swapaxes():
115 |     img0 = ip.zeros((4, 3, 2, 5), axes="tzyx")
116 |     
117 |     out = np.swapaxes(img0, 0, 2)
118 |     assert out.axes == ["y", "z", "t", "x"]
119 |     assert out.shape == np.swapaxes(img0.value, 0, 2).shape
120 |     
121 |     out = np.swapaxes(img0, "x", "z")
122 |     assert out.axes == ["t", "x", "y", "z"]
123 |     assert out.shape == np.swapaxes(img0.value, 3, 1).shape
124 | 
125 | def test_indices():
126 |     inds = ip.indices((4, 5, 6), axes="zyx")
127 |     inds_np = np.indices((4, 5, 6))
128 |     
129 |     assert_allclose(inds.z , inds_np[0])
130 |     assert_allclose(inds.y , inds_np[1])
131 |     assert_allclose(inds.x , inds_np[2])
132 | 
133 | @pytest.mark.parametrize("shape", [(3, 4, 5), (5,)])
134 | def test_arg(shape):
135 |     img = ip.zeros(shape)
136 |     np.argmax(img, axis=0)
137 |     np.argmax(img, axis="x")
138 |     np.argmin(img, axis=0)
139 |     np.argmin(img, axis="x")
140 | 


--------------------------------------------------------------------------------
/tests/test_props_functions.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import impy as ip
 3 | 
 4 | def test_pointprops():
 5 |     img2d = ip.zeros((20, 20), axes="yx")
 6 |     img = ip.zeros((10, 20, 20), axes="tyx")
 7 |     assert img2d.pointprops([3, 3]) == 0.
 8 |     assert img.pointprops([3, 3]).shape == (10,)
 9 |     out = img.pointprops([[3, 3], [6, 3], [3, 6], [6, 6]])
10 |     assert out.shape == (4, 10)  # N, t
11 | 
12 | def test_reslice():
13 |     img = ip.zeros((4, 10, 12, 14), axes="tzyx")
14 |     coords = np.array([[2, 2], [4, 4], [6, 4]])  # length = 4.84 => 5 sample points
15 |     out = img.reslice(coords)
16 |     assert out.shape == (4, 10, 5)
17 |     assert out.axes == ["t", "z", "s"]
18 |     
19 |     coords = np.array([[3, 2, 2], [3, 4, 4], [3, 6, 4]])
20 |     out = img.reslice(coords)
21 |     assert out.shape == (4, 5)
22 |     assert out.axes == ["t", "s"]
23 | 
24 | def test_pathprops():
25 |     img = ip.zeros((4, 10, 12, 14), axes="tzyx")
26 |     
27 |     # 2-D
28 |     coords = [
29 |         np.array([[2, 2], [3.4, 4.2], [7.5, 8.7]]),
30 |         np.array([[1, 2.1], [5.4, 3.2]]),
31 |     ]
32 |     
33 |     out = img.pathprops(coords, [np.mean, np.std])
34 |     assert len(out) == 2
35 |     out["mean"].shape == (2, 4, 10)
36 |     out["std"].shape == (2, 4, 10)
37 |     
38 |     # 3-D
39 |     coords = [
40 |         np.array([[1.2, 2, 2], [1.4, 3.4, 4.2], [5.5, 7.5, 8.7]]),
41 |         np.array([[3.4, 1, 2.1], [3, 5.4, 3.2]]),
42 |     ]
43 |     
44 |     out = img.pathprops(coords, [np.mean, np.std])
45 |     assert len(out) == 2
46 |     out["mean"].shape == (2, 10)
47 |     out["std"].shape == (2, 10)
48 | 
49 | def test_regionprops():
50 |     # prepare labeled image
51 |     zz, yy, xx = np.indices((10, 12, 14), dtype=np.float32)
52 |     imgs = []
53 |     for u in range(4):
54 |         imgs.append(np.sin(zz/3 + u)*np.cos(yy/2+u)*np.sin(xx/1.3 + u*2))
55 |     img = ip.asarray(np.stack(imgs, axis=0), axes="tzyx")
56 |     
57 |     property_names = ["mean_intensity", "area", "centroid"]
58 |         
59 |     lbl = img[0].threshold().label()
60 |     img.labels = lbl
61 |     props = img.regionprops(properties=property_names)
62 |     
63 |     for name in property_names:
64 |         assert props[name].axes == ["N", "t"]
65 | 
66 |     lbl = img[0, 4].threshold().label()
67 |     img.labels = lbl
68 |     props = img.regionprops(properties=property_names)
69 |     
70 |     for name in property_names:
71 |         assert props[name].axes == ["N", "t", "z"]
72 | 


--------------------------------------------------------------------------------
/tests/test_radon.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import pytest
 3 | import impy as ip
 4 | 
 5 | def test_radon_2d(resource):
 6 |     ndegs = 61
 7 |     degrees = np.linspace(-160, 160, ndegs)
 8 |     with ip.SetConst(RESOURCE=resource):
 9 |         img = ip.gaussian_kernel((15, 18), sigma=[2, 3])
10 |         assert img.dtype == np.float32
11 |         sino = img.radon(degrees)
12 |         assert sino.axes == ["degree", "x"]
13 |         assert sino.shape == (ndegs, 18)
14 |         assert sino.dtype == np.float32
15 |         img2 = sino.iradon(degrees, height=15)
16 |         assert img2.axes == ["y", "x"]
17 |         assert img2.shape == (15, 18)
18 |         assert ip.zncc(img, img2, dims="yx") > 0.85
19 |         assert img2.dtype == np.float32
20 | 
21 | def test_radon_3d(resource):
22 |     ndegs = 61
23 |     degrees = np.linspace(-160, 160, ndegs)
24 |     with ip.SetConst(RESOURCE=resource):
25 |         img = ip.gaussian_kernel((15, 18, 21), sigma=[2, 3, 3.5], axes="zyx")
26 |         img.set_scale(zyx=0.22)
27 |         assert img.dtype == np.float32
28 |         with pytest.raises(ValueError):
29 |             img.radon(degrees)
30 |         sino = img.radon(degrees, central_axis="y")
31 |         assert sino.axes == ["degree", "y", "x"]
32 |         assert sino.shape == (ndegs, 18, 21)
33 |         assert sino.dtype == np.float32
34 | 
35 |         img2 = sino.iradon(degrees, central_axis="y", height=15)
36 |         assert img2.axes == ["z", "y", "x"]
37 |         assert img2.shape == (15, 18, 21)
38 |         assert ip.zncc(img, img2, dims="zyx") > 0.85
39 |         assert img2.dtype == np.float32
40 |         assert img2.scale.z == 0.22
41 | 


--------------------------------------------------------------------------------
/tests/test_random.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from numpy.testing import assert_allclose
 3 | import impy as ip
 4 | import pytest
 5 | 
 6 | sizes = [None, 10, (10,), (10, 10), (6, 10, 10)]
 7 | 
 8 | rng = ip.random.default_rng(120)
 9 | np_rng = np.random.default_rng(120)
10 | 
11 | @pytest.mark.parametrize("size", sizes)
12 | @pytest.mark.parametrize("dtype", [np.float32, np.float64])
13 | def test_random(size, dtype):
14 |     assert_allclose(rng.random(size, dtype=dtype), np_rng.random(size, dtype=dtype))
15 | 
16 | @pytest.mark.parametrize("size", sizes)
17 | def test_normal(size):
18 |     assert_allclose(rng.normal(size=size), np_rng.normal(size=size))
19 | 
20 | def test_like_param():
21 |     img = ip.zeros((3, 4, 5), axes="zyx")
22 |     out = rng.normal(like=img)
23 |     assert out.axes == ["z", "y", "x"]
24 |     assert out.shape == (3, 4, 5)
25 | 


--------------------------------------------------------------------------------
/tests/test_roi.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | from impy.roi import LineRoi
 3 | from pathlib import Path
 4 | import tempfile
 5 | 
 6 | def test_roi_slicing():
 7 |     roi = LineRoi(
 8 |         [[3, 4],
 9 |          [6, 10]],
10 |         "tyx", 
11 |         multi_dims=[2]
12 |     )
13 |     assert roi._slice_by((2, slice(1, 6, 1), slice(3, 8, 1))) == LineRoi([[2, 1], [5, 7]], "yx", multi_dims=None)
14 |     assert roi._slice_by((2, slice(1, 6, 2), slice(3, 12, -1))) == LineRoi([[1, 8], [2.5, 2]], "yx", multi_dims=None)
15 |     assert roi._slice_by((1, slice(1, 6, 2), slice(3, 12, -1))) is None
16 |     assert roi._slice_by((2, 1, slice(3, 12, -1))) is None
17 |     assert roi._slice_by((2, slice(1, 6, 2), 1)) is None
18 | 
19 | def test_multi_dims():
20 |     roi = LineRoi(
21 |         [[3, 4],
22 |          [6, 10]],
23 |         "tzcyx", 
24 |         multi_dims=[2, 14, 1]
25 |     )
26 |     assert roi._slice_by((2, 14, 1, slice(1, 6, 1), slice(3, 8, 1))) is not None
27 |     assert roi._slice_by((2, 14, slice(0, 3, 1), slice(1, 6, 1), slice(3, 8, 1))) is not None
28 |     assert roi._slice_by((2, slice(0, 3, 1), 1, slice(1, 6, 1), slice(3, 8, 1))) is not None
29 |     assert roi._slice_by((slice(0, 3, 1), 14, 1, slice(1, 6, 1), slice(3, 8, 1))) is not None
30 |     assert roi._slice_by((slice(0, 3, 1), 14, slice(0, 3, 1), slice(1, 6, 1), slice(3, 8, 1))) is not None
31 |     assert roi._slice_by((slice(0, 3, 1), slice(0, 3, 1), 1, slice(1, 6, 1), slice(3, 8, 1))) is not None
32 |     assert roi._slice_by((1, 14, 1, slice(1, 6, 1), slice(3, 8, 1))) is None
33 |     assert roi._slice_by((2, 13, 1, slice(1, 6, 1), slice(3, 8, 1))) is None
34 |     assert roi._slice_by((2, 14, 3, slice(1, 6, 1), slice(3, 8, 1))) is None
35 |     assert roi._slice_by((1, 14, slice(0, 3, 1), slice(1, 6, 1), slice(3, 8, 1))) is None
36 |     assert roi._slice_by((1, slice(0, 3, 1), 1, slice(1, 6, 1), slice(3, 8, 1))) is None
37 |     assert roi._slice_by((slice(0, 3, 1), 1, 1, slice(1, 6, 1), slice(3, 8, 1))) is None
38 |     assert roi._slice_by((slice(0, 3, 1), 1, slice(0, 3, 1), slice(1, 6, 1), slice(3, 8, 1))) is None
39 |     assert roi._slice_by((slice(0, 3, 1), slice(0, 3, 1), 3, slice(1, 6, 1), slice(3, 8, 1))) is None
40 |         
41 | 
42 | def test_drop():
43 |     roi = LineRoi(
44 |         [[3, 4],
45 |          [6, 10]],
46 |         "tzcyx", 
47 |         multi_dims=[2, 14, 1]
48 |     )
49 |     
50 |     assert roi.drop(0) == LineRoi([[3, 4], [6, 10]], "zcyx", multi_dims=[14, 1])
51 |     assert roi.drop(2) == LineRoi([[3, 4], [6, 10]], "tzyx", multi_dims=[2, 14])
52 |     
53 | 
54 | def test_covariance():
55 |     img = ip.zeros((5, 10, 10), axes="tyx")
56 |     img.rois = [
57 |         LineRoi([[1, 1], [2, 3]], axes="yx"),
58 |         LineRoi([[4, 6], [2, 3]], axes="tyx", multi_dims=1),
59 |     ]
60 |     
61 |     img0 = img[1]
62 |     assert len(img0.rois) == 2
63 |     assert img0.rois[0] == LineRoi([[1, 1], [2, 3]], axes="yx")
64 |     assert img0.rois[1] == LineRoi([[4, 6], [2, 3]], axes="yx")
65 |     
66 |     img0 = img[1, 2:8]
67 |     assert len(img0.rois) == 2
68 |     assert img0.rois[0] == LineRoi([[-1, 1], [0, 3]], axes="yx")
69 |     assert img0.rois[1] == LineRoi([[2, 6], [0, 3]], axes="yx")
70 |     
71 |     img0 = img[0, 3:8]
72 |     assert len(img0.rois) == 1
73 |     assert img0.rois[0] == LineRoi([[-2, 1], [-1, 3]], axes="yx")
74 | 
75 | # TODO: need fix in the next version
76 | # def test_consistency():
77 | #     path = Path(__file__).parent / "_test_images" / "RoiSet.zip"
78 | #     rois = ip.roiread(path)
79 |     
80 | #     assert len(rois) == 6
81 |     
82 | #     with tempfile.TemporaryDirectory() as tmpdir:
83 | #         _path = Path(tmpdir) / "RoiSet-test.zip"
84 | #         rois.tofile(_path)
85 | #         rois2 = ip.roiread(_path)
86 | #         assert len(rois2) == 6
87 | #         for roi1, roi2 in zip(rois, rois2):
88 | #             assert roi1 == roi2
89 | 


--------------------------------------------------------------------------------
/tests/test_shape.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | 
 3 | def test_shapes():
 4 |     shape = (4, 5, 6)
 5 |     img = ip.zeros(shape, axes="zyx")
 6 |     assert img.shape == shape
 7 |     assert img.shape.z == img.shape["z"] == shape[0]
 8 |     assert img.shape.y == img.shape["y"] == shape[1]
 9 |     assert img.shape.x == img.shape["x"] == shape[2]
10 |     
11 |     shape = (9, 3, 12)
12 |     img = ip.zeros(shape, axes="zyx")
13 |     assert img.shape == shape
14 |     assert img.shape.z == img.shape["z"] == shape[0]
15 |     assert img.shape.y == img.shape["y"] == shape[1]
16 |     assert img.shape.x == img.shape["x"] == shape[2]
17 | 


--------------------------------------------------------------------------------
/tests/test_slicing.py:
--------------------------------------------------------------------------------
 1 | import impy as ip
 2 | import numpy as np
 3 | from numpy.testing import assert_equal
 4 | import pytest
 5 | 
 6 | def test_str_slicing():
 7 |     img = ip.random.normal(size=(10, 2, 30, 40), axes = "tcyx")
 8 |     assert_equal(img["t=4;c=0"], img.value[4, 0])
 9 |     assert_equal(img["c=0;x=10:30"], img.value[:, 0, :, 10:30])
10 |     assert_equal(img["y=3,6,20,26;x=7,3,4,13"], img.value[:, :, [3, 6, 20, 26], [7, 3, 4, 13]])
11 |     assert_equal(img["t=::-1;x=2:-1:3"], img.value[::-1, :, :, 2:-1:3])
12 | 
13 | def test_slicer_slicing():
14 |     img = ip.random.normal(size=(10, 2, 30, 40), axes = "tcyx")
15 |     assert_equal(img[ip.slicer.t[4].c[0]], img.value[4,0])
16 |     assert_equal(img[ip.slicer.c[0].x[10:30]], img.value[:,0,:,10:30])
17 |     assert_equal(img[ip.slicer.y[3, 6, 20, 26].x[7, 3, 4, 13]], img.value[:,:,[3,6,20,26],[7,3,4,13]])
18 |     assert_equal(img[ip.slicer.t[::-1].x[2:-1:3]], img.value[::-1,:,:,2:-1:3])
19 | 
20 | def test_sel_slicing():
21 |     img = ip.random.normal(size=(10, 2, 30, 40), axes = "tcyx")
22 |     img.set_axis_label(
23 |         t=[f"t={i}" for i in range(10)],
24 |         c=["blue", "red"],
25 |         y=[str(i) for i in range(30)],
26 |         x=[str(i) for i in range(40)],
27 |     )
28 |     assert_equal(img.sel(t="t=4", c="blue"), img.value[4,0])
29 |     assert_equal(img.sel(c="blue", x=slice("10", "30")), img.value[:,0,:,10:30])
30 |     assert_equal(img.sel(y=["3", "6", "20", "26"], x=["7", "3", "4", "13"]), img.value[:,:,[3,6,20,26],[7,3,4,13]])
31 |     assert_equal(img.sel(t=slice(None, None, -1), x=slice("2", "39", 3)), img.value[::-1,:,:,2:40:3])
32 | 
33 | def test_eval_slicing():
34 |     img = ip.random.normal(size=(10, 2, 30, 40), axes = "tcyx")
35 |     assert_equal(img["t=N//2;c=N-1"], img.value[5, 1])
36 |     assert_equal(img["c=0;x=ceil(N/2):N"], img.value[:, 0, :, 20:40])
37 |     assert_equal(img["y=ceil(N/10), floor(N/5)"], img.value[:, :, [3, 6], :])
38 | 
39 | def test_formatter():
40 |     img = ip.random.normal(size=(10, 2, 30, 40))
41 |     fmt = ip.slicer.y[4].get_formatter("tx")
42 | 
43 |     with pytest.raises(Exception):
44 |         img[fmt]
45 | 
46 |     # test repr
47 |     repr(ip.slicer)
48 |     repr(fmt)
49 | 
50 |     assert_equal(img[fmt[0, 0]], img["t=0;y=4;x=0"])
51 |     assert_equal(img[fmt[0, 3:6]], img["t=0;y=4;x=3:6"])
52 |     assert_equal(img[fmt[:5][:6]], img["t=:5;y=4;x=:6"])
53 | 
54 |     fmt = ip.slicer.get_formatter("tx")
55 |     with pytest.raises(Exception):
56 |         img[fmt]
57 | 
58 |     # test repr
59 |     repr(ip.slicer)
60 |     repr(fmt)
61 | 
62 |     assert_equal(img[fmt[0, 0]], img["t=0;x=0"])
63 |     assert_equal(img[fmt[0, 3:6]], img["t=0;x=3:6"])
64 |     assert_equal(img[fmt[:5][:6]], img["t=:5;x=:6"])
65 | 
66 | def test_scale():
67 |     img = ip.zeros((10, 10))
68 |     img.set_scale(xy=0.2)
69 |     assert img[0].axes[-1].scale == img.axes[-1].scale
70 |     assert img[0, 2:4].axes[-1].scale == img.axes[-1].scale
71 |     assert img[0, ::-1].axes[-1].scale == img.axes[-1].scale
72 |     assert img[0, ::2].axes[-1].scale == img.axes[-1].scale * 2
73 |     assert img[0, ::-3].axes[-1].scale == img.axes[-1].scale * 3
74 |     assert img.binning(2).axes[-1].scale == img.axes[-1].scale * 2
75 |     assert img.zoom(1/4).axes[-1].scale == img.axes[-1].scale * 4
76 | 
77 | def test_dataframe_slicing():
78 |     from impy.frame import AxesFrame
79 | 
80 |     df = AxesFrame({
81 |         "t": [0, 0, 1, 1, 2],
82 |         "y": [8, 9, 7, 5, 3],
83 |         "x": [2, 3, 5 ,7 ,10],
84 |     })
85 | 
86 |     assert df.col_axes == ["t", "y", "x"]
87 |     assert (df["t=0"]["t"] == 0).all()
88 |     assert (df["t=1"]["t"] == 1).all()
89 |     assert_equal(df["t=0"].values, np.array([[0, 8, 2], [0, 9, 3]]))
90 |     assert_equal(df["t=1"].values, np.array([[1, 7, 5], [1, 5, 7]]))
91 |     assert_equal(df["t=0:2"].values, np.array([[0, 8, 2], [0, 9, 3], [1, 7, 5], [1, 5, 7]]))
92 | 


--------------------------------------------------------------------------------