diff --git a/packages/image-io/python/itkwasm-image-io-wasi/tests/test_read_write_image.py b/packages/image-io/python/itkwasm-image-io-wasi/tests/test_read_write_image.py index 2b50a991c..96d8dd653 100644 --- a/packages/image-io/python/itkwasm-image-io-wasi/tests/test_read_write_image.py +++ b/packages/image-io/python/itkwasm-image-io-wasi/tests/test_read_write_image.py @@ -1,5 +1,3 @@ -from pathlib import Path - from itkwasm import PixelTypes, IntTypes from itkwasm_image_io_wasi import read_image, imread, write_image, imwrite diff --git a/packages/image-io/python/itkwasm-image-io/README.md b/packages/image-io/python/itkwasm-image-io/README.md new file mode 100644 index 000000000..5836e7c60 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/README.md @@ -0,0 +1,11 @@ +# itkwasm-image-io + +[![PyPI version](https://badge.fury.io/py/itkwasm-image-io.svg)](https://badge.fury.io/py/itkwasm-image-io) + +Input and output for scientific and medical image file formats. + +## Installation + +```sh +pip install itkwasm-image-io +``` diff --git a/packages/image-io/python/itkwasm-image-io/docs/Makefile b/packages/image-io/python/itkwasm-image-io/docs/Makefile new file mode 100644 index 000000000..d4bb2cbb9 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/packages/image-io/python/itkwasm-image-io/docs/_static/favicon.png b/packages/image-io/python/itkwasm-image-io/docs/_static/favicon.png new file mode 100644 index 000000000..bd1e535c6 Binary files /dev/null and b/packages/image-io/python/itkwasm-image-io/docs/_static/favicon.png differ diff --git a/packages/image-io/python/itkwasm-image-io/docs/_static/logo.svg b/packages/image-io/python/itkwasm-image-io/docs/_static/logo.svg new file mode 100644 index 000000000..669a445ed --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/_static/logo.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/docs/conf.py b/packages/image-io/python/itkwasm-image-io/docs/conf.py new file mode 100644 index 000000000..2244708cc --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/conf.py @@ -0,0 +1,56 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +from datetime import date + +project = 'itkwasm-image-io' +copyright = f'{date.today().year}, NumFOCUS' +author = 'Insight Software Consortium' + +extensions = [ + 'sphinx.ext.autosummary', + 'autodoc2', + 'myst_parser', + 'sphinx.ext.intersphinx', + 'sphinx_copybutton', + 'sphinxext.opengraph', + 'sphinx_design', +] + +myst_enable_extensions = ["colon_fence", "fieldlist"] + +templates_path = ['_templates'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +autodoc2_packages = [ + { + "path": "../itkwasm_image_io", + "exclude_files": ["_version.py"], + }, +] +autodoc2_render_plugin = "myst" + +intersphinx_mapping = { + "python": ("https://docs.python.org/3/", None), + "numpy": ("https://numpy.org/doc/stable", None), + "itkwasm": ("https://itkwasm.readthedocs.io/en/latest/", None), +} + +html_theme = 'furo' +html_static_path = ['_static'] +html_logo = "_static/logo.svg" +html_favicon = "_static/favicon.png" +html_title = f"{project}" + +# Furo options +html_theme_options = { + "top_of_page_button": "edit", + "source_repository": "https://github.com/InsightSoftwareConsortium/itk-wasm", + "source_branch": "main", + "source_directory": "docs", +} \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/docs/index.md b/packages/image-io/python/itkwasm-image-io/docs/index.md new file mode 100644 index 000000000..844a01e3d --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/index.md @@ -0,0 +1,35 @@ +itkwasm-image-io +======= + +> Input and output for scientific and medical image file formats. + +[![itkwasm-image-io version](https://badge.fury.io/py/itkwasm_image_io.svg)](https://pypi.org/project/itkwasm_image_io/) + +## Installation + +::::{tab-set} + +:::{tab-item} System +```shell +pip install itkwasm-image-io +``` +::: + +:::{tab-item} Browser +In Pyodide, e.g. the [Pyodide REPL](https://pyodide.org/en/stable/console.html) or [JupyterLite](https://jupyterlite.readthedocs.io/en/latest/try/lab), + +```python +import micropip +await micropip.install('itkwasm-image-io') +::: + +:::: + +```{toctree} +:hidden: +:maxdepth: 3 +:caption: 📖 Reference + +apidocs/index.rst +itkwasm docs +``` \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/docs/make.bat b/packages/image-io/python/itkwasm-image-io/docs/make.bat new file mode 100644 index 000000000..32bb24529 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/packages/image-io/python/itkwasm-image-io/docs/requirements.txt b/packages/image-io/python/itkwasm-image-io/docs/requirements.txt new file mode 100644 index 000000000..0c8041793 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/docs/requirements.txt @@ -0,0 +1,8 @@ +astroid<3 +sphinx +furo +sphinx-autodoc2 +myst-parser +sphinx-copybutton +sphinxext-opengraph +sphinx-design diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/__init__.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/__init__.py new file mode 100644 index 000000000..3f2b7bc42 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/__init__.py @@ -0,0 +1,91 @@ +"""itkwasm-image-io: Input and output for scientific and medical image file formats.""" + +from .read_image import read_image, imread +from .write_image import write_image, imwrite + +from .bio_rad_read_image_async import bio_rad_read_image_async +from .bio_rad_read_image import bio_rad_read_image +from .bio_rad_write_image_async import bio_rad_write_image_async +from .bio_rad_write_image import bio_rad_write_image +from .bmp_read_image_async import bmp_read_image_async +from .bmp_read_image import bmp_read_image +from .bmp_write_image_async import bmp_write_image_async +from .bmp_write_image import bmp_write_image +from .fdf_read_image_async import fdf_read_image_async +from .fdf_read_image import fdf_read_image +from .fdf_write_image_async import fdf_write_image_async +from .fdf_write_image import fdf_write_image +from .gdcm_read_image_async import gdcm_read_image_async +from .gdcm_read_image import gdcm_read_image +from .gdcm_write_image_async import gdcm_write_image_async +from .gdcm_write_image import gdcm_write_image +from .ge_adw_read_image_async import ge_adw_read_image_async +from .ge_adw_read_image import ge_adw_read_image +from .ge_adw_write_image_async import ge_adw_write_image_async +from .ge_adw_write_image import ge_adw_write_image +from .ge4_read_image_async import ge4_read_image_async +from .ge4_read_image import ge4_read_image +from .ge4_write_image_async import ge4_write_image_async +from .ge4_write_image import ge4_write_image +from .ge5_read_image_async import ge5_read_image_async +from .ge5_read_image import ge5_read_image +from .ge5_write_image_async import ge5_write_image_async +from .ge5_write_image import ge5_write_image +from .gipl_read_image_async import gipl_read_image_async +from .gipl_read_image import gipl_read_image +from .gipl_write_image_async import gipl_write_image_async +from .gipl_write_image import gipl_write_image +from .jpeg_read_image_async import jpeg_read_image_async +from .jpeg_read_image import jpeg_read_image +from .jpeg_write_image_async import jpeg_write_image_async +from .jpeg_write_image import jpeg_write_image +from .lsm_read_image_async import lsm_read_image_async +from .lsm_read_image import lsm_read_image +from .lsm_write_image_async import lsm_write_image_async +from .lsm_write_image import lsm_write_image +from .meta_read_image_async import meta_read_image_async +from .meta_read_image import meta_read_image +from .meta_write_image_async import meta_write_image_async +from .meta_write_image import meta_write_image +from .mgh_read_image_async import mgh_read_image_async +from .mgh_read_image import mgh_read_image +from .mgh_write_image_async import mgh_write_image_async +from .mgh_write_image import mgh_write_image +from .mrc_read_image_async import mrc_read_image_async +from .mrc_read_image import mrc_read_image +from .mrc_write_image_async import mrc_write_image_async +from .mrc_write_image import mrc_write_image +from .nifti_read_image_async import nifti_read_image_async +from .nifti_read_image import nifti_read_image +from .nifti_write_image_async import nifti_write_image_async +from .nifti_write_image import nifti_write_image +from .nrrd_read_image_async import nrrd_read_image_async +from .nrrd_read_image import nrrd_read_image +from .nrrd_write_image_async import nrrd_write_image_async +from .nrrd_write_image import nrrd_write_image +from .png_read_image_async import png_read_image_async +from .png_read_image import png_read_image +from .png_write_image_async import png_write_image_async +from .png_write_image import png_write_image +from .scanco_read_image_async import scanco_read_image_async +from .scanco_read_image import scanco_read_image +from .scanco_write_image_async import scanco_write_image_async +from .scanco_write_image import scanco_write_image +from .tiff_read_image_async import tiff_read_image_async +from .tiff_read_image import tiff_read_image +from .tiff_write_image_async import tiff_write_image_async +from .tiff_write_image import tiff_write_image +from .vtk_read_image_async import vtk_read_image_async +from .vtk_read_image import vtk_read_image +from .vtk_write_image_async import vtk_write_image_async +from .vtk_write_image import vtk_write_image +from .wasm_read_image_async import wasm_read_image_async +from .wasm_read_image import wasm_read_image +from .wasm_write_image_async import wasm_write_image_async +from .wasm_write_image import wasm_write_image +from .wasm_zstd_read_image_async import wasm_zstd_read_image_async +from .wasm_zstd_read_image import wasm_zstd_read_image +from .wasm_zstd_write_image_async import wasm_zstd_write_image_async +from .wasm_zstd_write_image import wasm_zstd_write_image + +from ._version import __version__ diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/_version.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/_version.py new file mode 100644 index 000000000..493f7415d --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/_version.py @@ -0,0 +1 @@ +__version__ = "0.3.0" diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image.py new file mode 100644 index 000000000..5a2a82b23 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def bio_rad_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "bio_rad_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image_async.py new file mode 100644 index 000000000..10f4b95b7 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def bio_rad_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "bio_rad_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image.py new file mode 100644 index 000000000..ade6973bd --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def bio_rad_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "bio_rad_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image_async.py new file mode 100644 index 000000000..128651e0c --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bio_rad_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def bio_rad_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "bio_rad_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image.py new file mode 100644 index 000000000..620b8edc8 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def bmp_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "bmp_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image_async.py new file mode 100644 index 000000000..c74c74734 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def bmp_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "bmp_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image.py new file mode 100644 index 000000000..048ffc60d --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def bmp_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "bmp_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image_async.py new file mode 100644 index 000000000..36a0f687c --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/bmp_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def bmp_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "bmp_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image.py new file mode 100644 index 000000000..9f2d0278a --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def fdf_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "fdf_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image_async.py new file mode 100644 index 000000000..b52090ad5 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def fdf_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "fdf_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image.py new file mode 100644 index 000000000..ef74fbe24 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def fdf_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "fdf_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image_async.py new file mode 100644 index 000000000..7afcc16b6 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/fdf_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def fdf_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "fdf_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image.py new file mode 100644 index 000000000..a87b1f3ec --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def gdcm_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "gdcm_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image_async.py new file mode 100644 index 000000000..b883fafc1 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def gdcm_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "gdcm_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image.py new file mode 100644 index 000000000..1ae274872 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def gdcm_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "gdcm_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image_async.py new file mode 100644 index 000000000..186085509 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gdcm_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def gdcm_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "gdcm_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image.py new file mode 100644 index 000000000..b37a0ce0c --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def ge4_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge4_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image_async.py new file mode 100644 index 000000000..f963d6701 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def ge4_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge4_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image.py new file mode 100644 index 000000000..6ba609f6a --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def ge4_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge4_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image_async.py new file mode 100644 index 000000000..3dd30e148 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge4_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def ge4_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge4_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image.py new file mode 100644 index 000000000..d03e8b67a --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def ge5_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge5_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image_async.py new file mode 100644 index 000000000..32f36b7f9 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def ge5_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge5_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image.py new file mode 100644 index 000000000..f56b94c61 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def ge5_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge5_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image_async.py new file mode 100644 index 000000000..68b764cf5 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge5_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def ge5_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge5_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image.py new file mode 100644 index 000000000..39b0e953d --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def ge_adw_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge_adw_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image_async.py new file mode 100644 index 000000000..6ff784f5c --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def ge_adw_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "ge_adw_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image.py new file mode 100644 index 000000000..66d73c664 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def ge_adw_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge_adw_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image_async.py new file mode 100644 index 000000000..18fbbc4ec --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/ge_adw_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def ge_adw_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "ge_adw_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image.py new file mode 100644 index 000000000..e8e643f19 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def gipl_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "gipl_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image_async.py new file mode 100644 index 000000000..346e0f3b6 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def gipl_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "gipl_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image.py new file mode 100644 index 000000000..ea7f4744e --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def gipl_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "gipl_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image_async.py new file mode 100644 index 000000000..90fc85fe0 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/gipl_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def gipl_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "gipl_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image.py new file mode 100644 index 000000000..fc00f6f9f --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def jpeg_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "jpeg_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image_async.py new file mode 100644 index 000000000..760fd0016 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def jpeg_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "jpeg_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image.py new file mode 100644 index 000000000..5ae0ad9bc --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def jpeg_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "jpeg_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image_async.py new file mode 100644 index 000000000..e4d048944 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/jpeg_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def jpeg_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "jpeg_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image.py new file mode 100644 index 000000000..19ee224cb --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def lsm_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "lsm_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image_async.py new file mode 100644 index 000000000..c40f2b7ea --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def lsm_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "lsm_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image.py new file mode 100644 index 000000000..633cb4ffe --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def lsm_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "lsm_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image_async.py new file mode 100644 index 000000000..3f3db20c7 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/lsm_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def lsm_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "lsm_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image.py new file mode 100644 index 000000000..95acfb0dc --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def meta_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "meta_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image_async.py new file mode 100644 index 000000000..07552b658 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def meta_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "meta_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image.py new file mode 100644 index 000000000..51cddcf30 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def meta_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "meta_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image_async.py new file mode 100644 index 000000000..1a347f336 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/meta_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def meta_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "meta_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image.py new file mode 100644 index 000000000..1edfc58e8 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def mgh_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "mgh_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image_async.py new file mode 100644 index 000000000..3a2ebd679 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def mgh_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "mgh_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image.py new file mode 100644 index 000000000..c4c0cc207 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def mgh_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "mgh_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image_async.py new file mode 100644 index 000000000..707ee8839 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mgh_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def mgh_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "mgh_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image.py new file mode 100644 index 000000000..bdddf2376 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def mrc_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "mrc_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image_async.py new file mode 100644 index 000000000..3da1d6274 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def mrc_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "mrc_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image.py new file mode 100644 index 000000000..37a5ea666 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def mrc_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "mrc_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image_async.py new file mode 100644 index 000000000..eb74db1ce --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/mrc_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def mrc_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "mrc_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image.py new file mode 100644 index 000000000..ebb55f904 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def nifti_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "nifti_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image_async.py new file mode 100644 index 000000000..0133edcd0 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def nifti_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "nifti_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image.py new file mode 100644 index 000000000..78e1b2fee --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def nifti_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "nifti_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image_async.py new file mode 100644 index 000000000..0898298f9 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nifti_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def nifti_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "nifti_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image.py new file mode 100644 index 000000000..d4e1deb13 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def nrrd_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "nrrd_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image_async.py new file mode 100644 index 000000000..8613c00ff --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def nrrd_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "nrrd_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image.py new file mode 100644 index 000000000..97be2ea10 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def nrrd_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "nrrd_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image_async.py new file mode 100644 index 000000000..2ca2027df --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/nrrd_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def nrrd_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "nrrd_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image.py new file mode 100644 index 000000000..1912873b8 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def png_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "png_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image_async.py new file mode 100644 index 000000000..68a767aab --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def png_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "png_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image.py new file mode 100644 index 000000000..9d96e8307 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def png_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "png_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image_async.py new file mode 100644 index 000000000..5ed264c53 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/png_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def png_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "png_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/read_image.py new file mode 100644 index 000000000..85e318ed5 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/read_image.py @@ -0,0 +1,49 @@ +import os +from typing import Optional, Union + +from itkwasm import ( + environment_dispatch, + Image, + PixelTypes, + IntTypes, + FloatTypes, +) + +def read_image( + serialized_image: os.PathLike, + information_only: bool = False, + pixel_type: Optional[PixelTypes]=None, + component_type: Optional[Union[IntTypes, FloatTypes]]=None, +) -> Image: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :param pixel_type: Pixel type to cast to. + :type pixel_Type: Optional[PixelTypes] + + :param component_type: Component type to cast to. + :type component_type: Optional[Union[IntTypes, FloatTypes]] + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "read_image") + output = func(serialized_image, information_only=information_only, pixel_type=pixel_type, component_type=component_type) + return output + +def imread( + serialized_image: os.PathLike, + information_only: bool = False, + pixel_type: Optional[PixelTypes]=None, + component_type: Optional[Union[IntTypes, FloatTypes]]=None, +) -> Image: + return read_image(serialized_image, information_only=information_only, pixel_type=pixel_type, component_type=component_type) + +imread.__doc__ = f"""{read_image.__doc__} + Alias for read_image. + """ \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image.py new file mode 100644 index 000000000..79a606cf9 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def scanco_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "scanco_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image_async.py new file mode 100644 index 000000000..eb6d1e198 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def scanco_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "scanco_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image.py new file mode 100644 index 000000000..1bbe2cea1 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def scanco_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "scanco_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image_async.py new file mode 100644 index 000000000..a4c570c35 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/scanco_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def scanco_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "scanco_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image.py new file mode 100644 index 000000000..e627995f3 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def tiff_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "tiff_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image_async.py new file mode 100644 index 000000000..217e92310 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def tiff_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "tiff_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image.py new file mode 100644 index 000000000..c85fa3ba3 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def tiff_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "tiff_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image_async.py new file mode 100644 index 000000000..c85246777 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/tiff_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def tiff_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "tiff_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image.py new file mode 100644 index 000000000..08ae17ced --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def vtk_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "vtk_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image_async.py new file mode 100644 index 000000000..2517aa805 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def vtk_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "vtk_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image.py new file mode 100644 index 000000000..ada63126c --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def vtk_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "vtk_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image_async.py new file mode 100644 index 000000000..b5044f017 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/vtk_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def vtk_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "vtk_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image.py new file mode 100644 index 000000000..7bd648d64 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def wasm_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "wasm_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image_async.py new file mode 100644 index 000000000..efbd3fd1a --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def wasm_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "wasm_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image.py new file mode 100644 index 000000000..68b73e04d --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def wasm_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "wasm_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image_async.py new file mode 100644 index 000000000..33bcc793a --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def wasm_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "wasm_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image.py new file mode 100644 index 000000000..499f62727 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +def wasm_zstd_read_image( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "wasm_zstd_read_image") + output = func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image_async.py new file mode 100644 index 000000000..ba84a3761 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_read_image_async.py @@ -0,0 +1,32 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + BinaryFile, + Image, +) + +async def wasm_zstd_read_image_async( + serialized_image: os.PathLike, + information_only: bool = False, +) -> Tuple[Any, Image]: + """Read an image file format and convert it to the itk-wasm file format + + :param serialized_image: Input image serialized in the file format + :type serialized_image: os.PathLike + + :param information_only: Only read image metadata -- do not read pixel data. + :type information_only: bool + + :return: Whether the input could be read. If false, the output image is not valid. + :rtype: Any + + :return: Output image + :rtype: Image + """ + func = environment_dispatch("itkwasm_image_io", "wasm_zstd_read_image_async") + output = await func(serialized_image, information_only=information_only) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image.py new file mode 100644 index 000000000..53a0f583e --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +def wasm_zstd_write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "wasm_zstd_write_image") + output = func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image_async.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image_async.py new file mode 100644 index 000000000..28c1e2ad6 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/wasm_zstd_write_image_async.py @@ -0,0 +1,37 @@ +# Generated file. Do not edit. + +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, + BinaryFile, +) + +async def wasm_zstd_write_image_async( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> Tuple[Any]: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + + :return: Whether the input could be written. If false, the output image is not valid. + :rtype: Any + """ + func = environment_dispatch("itkwasm_image_io", "wasm_zstd_write_image_async") + output = await func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return output diff --git a/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/write_image.py b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/write_image.py new file mode 100644 index 000000000..692ec5428 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/itkwasm_image_io/write_image.py @@ -0,0 +1,43 @@ +import os +from typing import Dict, Tuple, Optional, List, Any + +from itkwasm import ( + environment_dispatch, + Image, +) + +def write_image( + image: Image, + serialized_image: str, + information_only: bool = False, + use_compression: bool = False, +) -> None: + """Write an itk-wasm file format converted to an image file format + + :param image: Input image + :type image: Image + + :param serialized_image: Output image serialized in the file format. + :type serialized_image: str + + :param information_only: Only write image metadata -- do not write pixel data. + :type information_only: bool + + :param use_compression: Use compression in the written file + :type use_compression: bool + """ + func = environment_dispatch("itkwasm_image_io", "png_write_image") + func(image, serialized_image, information_only=information_only, use_compression=use_compression) + return + +def imwrite( + image: Image, + serialized_image: os.PathLike, + information_only: bool = False, + use_compression: bool = False, +) -> None: + return write_image(image, serialized_image, information_only=information_only, use_compression=use_compression) + +imwrite.__doc__ = f"""{write_image.__doc__} + Alias for write_image. + """ \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/pyproject.toml b/packages/image-io/python/itkwasm-image-io/pyproject.toml new file mode 100644 index 000000000..eb0eee3ec --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/pyproject.toml @@ -0,0 +1,61 @@ +[build-system] +requires = ["hatchling", "hatch-vcs"] +build-backend = "hatchling.build" + +[project] +name = "itkwasm-image-io" +readme = "README.md" +license = "Apache-2.0" +dynamic = ["version"] +description = "Input and output for scientific and medical image file formats." +classifiers = [ + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python", + "Programming Language :: C++", + "Environment :: WebAssembly", + "Environment :: WebAssembly :: Emscripten", + "Environment :: WebAssembly :: WASI", + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", +] +keywords = [ + "itkwasm", + "webassembly", + "wasi", + "emscripten", +] + +requires-python = ">=3.8" +dependencies = [ + "itkwasm >= 1.0.b131", + "itkwasm-image-io-wasi; sys_platform != \"emscripten\"", + "itkwasm-image-io-emscripten; sys_platform == \"emscripten\"", + +] + +[tool.hatch.version] +path = "itkwasm_image_io/_version.py" + +[tool.hatch.envs.default] +dependencies = [ + "pytest", +] + +[project.urls] +Home = "https://github.com/InsightSoftwareConsortium/itk-wasm" +Source = "https://github.com/InsightSoftwareConsortium/itk-wasm" + +[tool.hatch.envs.default.scripts] +test = "pytest" + + +[tool.hatch.build] +exclude = [ + "/examples", +] diff --git a/packages/image-io/python/itkwasm-image-io/tests/__init__.py b/packages/image-io/python/itkwasm-image-io/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/packages/image-io/python/itkwasm-image-io/tests/common.py b/packages/image-io/python/itkwasm-image-io/tests/common.py new file mode 100644 index 000000000..caf5bf5d9 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/tests/common.py @@ -0,0 +1,6 @@ +from pathlib import Path + +test_input_path = Path(__file__).parent / ".." / ".." / ".." / "test" / "data" / "input" +test_baseline_path = Path(__file__).parent / ".." / ".." / ".." / "test" / "data" / "baseline" +test_output_path = Path(__file__).parent / ".." / ".." / ".." / "test" / "data" / "python" +test_output_path.mkdir(parents=True, exist_ok=True) \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/tests/test_png.py b/packages/image-io/python/itkwasm-image-io/tests/test_png.py new file mode 100644 index 000000000..4500b5608 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/tests/test_png.py @@ -0,0 +1,41 @@ +from itkwasm_image_io import png_read_image, png_write_image + +from .common import test_input_path, test_output_path + +test_input_file_path = test_input_path / "cthead1.png" +test_output_file_path = test_output_path / "png-test-cthead1.png" + +def verify_image(image): + assert image.imageType.dimension == 2 + assert image.imageType.componentType == "uint8" + assert image.imageType.pixelType == "RGB" + assert image.imageType.components == 3 + assert image.origin[0] == 0.0 + assert image.origin[1] == 0.0 + assert image.spacing[0] == 1.0 + assert image.spacing[1] == 1.0 + assert image.direction[0, 0] == 1.0 + assert image.direction[0, 1] == 0.0 + assert image.direction[1, 0] == 0.0 + assert image.direction[1, 1] == 1.0 + assert image.size[0] == 256 + assert image.size[1] == 256 + assert image.data.shape[1] == 256 + assert image.data.shape[0] == 256 + +def test_png_read_image(): + could_read, image = png_read_image(test_input_file_path) + assert could_read + verify_image(image) + +def test_png_write_image(): + could_read, image = png_read_image(test_input_file_path) + assert could_read + + use_compression = False + could_write = png_write_image(image, test_output_file_path, use_compression) + assert could_write + + could_read, image = png_read_image(test_output_file_path) + assert could_read + verify_image(image) \ No newline at end of file diff --git a/packages/image-io/python/itkwasm-image-io/tests/test_read_write_image.py b/packages/image-io/python/itkwasm-image-io/tests/test_read_write_image.py new file mode 100644 index 000000000..f38adfdb7 --- /dev/null +++ b/packages/image-io/python/itkwasm-image-io/tests/test_read_write_image.py @@ -0,0 +1,62 @@ +from pathlib import Path + +from itkwasm import PixelTypes, IntTypes + +from itkwasm_image_io import read_image, imread, write_image, imwrite + +from .common import test_input_path, test_output_path + +test_input_file_path = test_input_path / "cthead1.png" +test_output_file_path = test_output_path / "read-write-cthead1.png" + +def verify_image(image): + assert image.imageType.dimension == 2 + assert image.imageType.componentType == "uint8" + assert image.imageType.pixelType == "RGB" + assert image.imageType.components == 3 + assert image.origin[0] == 0.0 + assert image.origin[1] == 0.0 + assert image.spacing[0] == 1.0 + assert image.spacing[1] == 1.0 + assert image.direction[0, 0] == 1.0 + assert image.direction[0, 1] == 0.0 + assert image.direction[1, 0] == 0.0 + assert image.direction[1, 1] == 1.0 + assert image.size[0] == 256 + assert image.size[1] == 256 + assert image.data.shape[1] == 256 + assert image.data.shape[0] == 256 + +def test_read_image(): + image = read_image(test_input_file_path) + verify_image(image) + +def test_read_image_pixel_type(): + image = read_image(test_input_file_path, pixel_type=PixelTypes.Vector) + assert image.imageType.pixelType == "Vector" + +def test_read_image_component_type(): + image = read_image(test_input_file_path, component_type=IntTypes.UInt16) + assert image.imageType.componentType == "uint16" + +def test_imread(): + image = imread(test_input_file_path) + verify_image(image) + +def test_write_image(): + image = read_image(test_input_file_path) + + use_compression = False + write_image(image, test_output_file_path, use_compression=use_compression) + + image = read_image(test_output_file_path) + verify_image(image) + +def test_imwrite(): + image = imread(test_input_file_path) + + use_compression = False + imwrite(image, test_output_file_path, use_compression=use_compression) + + image = imread(test_output_file_path) + verify_image(image)